ZappBots wishes a warm welcome to everyone.

Especially our visitors from
Savage///Circuits and Parallax!!!


Please take a look our new forums, we hope you register and become an active user.

The ZappBots forums are being run on phpBB 3.1.4 software .

The important thing is we have a place toTalk, Learn and Showcase our projects.

LED matrixing.

This is the place to talk about Parallax Propeller Chip and Boards
User avatar
jknightandkarr
VIP
VIP
Posts: 811
Joined: Tue May 12, 2015 5:11 pm
Location: Hopelessly lost on the USS-Titanic 968 years from home....
Contact:

LED matrixing.

Postby jknightandkarr » Tue Jun 13, 2023 3:44 pm

Might need some info on multiplexing with the propeller... I am currently looking at objects written for 7 seg and 14/16 seg displays, will post them later, but thinking for my bargraph displays, I should be able to rewrite those objects, once I relearn a little, to allow them so scan 12 or 24 seg displays. replace the no of digits to no of columns, and the number of segments to number of leds. More later.

User avatar
jknightandkarr
VIP
VIP
Posts: 811
Joined: Tue May 12, 2015 5:11 pm
Location: Hopelessly lost on the USS-Titanic 968 years from home....
Contact:

Re: LED matrixing.

Postby jknightandkarr » Tue Jun 13, 2023 5:31 pm

Here's the 2 codes i was looking at.

Code: Select all


CON

    _CLKMODE=XTAL1+PLL16x                               'System Clock
    _XINFREQ=5_000_000                                  'Set 80 Mhz
    isEnabled=%0001                                     'Enable Display

VAR

    LONG LowDigitPin, HighDigitPin                      'The pins for specifying digits.
                                                        'Must be contiguous
                                                        'HighDigitPin can be from 0 to 7 more than LowDigitPin
    LONG Seg0Pin, Seg8Pin                               'The pins for the segments.
                                                        'Must be contiguous
                                                        'Segment 8 is the decimal point
    BYTE LDP, Dig, Seg, Sensor, Setting                 'Display, Calibration & Speed Settings
    LONG flags, ms, LDP, Dig
    LONG myStack[10]                                    'Display Stack Space
    LONG runningCogID
    LONG myValue, displayValue                          'Value to be displayed
    LONG vss                                            'Vehical Speed Sensor Input
    LONG Mph, Kph                                       'Display In Miles or Kilometers Per Hour
    LONG stack0[20], stack1[20]                         'Counter & Display Space

PUB Start                                               
     
    COGNEW (Count, @stack0)                             'Start Counting VSS Signals
    COGNEW (Display, @stack1)                           'Start Display

PUB Count

    'Settings:
    PIN:=12                                             'Set I/O pin 12 as input

    DIRA[PIN]~                                          'Set PIN to Input
    REPEAT                                              'Start Repeat Loop
      CTRA:=0                                           'Clear Counter
      CTRA[30..26]:=%01010                              'Set Counter Bits 26-30 to POSEDGE detector
      CTRA[5..0]:=PIN                                   'Set Counter Bits 0-5 to I/O PIN
      FRQA:=1                                           'Send Pulses Count to PHSA
      PHSA:=0                                           'Clear PHSA
      WAITCNT(CLKFREQ+CNT)                              'Wait 1 Second
      vss:=PHSA                                         'Send PHSA value to vss
      CTRA:=0                                           'Clear Counter

PUB Display

    'SETTINGS:
    Sensor:=13                                          'Speed Sensor Calibration 4K or 8K ppm
    Setting:=14                                         'Mph or Kph readout
    LDP:=8                                              'Start Pin of Digit Display
    Dig:=4                                              'No of Digits in Display
    Seg:=0                                              'Start Pin of Segments
   
    REPEAT                                              'Start infinite repeat loop
      IF INA[Sensor]==1                                 'Check for 4K or 8Kppm speed sensor
         Mph:=vss*9/2                                   'Calibrate for 8000ppm sender if pin 13=Low
      ELSE
         Mph:=vss*9                                     'Calibrate for 4000ppm Sensor if pin 13=High
      IF INA[Setting]==1                                'Check for Mph or Kph setting
         Kph:=Mph*1_609_344/1_000_000                   'Display speed in Kph
      ELSE
         Kph:=Mph*1                                     'Display speed in Mph
      myValue := Kph                                    'Copy Kph to myValue
      Tones                                             'Goto Tones Object
      LowDigitPin:=LDP                                  'Set low digit pin
      HighDigitPin:=LDP + ((Dig - 1) <# 7)              'Set hight digit pin & limit to eight digits
      Seg0Pin := Seg                                    'Set first segment to 0
      Seg8Pin := Seg + 7                                'Set last segment to 8
      DIRA[Seg0Pin..Seg8Pin]~~                          'Set segment pins to outputs
      DIRA[LowDigitPin..HighDigitPin]~~                 'Set digit pins to outputs
      OUTA[Seg0Pin..Seg8Pin]~                           'Turn off all segments
      DIRA[LowDigitPin..HighDigitPin]~~                 'Turn off all digits
     'if enabled                                        'Set initial enabled state
      flags |= isEnabled
      'else                                             'Enable flags
      'flags~
      stop                                              'Stop the display
      runningCogID := COGNEW(ShowValue, @myStack) + 1   'Display the current speed

PUB Stop

    '' Stop the display
    IF runningCogID
      COGSTOP(runningCogID~ - 1)

PUB Enable

    '' Enable the display
    flags |= isEnabled

PUB Disable

    '' Disable the display
    flags &= !isEnabled
 
PUB SetValue(theValue)

    '' Set the value to display
    myValue := theValue

PRI ShowValue | digPos, divisor

    'ShowValue runs in its own cog and continually updates the display
    DIRA[Seg0Pin..Seg8Pin]~~                            'Set segment pins to outputs
    DIRA[LowDigitPin..HighDigitPin]~~                   'Set digit pins to outputs
    REPEAT
      IF flags & isEnabled
        displayValue := myValue                         'Take snapshot of myValue so it can't be changed
                                                        'while it is being displayed.
        divisor := 1                                    'Divisor is used to isolate a digit to display.
      REPEAT digPos FROM 0 TO HighDigitPin-LowDigitPin  'Only display as many digits as there are pins.
        OUTA[Seg0Pin..Seg8Pin]~                         'Clear the segments to avoid flicker.
        OUTA[LowDigitPin..HighDigitPin]:=BYTE[@DigSel+digPos] 'Enable the next digit.
        OUTA[Seg0Pin..Seg8Pin]:=BYTE[@Digit0+displayValue/divisor//10] 'Display the digit.
        WAITCNT(CLKFREQ/10_000+CNT)                     'The delay value can be tweaked to adjust
                                                        'display Brightness.
        divisor *= 10
      ELSE
        OUTA[LowDigitPin..HighDigitPin]~~               'Disable all digits.
        WAITCNT (CLKFREQ / 10 + CNT)                    'Wait 1/10 second before checking again.
     
Pub Tones                 

    IF Kph<>displayValue                                'Check & compare values
                                                        'Goto Freqout if values are different.
       FREQOUT
    ELSE                                                'End if values are equal.
   
PUB FREQOUT '(Pin,Duration, Freq1, Freq2)

    'Update(Pin, Duration, Freq1, Freq2)
    Update(27,500,0)                                    'Set Freq 1
    'Update(27,770,1)                                   'Set Freq 2 (Optional)
    WAITCNT((CLKFREQ/1000)*56+CNT)                      'Set duration pause
    Update(27,0,0)                                      'Stop all tones
    'Update(27,0,1)
   
   
PRI Update(pin2, freq, ch) | temp

    {updates either the A or B counter modules.

    PARAMETERS:
      pin  - I/O pin to transmit the square wave
      freq - The frequency in Hz
      ch   - 0 for counter module A, or 1 for counter module B
    RERTURNS:
      The value of cnt at the start of the signal
      Adapted from Code by Andy Lindsay}


    IF freq == 0                                        'Freq=0, turns off square wave
        WAITPEQ(0, |< pin, 0)                           'Wait for low signal
        DIRA[pin2]~                                     'Set I/O Pin to Input
        IF ch==0
          CTRA := 0                                     'Set CTRA/B to 0
        ELSE
          CTRB := 0                                     'Set CTRA/B to 0

         
    temp := pin2                                        'CTRA/B[8..0]:=pin
    temp += (%00100 << 26)                              'CTRA/B[30..26]:=%00100
    IF ch==0                                            'If ch=0 use counter A else use counter B
      CTRA := temp                                      'Copy temp to CTRA
      FRQA := calcFrq(freq)                             'Set FRQA
      PHSA := 0                                         'Clear PHSA (start cycle low)
    ELSE
      CTRB := temp                                      'Copy temp to CTRB
      FRQB := calcFrq(freq)                             'Set FRQB
      PHSB := 0                                         'Clear PHSB (start cycle low)
    DIRA[pin2]~~                                        'Make pin output
    RESULT := CNT                                       'Return the start time

PRI CalcFrq(freq)

    {Solve FRQA/B = frequency * (2^32) / clkfreq with binary LONG
    division (Thanks Chip!- signed Andy).
 
    Note: My version of this method relied on the FloatMath object.
    Not surprisingly, Chip's solution takes a fraction program space,
    memory, and time.  It's the binary LONG-division approach, which
    implements with the binary
    long division approach - Andy Lindsay, Parallax } 

    REPEAT 33                                   
      RESULT <<= 1
      IF freq => CLKFREQ
        freq -= CLKFREQ
        RESULT++       
      freq <<= 1     

DAT   
    'Common cathode 7-segment displays are activated by bringing the cathode to ground
    DigSel          BYTE    %11111110
                    BYTE    %11111101
                    BYTE    %11111011
                    BYTE    %11110111
                    BYTE    %11101111
                    BYTE    %11011111
                    BYTE    %10111111
                    BYTE    %01111111
                   
    'Digit Patterns         %.GFEDCBA
    Digit0          BYTE    %00111111
    Digit1          BYTE    %00000110
    Digit2          BYTE    %01011011
    Digit3          BYTE    %01001111
    Digit4          BYTE    %01100110
    Digit5          BYTE    %01101101
    Digit6          BYTE    %01111101
    Digit7          BYTE    %00000111
    Digit8          BYTE    %01111111
    Digit9          BYTE    %01100111


Code: Select all

{{General purpose Sixteen-segment alpha-numeric display object. Can display up to 14 characters.

  Note that a 14 character display requires 30 Propeller I/O pins, leaving only two pins
  for either USB or EEPROM connection. See CharSel table in DAT section for a display with
  more than six characters.
             
  Author:  Steven R. Stuart (Adapted from Steve Nicholson's Seven-segment display object)
  Version: 1.4

  History: 1.5 (21-Jul-2010) Fixed error when displaying 9 or more characters
           1.4 (20-Dec-2009) Added character code checking to ensure display chars fall within the
                              character table. Default display has been set to six characters.
           1.3 (16-Dec-2009) Fixed error in CharSel table. Fixed error in curly bracket patterns
           1.2 (04-Dec-2009) Increased display support to 14 chars. Map lower case chars to   
                              upper case chars to avoid redundant table entries
           1.1 (02-Dec-2009) Added local display buffer
           1.0 (14-Nov-2009) Initial release

           See end of file for terms of use.
}}

VAR                                           
  long LowCharPin, HighCharPin                          'The pins for specifying chars.
                                                        ' Must be contiguous
                                                        ' HighCharPin can be from 0 to 13 more than LowCharPin
  long Seg0Pin, Seg15Pin                                'The pins for the segments.
                                                        ' Must be contiguous
  long flags
  long stack[10]   
  long runningCogID
 
CON
  isEnabled  = %0001                                    'Display ENABLE flag

PUB Start(charRt, chars, s0, enabled)
''Start the display
''Parameters:
''   charRt - the cathode pin number of the rightmost character
''   chars - the number of characters to display  (up to 14)
''   s0 - the pin number of segment 0 (segment a1)
''   enabled - the initial enabled state

  LowCharPin := charRt
  HighCharPin := charRt + ((chars - 1) <# 13)           'Limit to 14 chars
  Seg0Pin := s0
  Seg15Pin := s0 + 15
  dira[Seg0Pin..Seg15Pin]~~                             'Set segment pins to outputs
  dira[LowCharPin..HighCharPin]~~                       'Set char pins to outputs
  outa[Seg0Pin..Seg15Pin]~                              'Turn off all segments
  dira[LowCharPin..HighCharPin]~~                       'Turn off all chars
  if enabled                                            'Set initial enabled state
    flags |= isEnabled
  else
    flags~
  stop
  runningCogID := cognew(ShowStr, @stack) + 1

PUB Stop
''Shutdown the display
  if runningCogID
    cogstop(runningCogID~ - 1)

PUB Enable
''Enable the display
  flags |= isEnabled

PUB Disable
''Disable (blank) the display
  flags &= !isEnabled

PUB SetDisplay(strAddr)
''Move the desired display string to local buffer 
  bytemove(DspBuff,strAddr,14)
     
PRI ShowStr | stringPos, char, bias
' ShowStr runs in its own cog and continually updates the display
  dira[Seg0Pin..Seg15Pin]~~                             'Set segment pins to outputs
  dira[LowCharPin..HighCharPin]~~                       'Set character pins to outputs
  repeat
    if flags & isEnabled
      repeat stringPos from 0 to HighCharPin - LowCharPin 'Get next char position
        char := byte[DspBuff+stringPos]&127 #>32        'Get char and validate
        case char                                       'Adjust char table pointer
          "a".."z": bias := -128                        ' Map lowercase to uppercase
          123..127: bias := -116                        ' Adjust chars above the lowcase set
          other   : bias := -64                         ' Skip unprintable chars       
        outa[Seg15Pin..Seg0Pin]~                        'Clear the segments to avoid flicker                                                       
        outa[LowCharPin..HighCharPin] := word[@CharSel +stringPos *2] 'Enable the next character
        outa[Seg15Pin..Seg0Pin] := word[@CharTab +char *2 +bias] 'Output the pattern
        waitcnt (clkfreq / 10_000 + cnt)                'This delay value can be tweaked to adjust
                                                        ' display brightness
    else
      outa[HighCharPin..LowCharPin]~~                   'Disable all characters
      waitcnt (clkfreq / 10 + cnt)                      'Wait 1/10 second before checking again
     
DAT
{{
┌──────────────────────────────────────────────────────────────────────────────────────────┐
│ASCII character codes 0 through 31 are normally unprintable control codes and most have no│
│defined 16-segment pattern so have been excluded from the display table.                  │
│Characters outside the range of 32..127 will display as a space character (code Asc_032)  │
└──────────────────────────────────────────────────────────────────────────────────────────┘
}}
  CharTab
'                    Character table                 
'                   ─────────────────
'      segments:     mlkjihggfeddcbaa
'                          21  21  21
{
  Asc_000   word    %0000000000000000   'NUL    (Null char)
  Asc_001   word    %0000000000000000   'SOH    (Start of Header)
  Asc_002   word    %0000000000000000   'STX    (Start of Text)
  Asc_003   word    %0000000000000000   'ETX    (End of Text)
  Asc_004   word    %0000000000000000   'EOT    (End of Transmission)
  Asc_005   word    %0000000000000000   'ENQ    (Enquiry)
  Asc_006   word    %0000000000000000   'ACK    (Acknowledgment)
  Asc_007   word    %0000000000000000   'BEL    (Bell)
  Asc_008   word    %0000000000000000   'BS     (Backspace)
  Asc_009   word    %0000000000000000   'HT     (Horizontal Tab)
  Asc_010   word    %0000000000000000   'LF     (Line Feed)
  Asc_011   word    %0000000000000000   'VT     (Vertical Tab)
  Asc_012   word    %0000000000000000   'FF     (Form Feed)
  Asc_013   word    %0000000000000000   'CR     (Carriage Return)
  Asc_014   word    %0000000000000000   'SO     (Shift Out)
  Asc_015   word    %0000000000000000   'SI     (Shift In)
  Asc_016   word    %0000000000000000   'DLE    (Data Link Escape)
  Asc_017   word    %0000000000000000   'DC1    (Device Control 1) (XON)
  Asc_018   word    %0000000000000000   'DC2    (Device Control 2)
  Asc_019   word    %0000000000000000   'DC3    (Device Control 3) (XOFF)
  Asc_020   word    %0000000000000000   'DC4    (Device Control 4)
  Asc_021   word    %0000000000000000   'NAK    (Negative Acknowledgemnt)
  Asc_022   word    %0000000000000000   'SYN    (Synchronous Idle)
  Asc_023   word    %0000000000000000   'ETB    (End of Trans. Block)
  Asc_024   word    %0100101100110010   'CAN    (Cancel)
  Asc_025   word    %0101011100000000   'EM     (End of Medium)
  Asc_026   word    %0100101111110011   'SUB    (Substitute)
  Asc_027   word    %0000101000000110   'ESC    (Escape)
  Asc_028   word    %0001010011000000   'FS     (File Separator)
  Asc_029   word    %0100101100110000   'GS     (Group Separator)
  Asc_030   word    %1110100000000000   'RS     (Reqst to Send)(Rec. Sep.)
  Asc_031   word    %0101110000000000   'US     (Unit Separator)
}
  Asc_032   word    %0000000000000000   'SP     (Space) 
  Asc_033   word    %0100100000110000   '!      (exclamation mark)
  Asc_034   word    %0000100010000000   '"      (double quote)
  Asc_035   word    %1111111111111111   '#      (number sign)
  Asc_036   word    %0100101110111011   '$      (dollar sign)
  Asc_037   word    %1101101110101001   '%      (percent)
  Asc_038   word    %1101100000111010   '&      (ampersand)
  Asc_039   word    %0001000000000000    '      (single quote)
  Asc_040   word    %0011000000000000   '(      (left/open parenthesis)
  Asc_041   word    %1000010000000000   ')      (right/closing parenth.)
  Asc_042   word    %1111111100000000   '*      (asterisk)
  Asc_043   word    %0100101100000000   '+      (plus)
  Asc_044   word    %1000000000000000   ',      (comma)
  Asc_045   word    %0000001100000000   '-      (minus or dash)
  Asc_046   word    %0100000101100000   '.      (dot)
  Asc_047   word    %1001000000000000   '/      (forward slash)
  Asc_048   word    %1001000011111111   '0
  Asc_049   word    %0000000000001100   '1
  Asc_050   word    %0000001101110111   '2
  Asc_051   word    %0000001000111111   '3
  Asc_052   word    %0000001110001100   '4
  Asc_053   word    %0000001110111011   '5
  Asc_054   word    %0000001111111001   '6
  Asc_055   word    %0000000000001111   '7
  Asc_056   word    %0000001111111111   '8
  Asc_057   word    %0000001110111111   '9
  Asc_058   word    %0100100000000000   ':      (colon)
  Asc_059   word    %1000100000000000   ';      (semi-colon)
  Asc_060   word    %0011000000000000   '<      (less than)
  Asc_061   word    %0000001100110000   '=      (equal sign)
  Asc_062   word    %1000010000000000   '>      (greater than)
  Asc_063   word    %0100001000000110   '?      (question mark)
  Asc_064   word    %0000101011110111   '@      (AT symbol)
  Asc_065   word    %0000001111001111   'A
  Asc_066   word    %0100101000111111   'B
  Asc_067   word    %0000000011110011   'C
  Asc_068   word    %0100100000111111   'D
  Asc_069   word    %0000001111110011   'E
  Asc_070   word    %0000000111000011   'F
  Asc_071   word    %0000001011111011   'G
  Asc_072   word    %0000001111001100   'H
  Asc_073   word    %0100100000110011   'I
  Asc_074   word    %0000000001111100   'J
  Asc_075   word    %0011000111000000   'K
  Asc_076   word    %0000000011110000   'L
  Asc_077   word    %0001010011001100   'M
  Asc_078   word    %0010010011001100   'N
  Asc_079   word    %0000000011111111   'O
  Asc_080   word    %0000001111000111   'P
  Asc_081   word    %0010000011111111   'Q
  Asc_082   word    %0010001111000111   'R
  Asc_083   word    %0010010000110011   'S
  Asc_084   word    %0100100000000011   'T
  Asc_085   word    %0000000011111100   'U
  Asc_086   word    %1001000011000000   'V
  Asc_087   word    %1010000011001100   'W
  Asc_088   word    %1011010000000000   'X
  Asc_089   word    %0101010000000000   'Y
  Asc_090   word    %1001000000110011   'Z
  Asc_091   word    %0100100000100010   '[      (left/opening bracket)
  Asc_092   word    %0010010000000000   '\      (back slash)
  Asc_093   word    %0100100000010001   ']      (right/closing bracket)
  Asc_094   word    %1001000000000110   '^      (caret/circumflex)
  Asc_095   word    %0000000000110000   '_      (underscore)
  Asc_096   word    %0000010000000000   '`      (back tick)
{
  Asc_097   word    %0000001111001111   'a       
  Asc_098   word    %0100101000111111   'b     
  Asc_099   word    %0000000011110011   'c       Lower case characters are mapped
  Asc_100   word    %0100100000111111   'd       to upper case patterns
  Asc_101   word    %0000001111110011   'e       
  Asc_102   word    %0000000111000011   'f
  Asc_103   word    %0000001011111011   'g
  Asc_104   word    %0000001111001100   'h
  Asc_105   word    %0100100000110011   'i
  Asc_106   word    %0000000001111100   'j
  Asc_107   word    %0011000111000000   'k         
  Asc_108   word    %0000000011110000   'l         
  Asc_109   word    %0001010011001100   'm         
  Asc_110   word    %0010010011001100   'n
  Asc_111   word    %0000000011111111   'o
  Asc_112   word    %0000001111000111   'p
  Asc_113   word    %0010000011111111   'q
  Asc_114   word    %0010001111000111   'r
  Asc_115   word    %0010010000110011   's
  Asc_116   word    %0100100000000011   't
  Asc_117   word    %0000000011111100   'u
  Asc_118   word    %1001000011000000   'v
  Asc_119   word    %1010000011001100   'w
  Asc_120   word    %1011010000000000   'x
  Asc_121   word    %0101010000000000   'y
  Asc_122   word    %1001000000110011   'z
}
  Asc_123   word    %0100100100010010   '{      (left/opening brace)
  Asc_124   word    %0100100000000000   '|      (vertical bar)
  Asc_125   word    %0100101000100001   '}      (right/closing brace)
  Asc_126   word    %0000001101000100   '~      (tilde)
  Asc_127   word    %0100001011111111   'DEL    (delete)

' Common cathode 16-segment displays are activated by bringing the cathode to ground
  CharSel   word    %11111111_11111110  'Rightmost character
            word    %11111111_11111101 
            word    %11111111_11111011
            word    %11111111_11110111
            word    %11111111_11101111
            word    %11111111_11011111                                         
            word    %11111111_10111111 
            word    %11111111_01111111 
            word    %11111110_11111111 
            word    %11111101_11111111
            word    %11111011_11111111
            word    %11110111_11111111
            word    %11101111_11111111
            word    %11011111_11111111  'Leftmost character of a 14 char display     

  DspBuff   byte    "00000000000000"    '14-byte display buffer

{{

User avatar
Savage///Circuits
VIP
VIP
Posts: 849
Joined: Tue May 12, 2015 2:43 pm
Location: Palmyra, NY
Contact:

Re: LED matrixing.

Postby Savage///Circuits » Fri Jun 16, 2023 9:40 am

What information were you looking for? I wrote an object for the PPDB to use the 16-segment displays on that board. There was also a demo. Since then, I have seen numerous objects that users developed for their specific needs, but the principles are all the same, with some differences in the hardware (direct drive vs shift registers).
Image
I'm only responsible for what I say, not what you understand.
Visit Savage///Circuits

User avatar
jknightandkarr
VIP
VIP
Posts: 811
Joined: Tue May 12, 2015 5:11 pm
Location: Hopelessly lost on the USS-Titanic 968 years from home....
Contact:

Re: LED matrixing.

Postby jknightandkarr » Fri Jun 16, 2023 10:56 am

Generally just suggestions if my current attempt has issues.

Code: Select all

{{General purpose Seven-segment display object. Can control from one to eight digits.

   Author: Steve Nicholson
   Version: 1.0 (4 Jan 2007)
   Email: [email protected]
   Copyright: none

}}

VAR
  long LowDigitPin, HighDigitPin                        'The pins for specifying digits.
                                                        ' Must be contiguous
                                                        ' HighDigitPin can be from 0 to 7 more than LowDigitPin
  long Seg00Pin, Seg23Pin                                 'The pins for the segments.
                                                        ' Must be contiguous
                                                        ' Segment 8 is the decimal point
  long flags
  long myStack[10]
  long runningCogID
  long myValue

CON
  isEnabled = %0001

PUB Start(dLow, digits, s0, enabled)
'' Start the display
'' Parameters:
''   dLow - the pin number of the least significant digit
''   digits - the number of digits to display  (up to 8)
''   s0 - the pin number of segment 0
''   enabled - the initial enabled state
  myValue := 0
  LowDigitPin := dLow
  HighDigitPin := dLow + ((digits - 1) <# 7)            'Limit to eight digits
  Seg00Pin := s0
  Seg23Pin := s0 + 24
  dira[Seg00Pin..Seg23Pin]~~                              'Set segment pins to outputs
  dira[LowDigitPin..HighDigitPin]~~                     'Set digit pins to outputs
  outa[Seg00Pin..Seg23Pin]~                               'Turn off all segments
  dira[LowDigitPin..HighDigitPin]~~                     'Turn off all digits
  if enabled                                            'Set initial enabled state
    flags |= isEnabled
  else
    flags~
  stop
  runningCogID := cognew(ShowValue, @myStack) + 1

PUB Stop
'' Stop the display
  if runningCogID
    cogstop(runningCogID~ - 1)

PUB Enable
'' Enable the display
  flags |= isEnabled

PUB Disable
'' Disable the display
  flags &= !isEnabled

PUB SetValue(theValue)
'' Set the value to display
  myValue := theValue

PRI ShowValue | digPos, divisor, displayValue
' ShowValue runs in its own cog and continually updates the display
  dira[Seg00Pin..Seg23Pin]~~                              'Set segment pins to outputs
  dira[LowDigitPin..HighDigitPin]~~                     'Set digit pins to outputs
  repeat
    if flags & isEnabled
      displayValue := myValue                           'take snapshot of myValue so it can't be changed
                                                        ' while it is being displayed
      divisor := 1                                      'divisor is used to isolate a digit to display
      repeat digPos from 0 to HighDigitPin - LowDigitPin 'only display as many digits as there are pins
        outa[Seg00Pin..Seg23Pin]~                         'clear the segments to avoid flicker
        outa[LowDigitPin..HighDigitPin] := byte[@Row + digPos] 'enable the next digit
        outa[Seg00Pin..Seg23Pin] := byte[@Seg00 + displayValue / divisor // 10] 'display the digit
        waitcnt (clkfreq / 10_000 + cnt)                'the delay value can be tweaked to adjust
                                                        ' display brightness
        divisor *= 10
    else
      outa[LowDigitPin..HighDigitPin]~~                 'disable all digits
      waitcnt (clkfreq / 10 + cnt)                      'wait 1/10 second before checking again

DAT
        'Common cathode 7-segment displays are activated by bringing the cathode to ground
        Row             byte    %11111110
                        byte    %11111101
                        byte    %11111011
                        byte    %11110111
                        byte    %11101111
                        byte    %11011111
                        byte    %10111111
                        byte    %01111111

        Seg00          byte    %000000000000000000000000
        Seg01          byte    %000000000000000000000000
        Seg02          byte    %000000000000000000000000
        Seg03          byte    %000000000000000000000000
        Seg04          byte    %000000000000000000000000
        Seg05          byte    %000000000000000000000000
        Seg06          byte    %000000000000000000000000
        Seg07          byte    %000000000000000000000000
        Seg08          byte    %000000000000000000000000
        Seg09          byte    %000000000000000000000000
        Seg10          byte    %000000000000000000000000
        Seg11          byte    %000000000000000000000000
        Seg12          byte    %000000000000000000000000
        Seg13          byte    %000000000000000000000000
        Seg14          byte    %000000000000000000000000
        Seg15          byte    %000000000000000000000000
        Seg16          byte    %000000000000000000000000
        Seg17          byte    %000000000000000000000000
        Seg18          byte    %000000000000000000000000
        Seg19          byte    %000000000000000000000000
        Seg20          byte    %000000000000000000000000
        Seg21          byte    %000000000000000000000000
        Seg22          byte    %000000000000000000000000
        Seg23          byte    %000000000000000000000000
        Seg24          byte    %000000000000000000000000

My current attempt, still need todo patterns for the Seg##, but other then that I think it should be ready to try, just need to modify the demo to work with it, which I am going to try soon. Yeah, shift registers would be a good idea i think. Don't have to run lot of wires between displayboards.


Return to “Parallax Propeller Chip and Boards”

Who is online

Users browsing this forum: No registered users and 4 guests