' **********************************************************************
' * File:   gmbiob.bas - Rel. 1.1 con Bascom AVR IDE e LIB 1.11.7.4    *
' * Schede: GMB HR168 + GMM AM128                                      *
' * GRIFO(R)   via Dell'Artigiano 8/6   40016 S. Giorgio di Piano (BO) *
' *     Tel. +39 051 892052                      Fax. +39 051 893661   *
' *     http://www.grifo.com                     http://www.grifo.it   *
' *     by Graziano Gaiba                               del 15.06.05   *
' **********************************************************************
'
' 15.06.05 - Rel 1.1 By Graziano Gaiba
'  Questo Demo permette di utilizzare immediatamente le uscite bufferate
'  a rele` disponibili su CN3 e CN4 e gli ingressi optoisolati su CN1 e
'  CN2.
'  Tramite la console si puo' settare lo stato deglii otto rele' di
'  uscita oppure rappresentare lo stato dei 16 ingressi NPN/PNP.
'  Inoltre vengono applicate le funzionalita' evolute offerte dal Mini
'  Modulo, come ad esempio ingressi contati via hw o che generano interrupt, ecc.
'
'
'
' !!!!!!!!!!!!!!!!!!!!!!!!!!! IMPORTANTE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
' Nel menu Options | Compiler | Chip, impostare:
'
' Chip:       M128
' HW Stack:   almeno 64
' Soft Stack: almeno 32
' Framesize:  almeno 64
'
'
'****************** Direttive del compilatore **************************
'
$regfile = "m128def.dat"
$crystal = 7372800
$baud = 19200


On Int4 Risp_int4 Nosave
On Int5 Risp_int5 Nosave
On Int6 Risp_int6 Nosave
On Timer2 Risp_int_t2 Nosave
'
'****************** Dichiarazione delle costanti ***********************
'
Const Cret = 13                                             ' Codice di ritorno di carrello
Const Nl = 10                                               ' Codice nuova linea
Const Clrscr = 12                                           ' codice di clear screen
Const Bell = 7                                              ' codice di Bell
'
Const Ee_timeout = 50000
'
'****************** Dichiarazione delle variabili **********************
'

' Uso generico
Dim V As Byte , S As Byte , T As Byte                       ' Byte di uso generico

' Contatore interrupts
Dim Cntintr4 As Byte , Cntintr5 As Byte , Cntintr6 As Byte , Cntintt2 As Byte
'
'****************** Dichiarazione delle procedure **********************
'
Declare Sub Init()                                          ' Inizializzazione
Declare Sub Set_relays_out(byval V As Byte)                 ' Imposta lo stato dei rele'
Declare Function Get_opto_in_a() As Byte                    ' Legge gli ingressi Opto A
Declare Function Get_opto_in_b() As Byte                    ' Legge gli ingressi Opto B
Declare Sub Richiedi_tasto()
Declare Function Leggi_attesa() As Byte
Declare Sub Check_ready()
Declare Function Check_ready_2() As Byte
'
'************************* Programma main ******************************
'
Main:

Call Init()                                                 ' Inzializza il modulo

Do
   Call Set_relays_out(0)
   Print Chr(clrscr);                                       ' Pulisce lo schermo
   Print "Demo 1.1 per GMM AM128 + GMB HR168"
   Print
   Call Check_ready()                                       ' Verifica scheda pronta
   Do
      Print "Esempio di utilizzo degli ingressi su CN1,CN2 e delle uscite su CN3,CN4"
      Print
      Print "1) Input digitali"
      Print "2) Uscite a rele'"
      Print
      Print "SELEZIONE: ";
      Do
         V = Inkey()
      Loop Until V <> 0

      Print Chr(v)

      If V = "1" Then
         Print "Ingressi optoisolati su CN1 e CN2"
         Do
            Call Richiedi_tasto()
            Print "CN1  CN2"
            Do
               T = Get_opto_in_a()
               Print Hex(t) ; "   ";
               T = Get_opto_in_b()
               Print Hex(t) ; "   ";
               Printbin Cret
               S = Leggi_attesa()
            Loop Until S <> 0

            Print
            Print
            Print "IN3 e' anche trigger di int4, IN4 di int5 e IN6 di int6."
            Print "Una transizione H-L attiva l'interrupt che incrementa il relativo contatore."
            Call Richiedi_tasto()
            Print "INT4 INT5 INT6"
            Eicrb.0 = 0                                     ' Int4 triggers on falling edge
            Eicrb.1 = 1
            Eicrb.2 = 0                                     ' Int5 triggers on falling edge
            Eicrb.3 = 1
            Eicrb.4 = 0                                     ' Int5 triggers on falling edge
            Eicrb.5 = 1
            Enable Int4                                     ' Enables int4
            Enable Int5                                     ' Enables int5
            Enable Int6                                     ' Enables int6
            Enable Interrupts                               ' Enables interrupts
            Cntintr4 = 0                                    ' Resets interrupt counters
            Cntintr5 = 0
            Cntintr6 = 0
            Do
               ' Prints interrupt counters
               Print Hex(cntintr4) ; "   " ; Hex(cntintr5) ; "   " ; Hex(cntintr6) ;
               Printbin Cret                                ' Back to line beginning
               S = Leggi_attesa()
            Loop Until S <> 0                               ' Exits when key pressed
            Disable Interrupts                              ' Disables interrupts
            Disable Int6                                    ' Disables int6
            Disable Int5                                    ' Disables int5
            Disable Int4                                    ' Disables int4

         Loop Until S <> 0

         Print
         Print
         Print "T0 e' configurato come contatore,IN5 e' il suo trigger"
         Print "Ogni overflow genera un interrupt"
         Call Richiedi_tasto()
         Cntintt2 = 0
         ' Bisogna SEMPRE fermare i timer prima di riconfigurarli
         Stop Timer2
         ' Configura Timer 0 come counter sulle transizione H->L del pin T0.
         Config Timer2 = Counter , Edge = Falling
         Counter2 = &HE0                                    ' Valore iniziale
         Enable Timer2                                      ' Abilita interrupt overflow timer 0
         Enable Interrupts                                  ' Abilita gli interrupt
         Start Timer2
         Print "T2 N.INT"
         Do
            Print Hex(counter2) ; " " ; Hex(cntintt2);      'Stampa contatore
            ' Leggere counter2 ferma automaticamente timer2, bisogna riattivarlo
            Start Timer2
            Printbin Cret                                   ' Torna a inizio riga
            S = Leggi_attesa()
         Loop Until S <> 0                                  ' Esce alla pressione di un tasto
         Disable Interrupts
         Disable Timer2
         Stop Timer2
      End If


      If V = "2" Then
         Print Chr(clrscr);
         Print "Demo uscite rele'"
         Print
         Call Set_relays_out(0)
         Do
            Inputhex "Digitare cifra hex (00 esce): " , S
            Print Hex(s)
            Call Set_relays_out(s)                          ' Imposta le uscite
         Loop Until S = 0
         Call Set_relays_out(0)
      End If
   Loop
Loop

Risp_int4:
      Incr Cntintr4                                         ' Incrementa contatore interrupt
Return

Risp_int5:
      Incr Cntintr5                                         ' Incrementa contatore interrupt
Return

Risp_int6:
      Incr Cntintr6                                         ' Incrementa contatore interrupt
Return

Risp_int_t2:
      Incr Cntintt2                                         ' Incrementa contatore interrupt
Return

End
'
'************************ Fine del programma ***************************
'
'
'
'
'******************************************************************************
'*               Procedure di gestione degli I/O della GMB HR168              *
'******************************************************************************
'
'
'
' Imposta le uscite a rele'
' Se il Bit e' 1 il corrispondente rele' viene chiuso, altrimenti viene aperto
' OUT A1 - Portf.4
' OUT A2 - Portf.5
' OUT B1 - Portf.6
' OUT B2 - Portf.7
' OUT C1 - Portb.3
' OUT C2 - Portb.2
' OUT D1 - Portb.1
' OUT D2 - Porte.2 (di default, ovvero con J10 in 3-4)
'
' V.0 comanda RL1 OUT A1
' V.1 comanda RL2 OUT A2
' V.2 comanda RL3 OUT B1
' V.3 comanda RL4 OUT B2
' V.4 comanda RL5 OUT C1
' V.5 comanda RL6 OUT C2
' V.6 comanda RL7 OUT D1
' V.7 comanda RL8 OUT D2
Sub Set_relays_out(byval V As Byte)
   Portf.4 = Not V.0
   Portf.5 = Not V.1
   Portf.6 = Not V.2
   Portf.7 = Not V.3
   Portb.3 = Not V.4
   Portb.2 = Not V.5
   Portb.1 = Not V.6
   Porte.2 = Not V.7
End Sub
'
'
' Legge gli ingressi optoisolati di CN2
'
Function Get_opto_in_a() As Byte

   Local V_in As Byte
   ' IN1-1 - Portb.7
   ' IN2-1 - Portb.6
   ' IN3-1 - Porte.4
   ' IN4-1 - Porte.5
   ' IN5-1 - Portd.7
   ' IN6-1 - Porte.6
   ' IN7-1 - Portb.4
   ' IN8-1 - Portb.0
   '
   ' V_in.0 legge IN1-1
   ' V_in.1 legge IN2-1
   ' V_in.2 legge IN3-1
   ' V_in.3 legge IN4-1
   ' V_in.4 legge IN5-1
   ' V_in.5 legge IN6-1
   ' V_in.6 legge IN7-1
   ' V_in.7 legge IN8-1
   V_in.0 = Not Pinb.7
   V_in.1 = Not Pinb.6
   V_in.2 = Not Pine.4
   V_in.3 = Not Pine.5
   V_in.4 = Not Pind.7
   V_in.5 = Not Pine.6
   V_in.6 = Not Pinb.4
   V_in.7 = Not Pinb.0

   Get_opto_in_a = V_in
End Function
'
'
' Legge gli ingressi optoisolati di CN1
'
Function Get_opto_in_b() As Byte

   Local V_in As Byte
   ' IN1-2 - Portc.0
   ' IN2-2 - Portc.1
   ' IN3-2 - Portc.2
   ' IN4-2 - Portc.3
   ' IN5-2 - Portc.4
   ' IN6-2 - Portc.5
   ' IN7-2 - Portc.6
   ' IN8-2 - Portc.7
   '
   ' V_in.0 legge IN1-2
   ' V_in.1 legge IN2-2
   ' V_in.2 legge IN3-2
   ' V_in.3 legge IN4-2
   ' V_in.4 legge IN5-2
   ' V_in.5 legge IN6-2
   ' V_in.6 legge IN7-2
   ' V_in.7 legge IN8-2
   V_in = Not Pinc

   Get_opto_in_b = V_in
End Function
'
'******************************************************************************
'*                  Procedure di gestione specifiche del demo                 *
'******************************************************************************
'
'
'
' Inizializza il demo
'
Sub Init()
' Inizializza la direzionalita' dei port che pilotano gli ingressi optoisolati
' e le uscite a rele':
' IN1-1 - Portb.7
' IN2-1 - Portb.6
' IN3-1 - Porte.4
' IN4-1 - Porte.5
' IN5-1 - Portd.7
' IN6-1 - Porte.6
' IN7-1 - Portb.4
' IN8-1 - Portb.0
   Ddrb.7 = 0
   Ddrb.6 = 0
   Ddre.4 = 0
   Ddre.5 = 0
   Ddrd.7 = 0
   Ddre.6 = 0
   Ddrb.4 = 0
   Ddrb.0 = 0
' IN1-2 - Portc.0
' IN2-2 - Portc.1
' IN3-2 - Portc.2
' IN4-2 - Portc.3
' IN5-2 - Portc.4
' IN6-2 - Portc.5
' IN7-2 - Portc.6
' IN8-2 - Portc.7
   Ddrc = 0
' OUT A1 - Portf.4
' OUT A2 - Portf.5
' OUT B1 - Portf.6
' OUT B2 - Portf.7
' OUT C1 - Portb.3
' OUT C2 - Portb.2
' OUT D1 - Portb.1
' OUT D2 - Porte.2 (di default, ovvero con J10 in 3-4)
   Ddrf.4 = 1
   Ddrf.5 = 1
   Ddrf.6 = 1
   Ddrf.7 = 1
   Ddrb.3 = 1
   Ddrb.2 = 1
   Ddrb.1 = 1
   Ddre.2 = 1
End Sub
'
'******************************************************************************
'*                         Procedure di uso generico                          *
'******************************************************************************
'
'
' Stampa il messaggio "Premere tasto per uscire"
'
Sub Richiedi_tasto()
   Print
   Print "Premere tasto per uscire"
   Print
End Sub
'
'
' Attende 200 msec poi legge un tasto e lo restituisce
'
Function Leggi_attesa()

   Waitms 200
   Leggi_attesa = Inkey()

End Function
'
'
' Funzione di supporto della Check_ready().
'
Function Check_ready_2() As Byte

  Local Time_out As Word , I As Byte

  Time_out = 0                                              ' Contatore timeout
  Do
     Incr Time_out                                          ' Incrementa contatore
  Loop Until Twcr.twint = 1 Or Time_out = Ee_timeout
  I = Twsr
  I = I And &HF8
  Check_ready_2 = I
End Function
'
'
' Controlla che la scheda sia pronta
'
Sub Check_ready()

   Local Check As Byte , Test As Byte

   Do                                                       ' Ciclo attesa scheda pronta
      Twsr = Twsr And &HFC
      Check = Twdr Or &HF4
      Test.4 = Not Check.3
      Twbr = 72
      Twcr = &HA4
      Check = Check_ready_2()
      Test = Check Or Twcr
      If Check = &H09 Then
         Test = &H67
      Else
         Test.1 = Not Test.1
      End If
      Twdr = &HA0
      Twcr = &H84
      Check = Check_ready_2()
      Twcr = &H94
      Waitms 27
   Loop Until Check = &H18 Or Test <> 1
   Twcr.twen = 0
End Sub