'******************************************************************
'*  Nome      : gmbiot.bas                                        *
'*  Autore    : Graziano GAIBA                                    *
'*  Data      : 05/05/04                                          *
'*  Versione  : 1.1                                               *
'*  Scheda    : GMM 876 + GMB HR84                                *
'*  Linguaggio: PIC BASIC Standard  Ver. 1.45                     *
'*  Azienda   : Copyright (c) 2004 grifo(r) ITALIAN Technology    *
'*            : All Rights Reserved                               *
'*            : Tel.: +39 051 892052        Fax: +39 051 893661   *
'*            : http://www.grifo.com         http://www.grifo.it  *
'*            : sales@grifo.it   tech@grifo.it    grifo@grifo.it  *
'******************************************************************
'
' Questo Demo permette di utilizzare immediatamente le linee di I/O digitale
' TTL presenti su CN4. Alla partenza viene presentata la lista delle linee
' disponibili.
' Una Volta Selezionata Quella d'interesse la si puo' gestire in input
' (rappresentando Il Suo Stato Sulla Console) o in output
' (settandola alta o bassa).
'
' Per la comunicazione, viene usata la seriale hardware implementata
' nel demo Usart.bas del PIC Basic standard opportunamente
' modificata.
'
'
' *********************************************************************
' *                       Definizioni e Costanti                      *
' *********************************************************************
'
' Registri del PIC
symbol  INDF  = 0
symbol  FSR   = $04
' Port di I/O
symbol  PORTA = $05
symbol  TRISA = $85 ' banco 1
symbol  PORTB = $06
symbol  TRISB = $86 ' banco 1
symbol  PORTC = $07
symbol  TRISC = $87 ' banco 1
symbol  ADCON0 = $1F
symbol  ADCON1 = $9F ' banco 1
'
symbol  OPTION_REG = $81 ' banco 1
'
' Simboli usati dalla seriale hardware implementata
' nel demo Usart.bas del PIC Basic standard 
' Definizione registri USART
Symbol PIR1  = $0C             ' Registro Peripheral Interrupt Flag
Symbol RCSTA = $18             ' Registro di stato e controllo ricezione
Symbol TXREG = $19             ' Dato da trasmettere
Symbol RCREG = $1A             ' Dato ricevuto
Symbol TXSTA = $98             ' Registro di stato e controllo trasmissione
Symbol SPBRG = $99             ' Registro del Baud Rate Generator
'
'
' *********************************************************************
' *                  Variabili usate dal programma                    *
' *********************************************************************
'
'
' Usate dall'USART
SYMBOL UsartST  = B0           ' Stato dell'USART
SYMBOL UsartOut = B1           ' Carattere da inviare
symbol UsartIn  = B2           ' Carattere ricevuto

' Valore da stampare come stringa
symbol Valore    = B3

' Uso Generico
SYMBOL i = B4
SYMBOL c = B5
symbol z = B6

' Usato dall'input di un valore esadecimale
symbol ValoreHex    = B7
symbol ValoreHexMSB = B8

' Usato dall'interrupt del Timer 2
symbol CntInt = B9

' Usata per inizializzare il Baud Rate Generator
symbol ValBRG = B10

'Usate per selezionare pin ed azione
symbol Pin_scelto = B11
symbol Port_scelto = B12
symbol Azione = B13
'
'
' *********************************************************************
' *                          Programma main                           *
' *********************************************************************
'
Main:
        gosub Module_init       ' Inizializzazione
        ' Apre tutti i relays
        B0 = 0
        gosub set_relays
        
        for i=0 to 35
            lookup i,("Demo per GMM 876 e GMB HR84 Rel. 1.1"),usartout
            gosub charout
        next i
        gosub nlcr
        gosub nlcr
        ' Scelta tra i pin utilizzabili come I/O TTL
        ' 1) Pin 2
        ' 2) Pin 3
        ' 3) Pin 5
        ' 4) Pin 6
        ' 5) Pin 8
        for i=0 to 92
            lookup i,("Su CN4 questi pin sono I/O TTL:",13,10,"1) Pin 2",13,10,"2) Pin 3",13,10,"3) Pin 5",13,10,"4) Pin 6",13,10,"5) Pin 8",13,10,13,10,"Scelta: "),usartout
            gosub charout
        next i
' Attende un carattere tra "1" e "5" e lo stampa
Mainloop1:
        gosub CharIn
        if usartin < "1" or usartin > "5" then Mainloop1
        pin_scelto = usartin - "0" - 1
        usartout = usartin
        gosub charout
        gosub nlcr
        lookup pin_scelto,(PORTA, PORTB, PORTB, PORTC, PORTA),port_scelto
        if pin_scelto <> 4 then main_continua
        for i=0 to 116
            lookup i,("Su questo pin sono presenti un pull-down ed un partitore.",13,10,"Consultare il manuale GMB HR84 per ulteriori informazioni."),usartout
            gosub charout
        next i        
        gosub nlcr
        gosub nlcr
Main_continua:
        for i=0 to 30
            lookup i,("1) Input",13,10,"2) Output",13,10,13,10,"Scelta: "),usartout
            gosub charout
        next i
' Attende un carattere tra "1" e "5" e lo stampa
Mainloop2:
        gosub CharIn
        if usartin < "1" or usartin > "5" then Mainloop2
        azione = usartin - "0" - 1
        usartout = usartin
        gosub charout
        gosub nlcr
        gosub nlcr
        branch azione,(Demo_in, Demo_out)
        goto main
end
'
'
' *********************************************************************
' *                      Fine del programma                           *
' *********************************************************************
'
'
' Inizializzazione della GMM 876
Module_init:
        ' Spengo l'A/D converter
        poke adcon0, 0
        ' Imposta Port A come input digitale
        poke ADCON1, 7
        '
        ' Inizializza USART per 19200 Baud
        W0 = 19200
        gosub calcolabrg_hs
        Poke SPBRG,valbrg       ' Imposta baud rate a 19200
        Poke RCSTA,%10010000    ' Abilita porta seriale e ricezione continua
        Poke TXSTA,%00100100    ' Abilita tramsissione, modalita' asincrona e
                                ' baud rate elevati
        ' Rimettere la pagina 0 prima di uscire dall'asm
        'ASM
        'ENDASM
        pause 500                      
    return
'
'
' Demo di utilizzo delle linee TTL di CN4 come ingressi
Demo_in:
        ' Imposta come ingressi le linee RA3, RA5, RB2, RB3 ed RC2
        peek trisa, B0
        bit3 = 1
        bit5 = 1
        poke trisa, B0
        '
        peek trisb, B0
        bit2 = 1
        bit3 = 1
        poke trisb, B0
        '
        peek trisc, B0
        bit2 = 1
        poke trisc, B0
        '
        for i=0 to 54
            lookup i,("Viene visualizzato continuamente l'ingresso selezionato"),usartout
            gosub charout
        next i
        gosub nlcr
        gosub chieditasto
        gosub nlcr
Demo_in_loop:        
        for i=0 to 6
            lookup i,("Stato: "),usartout
            gosub charout
        next i
        ' Legge l'ingressi digitale selezionato
        B0 = 0
        peek port_scelto, B1
        ' Isola il bit dell'ingresso selezionato in B0
        branch pin_scelto, (isola_b3,isola_b3,isola_b2,isola_b2)
        ' Isola il bit 5 (pin scelto = pin 8 ovvero RA5)
        bit0 = bit13
        goto stampa_stato
Isola_b2:
        ' Isola il bit 2 (pin scelto = pin 5 o 6 ovvero RB2 o RC2)        
        bit0 = bit10
        goto stampa_stato
Isola_b3:
        ' Isola il bit 3 (pin scelto = pin 2 o 3 ovvero RA3 o RB3)        
        bit0 = bit11
Stampa_stato:
        ' Stampa il valore letto in esadecimale
        valore = B0
        gosub stampanibblehex
        ' Torna a capo
        gosub cr
        pause 300
        ' Verifica se un tasto e' stato premuto
        gosub charin
        ' Se nessun tasto e' stato premuto, ripeti
        if usartin = 0 then demo_in_loop
        ' Esci
        gosub nlcr
        gosub nlcr
    goto main
'
'
' Demo di utilizzo delle linee TTL di CN4 come uscite
Demo_out:
        ' Imposta come uscite le linee RA3, RA5, RB2, RB3 ed RC2
        peek trisa, B0
        bit3 = 0
        bit5 = 0
        poke trisa, B0
        '
        peek trisb, B0
        bit2 = 0
        bit3 = 0
        poke trisb, B0
        '
        peek trisc, B0
        bit2 = 0
        poke trisc, B0
        '
        for i=0 to 78
            lookup i,("Viene impostato (0 o 1) lo stato del segnale selezionato, premere 2 per uscire."),usartout
            gosub charout
        next i
        gosub nlcr
        gosub nlcr
Demo_out_loop:        
        for i=0 to 6
            lookup i,("Stato: "),usartout
            gosub charout
        next i
        ' Legge la scelta dell'utente
        valorehex = 0
        gosub inputhex2
        if valorehex > 1 then demo_esci
        B0 = valorehex
        ' Pone il valore digitato nel bit corrispondente al pin scelto
        branch pin_scelto, (poni_b3,poni_b3,poni_b2,poni_b2)
        ' Pone nel bit 5 (pin scelto = pin 8 ovvero RA5)
        peek port_scelto, B1
        bit13 = bit0
        goto imposta_stato
Poni_b2:
        ' Isola il bit 2 (pin scelto = pin 5 o 6 ovvero RB2 o RC2)        
        peek port_scelto, B1
        bit10 = bit0
        goto imposta_stato
Poni_b3:
        ' Isola il bit 3 (pin scelto = pin 2 o 3 ovvero RA3 o RB3)        
        peek port_scelto, B1
        bit11 = bit0
Imposta_stato:
        ' Imposta lo stato del pin scelto dall'utente
        poke port_scelto, B1
        ' Prosegue
        goto demo_out_loop
        ' Esci
Demo_esci:
        gosub nlcr
        gosub nlcr
    goto main
'
'
' Questa procedura imposta lo stato dei relays di una GMB HR84.
' La corrispondenza tra bit del paramertro, linea di I/O e relay e':
'        Bit 0  ->    RB4     ->      A1
'        Bit 1  ->    RB5     ->      A2
'        Bit 2  ->    RB6     ->      B1
'        Bit 3  ->    RB7     ->      B2
' Il parametro in ingresso e' la variabile B0, viene distrutto il
' contenuto della variabile B1.
' Per ogni segnale, il rispettivo bit ha il seguente significato:
'        bit a 0 ->  Relay aperto
'        bit a 1 ->  Relay chiuso
Set_relays:
        B0 = B0 ^ $0F
        peek portb, B1
        bit12 = bit0
        bit13 = bit1
        bit14 = bit2
        bit15 = bit3
        poke portb, B1
    return
    '
'
' Calcola il valore per inizializzare il Baud Rate Generator in modalita'
' ad alta velocita'.
' Il Baud Rate desiderato si trova nella variabile W0, il risultato,
' ovvero il valore da scrivere nel registro SPBRG, si trova nella
' variabile ValBRG.
' Si ricorda che per attivare la modalita' ad alta velocita' bisogna
' porre ad 1 il bit 2 del registro TXSTA (BRGH).
CalcolaBRG_HS:
        '           Fquarzo
        ' ValBRG = -------- - 1
        '          16 * BR
        valbrg = 0
        
        if W0 = 9600 then val_9600_hs
        if W0 = 19200 then val_19200_hs
        if W0 = 38400 then val_38400_hs
        if W0 = 57600 then val_57600_hs
        if W0 = 115200 then val_115200_hs
        goto esci_hs
        
val_9600_hs:
        valbrg = 129
        goto esci_hs
val_19200_hs:
        valbrg = 64
        goto esci_hs
val_38400_hs:
        valbrg = 32
        goto esci_hs
val_57600_hs:
        valbrg = 21
        goto esci_hs
val_115200_hs:
        valbrg = 10
        goto esci_hs
esci_hs:
    return
'
'
' Calcola il valore per inizializzare il Baud Rate Generator in modalita'
' a bassa velocita'.
' Il Baud Rate desiderato si trova nella variabile W0, il risultato,
' ovvero il valore da scrivere nel registro SPBRG, si trova nella
' variabile ValBRG.
' Si ricorda che per attivare la modalita' a bassa velocita' bisogna
' porre a 0 il bit 2 del registro TXSTA (BRGH).
CalcolaBRG_LS:
        '           Fquarzo
        ' ValBRG = -------- - 1
        '          64 * BR        
        valbrg = 0
        
        if W0 = 1200 then val_1200_ls
        if W0 = 2400 then val_2400_ls
        if W0 = 9600 then val_9600_ls
        if W0 = 19200 then val_19200_ls
        if W0 = 76800 then val_76800_ls
        goto esci_hs
        
val_1200_ls:
        valbrg = 255
        goto esci_hs
val_2400_ls:
        valbrg = 129
        goto esci_hs
val_9600_ls:
        valbrg = 32
        goto esci_hs
val_19200_ls:
        valbrg = 15
        goto esci_hs
val_76800_ls:
        valbrg = 3
        goto esci_ls
esci_ls:
    return
'
'
' Stampa due spazi
DueSpazi:   
        usartout = " "           ' Spazio
        gosub charout
        gosub charout
    return
'
'
' Trasforma il valore esadecimle nella variabile Valore in caratteri
' ASCII e li invia alla porta seriale.
' Valore deve essere compreso tra 0 e 0FFh.
StampaHex:
        usartout = valore / 16
        gosub hexdecode
        gosub charout
StampaNibbleHex:
        usartout = valore & $0F
        gosub hexdecode
        gosub charout
    return
'
HexDecode:
        Lookup usartout,("0123456789ABCDEF"),usartout
    return
'
HexEncode:
        lookDown usartin,("0123456789abcdef"),usartin
    return
'
'
' Manda a capo su una riga sotto
NLCR:   usartout = 10            ' New Line
        gosub charout
CR:     usartout = 13            ' Carriage Return
        gosub charout
    return
'
'
' Input di un valore esadecimale da 000 a FFF poi va a capo
InputHex3:
        gosub charin
        if usartin = 0 then InputHex3
        usartout = usartin
        gosub charout
        usartin = usartin | $20
        gosub hexencode
        valorehexMSB = usartin
InputHex:
        gosub charin
        if usartin = 0 then InputHex
        usartout = usartin
        gosub charout
        usartin = usartin | $20
        gosub hexencode
        valorehex = usartin * 16
InputHex2:
        gosub charin
        if usartin = 0 then InputHex2
        usartout = usartin
        gosub charout
        usartin = usartin | $20
        gosub hexencode
        valorehex = valorehex + usartin
        gosub nlcr
    return
'
'
' Attende un carattere dalla porta seriale
ChiediTasto:
        for i = 0 to 33
            lookup i,("Premere un tasto per continuare..."),usartout
            gosub charout
        next i
        gosub NLCR
    return

AttendiTasto:
        gosub charin
        if usartin = 0 then AttendiTasto
    return
'
'
' Subroutine che invia un carattere al trasmettitore USART
' (sospensiva)
CharOut: 
        Peek pir1,UsartST       ' Leggi il Flag in UsartST = B0
        If Bit4 = 0 Then charout ' Attendi che si svuoti il registro di
                                 ' trasmissione
        Poke TXREG,Usartout       ' Metti il carattere nel registro di
                                 ' trasmissine
    Return                       ' Ritorno al chiamante
'
'
' Subroutine che preleva un carattere dal ricevitore dell'USART
' (non sospensiva)
CharIn: UsartIn = 0             ' Preset a nessun carattere ricevuto
        Peek PIR1,Usartst       ' Leggi il Flag in UsartST = B0
        If Bit5 = 0 Then ciret  ' Se il flag di ricezione e' 0, esci
        Peek RCREG,UsartIn      ' Altrimenti metti il carattere ricevuto
                                ' in UsartIn = B1
ciret:  
    Return