'****************************************************************
'*  Name    : scroll8ch.BAS                                      *
'*  Author  : zuisti                                            *
'*  Date    : 2007.09.04.                                       *
'*  Version : 1.0  (1044 words)                                             *
'****************************************************************

        Device = 16F628A
        XTAL = 4

        OPTIMISER_LEVEL = 3

        ' max. 54 chars (and 2 spaces for gap) buffer for scrolling message
        Symbol BUFFERSIZE 56
        Dim buffer[BUFFERSIZE] As Byte

        Dim bitmap_index As Word

        Dim FirstPos As Byte
        Dim NextPos  As Byte
        Dim CharCnt  As Byte

        Dim ScrollTime As Byte
        Dim scrollcnt  As Byte

        Dim mode    As Byte
        Dim charnum As Byte
        Dim linenum As Byte
        Dim pattern As Byte

        Dim idx      As Byte
        Dim startidx As Byte
        Dim endidx   As Byte

        Dim ch As Byte  'used only under interrupt: received char

        Symbol LINEPORT PORTA ' outputs for Line decoder: PORTA<2:0> ;RA0 = LSB
        Symbol LINES_OFF 7    ' decoder IC output 7 is "free", 0...6 are use

        ' Mode switch input: PORTA.4 ;RA4   (0: scrolling, 1: static)
        Symbol MODESWITCH PORTA.4

        Symbol CLOCK_PIN PORTB.0   ' for shift regs clocking in
        Symbol DATA_PIN  PORTB.7   ' the data itself
        Symbol STORE_PIN PORTA.3   ' clock the shift reg's output storage

        Symbol PORT_POS_SWITCH PORTB      ' pos/speed switch inputs: PORTB<6:3>
        Symbol MASK_POS_SWITCH %01111000  ' RB3 = SW_1 , sum value *8 !!
        Symbol SPEEDMAX 5                 ' fastest scroll if the speed switch 0

    Declare FSR_CONTEXT_SAVE = On ' indirect addressing is used under IT too

    ON_HARDWARE_INTERRUPT GoTo SerialIT ' receive only !

' ***************** Program starts here

    GoSub HW_Init

    ' setup for positive pulses:
    STORE_PIN = 0 : CLOCK_PIN = 0 : DATA_PIN = 0
    GoSub DisplayClear
    mode = MODESWITCH
    FirstPos = PORT_POS_SWITCH & MASK_POS_SWITCH ' value * 8
    If mode = 0 Then        ' scroll
        scrollcnt = 0
        ScrollTime = FirstPos + SPEEDMAX
        FirstPos = 0
        NextPos = BUFFERSIZE
    Else                    ' static               
        NextPos = FirstPos + 8
    EndIf
    startidx = 0
    endidx = BUFFERSIZE
    INTCON = $C0 : PIE1 = $20 'enable global ITs and RX it

    While 1=1  ' main loop (forever)

        If mode = 0 Then ' in scrolling mode only
            Inc scrollcnt
            If scrollcnt = ScrollTime Then
                scrollcnt = 0
                ScrollTime = (PORT_POS_SWITCH & MASK_POS_SWITCH) + SPEEDMAX
                Disable ' IT
                ' for a scrolling gap
                If CharCnt < (BUFFERSIZE - 3) Then
                    If startidx < ( CharCnt + 2 ) Then
                        endidx = CharCnt + 3                       
                    End If
                End If
                Enable ' IT   
                Inc startidx
                If startidx = endidx Then startidx = 0
                LINEPORT = LINES_OFF ' disable lines               
            End If
        End If

        linenum = 7 ' line loop
        Repeat
            Dec linenum
            idx = startidx
           
            charnum = 8 ' character loop
            Repeat
                GoSub GetPatternAndOut       
                Inc idx
                If idx = endidx Then idx = 0
                Dec charnum
            Until charnum = 0 ' end of character loop               

            LINEPORT = LINES_OFF           ' disable lines
            STORE_PIN = 1 : STORE_PIN = 0  ' store  pulse
            LINEPORT = linenum             ' switch on the actual line
            DelayUS 250
        Until linenum = 0 ' end of line loop               
   
    Wend  ' end of main loop

' ************ subroutines

SerialIT:

        ch = RCREG ' read the received char
        If ch < 32 Then
            If ch = 13 Then GoSub DisplayClear
        Else
            Inc CharCnt
            If ch > $7F Then ch = "?"
            ch = ch - 32
            If  CharCnt < NextPos Then If CharCnt >= FirstPos Then buffer[CharCnt - FirstPos] = ch
        EndIf                                 

    Context Restore ' return from interrupt with restore regs

HW_Init:

        CMCON = %00000111 ' switch off comparators
        TRISA = %10110000 ' 7, 5 and 4 PORTA pins are inputs

        ' Initialize USART module for receive (RX) only:
       TXSTA.2 = 1 'BRGH 
        SPBRG = 25 '9600 Bd at 4 M clock
        RCSTA = %10010000           ' 8 bit, no parity
        ch = RCREG : ch = RCREG     ' empty rx fifo

        TRISB = %01111110           ' only PORTB.0 and PORTB.7 are outputs

    Return ' Hw_init

DisplayClear:

        LINEPORT = LINES_OFF 'disable lines
        CharCnt = BUFFERSIZE
        Repeat
            Dec CharCnt
            buffer[CharCnt] = 0
        Until CharCnt = 0
        Dec CharCnt
        idx = 0
        startidx = 0

    Return ' DisplayClear

GetPatternAndOut:

        bitmap_index = buffer[idx] * 8 ' 8 byte/char in bitmap table (for easier computing)
        pattern = LRead8 bitmap[bitmap_index + linenum] ' 7 bite as line pattern (first the 0)
        pattern = ~pattern ' only if we are using common cathode displays in Proteus

        'out the low 5 bits of pattern       
        If pattern.4 = 1 Then DATA_PIN = 1
        CLOCK_PIN = 1 : CLOCK_PIN = 0: DATA_PIN = 0 ' out a clock pulse and restore data pin to 0
        If pattern.3 = 1 Then DATA_PIN = 1
        CLOCK_PIN = 1 : CLOCK_PIN = 0: DATA_PIN = 0
        If pattern.2 = 1 Then DATA_PIN = 1
        CLOCK_PIN = 1 : CLOCK_PIN = 0: DATA_PIN = 0
        If pattern.1 = 1 Then DATA_PIN = 1
        CLOCK_PIN = 1 : CLOCK_PIN = 0: DATA_PIN = 0
        If pattern.0 = 1 Then DATA_PIN = 1
        CLOCK_PIN = 1 : CLOCK_PIN = 0: DATA_PIN = 0

    Return ' GetPatternAndOut

    Include "bitmap.inc"    ' LDATA table, lenght = 300H

' ********************
    'Stop ' end of program

//PIC 8char dotmatrix, switchable to static-scrolling
//prg lenght 1077 words, made by zuisti, 29.08.2007

//for a simple and fast PROTEUS simulation I am not using line drivers !
#define COMMON_CATHODE

#define BUFFERSIZE 56
//max. 54 chars (and 2 gap space) for scrolling message

char buffer[BUFFERSIZE]; //display buffer: 8 chars + 2 spaces(gap for scrolling)

char FirstPos, NextPos, CharCnt, ScrollTime;

char mode, scrollcnt, charnum, linenum, pattern;

char *ptr, *startptr, *endptr;

#include "bitmap.h"

//pos/speed switch inputs: PORTB<6:3> ;RB2 = SW_1 , sum value *8 !!
#define SWITCHVALUE8 PORTB & 0b01111000
// in STATIC mode (cascadable): position in the received string
// in SCROLLING mode: scrolling speed (smaller value is faster)
#define SPEEDMAX 5

//Mode switch input: PORTA.4 ;RA4   (0: scrolling, 1: static)
#define STATICMODE Porta.F4
//checked at start only

//Line decoder outputs: PORTA<2:0> ;RA0 = LSB
#define DisableLines PORTA = 0b0111  //all 1, decoder outputs are active low


//Clock  output: PORTB.0    ;RB0
//Data   output: PORTB.7    ;RB7

//Store  output: PORTA.3  (RA3), positive clock for shiftregs output storage
#define StorePulse PORTA.F3 = 1; PORTA.F3 = 0
//setup for positive pulses
#define PinInits      PORTA.F3 = 0; PORTB.F0 = 0; PORTB.F7 = 0

/*
ClockoutPatternBit(X): Data = pattern.FX followed by an positive clock pulse
I am using here (too) a little asm, this is much shorter as the pure C
*/
#define ClockoutPatternBit(X) asm { btfsc _pattern, X }; \
                                             asm { bsf PORTB, 7 }; \
                                             PORTB.F0 = 1; PORTB.F0 = 0; \
                                             PORTB.F7 = 0

//RX      input: PORTB.1    ;RB1

//this is used in IT
void DisplayClear(void) {
   DisableLines;
   CharCnt = BUFFERSIZE;   //init the display buffer with zeroes
   do
      buffer[--CharCnt] = 0;
   while ( CharCnt );
   --CharCnt;    //= 255, the first received char increments it to zero
   ptr = startptr = buffer;
}

void interrupt() {
   char ch = RCREG;

   if ( ch < 0x20 ) {
      if ( ch == 0x0D )
         DisplayClear();
   }
   else if ( ++CharCnt < NextPos && CharCnt >= Firstpos ) {
      if ( ch > 0x7F )
         ch = '?';
      *((char *)(buffer + (short)(CharCnt-FirstPos))) = ch - 0x20;
   }
}

void GetPatternAndOut() {
#ifdef COMMON_CATHODE
   pattern = ~(bitmap[ (*ptr << 3)+ linenum ]);
#else
   pattern = bitmap[ (*ptr << 3)+ linenum ];
#endif

   ClockoutPatternBit(4);
   ClockoutPatternBit(3);
   ClockoutPatternBit(2);
   ClockoutPatternBit(1);
   ClockoutPatternBit(0);
}

void DisplayLine(void) {
   DisableLines;
   StorePulse;
   PORTA = linenum;
   Delay_us(300);
}

void HW_Init(void) {

   CMCON = 0b00000111; // switch off comparators
   TRISA = 0b10110000; // 7, 5 and 4 PORTA pins are inputs

// Initialize USART module for receive (rx) only:
   TXSTA.BRGH = 1;   SPBRG = 25;                           //9600 Bd at 4 M clock
   RCSTA = 0b10010000;                                       // 8 bit, no parity
   asm {MOVF   RCREG, 0}; asm {MOVF   RCREG, 0};   //empty rx fifo in asm (short)

   TRISB = 0b01111110;   // only PORTB.0 and PORTB.7 are outputs
}

void main(void) {

   HW_Init();
   PinInits;
   DisplayClear();

   if ( !( mode = (char) STATICMODE ) ) { // 0 = scrolling mode
      FirstPos = 0;
      NextPos = BUFFERSIZE;
    scrollcnt = 0;
      ScrollTime = ( SWITCHVALUE8 ) + SPEEDMAX;
   }
   else {       //static mode
      NextPos = ( FirstPos = SWITCHVALUE8 ) + 8;
   }

  startptr = buffer;
   endptr = buffer + BUFFERSIZE;
   
   INTCON = 0xC0; PIE1 = 0x20;               //enable global ITs and RX it

   for ( ; ; ) { // main loop forever

      //scrolling mode (mode = 0) ?
      if ( !mode && ++scrollcnt == ScrollTime ) {
         scrollcnt = 0;
         ScrollTime = ( SWITCHVALUE8 ) + SPEEDMAX;   //check the speed sw again

         //for a gap
         INTCON = 0;               //disable IT
         if ( CharCnt < (BUFFERSIZE - 3) && startptr < ( buffer + CharCnt + 2 ) )
            endptr = buffer + CharCnt + 3;
         INTCON = 0xC0;         //enable IT

         if ( ++startptr == endptr )
             startptr = buffer;
         DisableLines;
      }

      linenum = 7;
      do {
         --linenum;
         ptr = startptr;
         charnum = 8;
         do {
            GetPatternAndOut();
            if (++ptr == endptr )
               ptr = buffer;
         } while ( --charnum );
         DisplayLine();
      } while ( linenum );

   } // end loop
}