Marsy Electronic

-> mcHID.dll <-

Primo esempio: Interfaccia I/O

Per agevolare l'apprendimento della comunicazione USB ho realizzato 3 esempi differenti che sfruttano la comunicazione USB. Partono dal più facile al più difficile. Questo che sto per presentarvi è la realizzazione di una scheda capace di gestire delle entrate e delle uscite, e tale controllo e visione viene effettuata tramite un software opportuno, eseguito sul pc, tutto gestito attraverso dei semplici click. Il circuito è quello base con in più 4 uscite rappresentate da 4 led e 4 entrate rappresentate da 4 pulsanti. Ecco il circuito:

clicca per ingrandire

Come vedete è molto semplice anche questo circuito, e ovviamente verrà sempre collegato al pc tramite la porta USB. Ora passiamo al firmware, questa volta è stato modificato il ciclo aggiungendo la lettura di ogni singolo byte proveniente dal pc per il controllo di ogni singolo led, e successivamente viene fatto il controllo su ogni singola porta dove ci sono i pulsanti per poi costruire il pacchetto di dati da inviare al pc. In pratica il pic e il pc si scambiano un pacchetto di dati di 4byte, tipo 0110, che rappresentano lo stato delle porte per quanto riguarda delle uscite si tratt di RB0:RB3 e per quanto riguarda le uscite RB4:RB7. Ecco il firmware:

program usb_io

dim readbuff as char[64] absolute 0x500 ' Buffers should be in USB RAM, please consult datasheet
dim writebuff as char[64] absolute 0x540

sub procedure Interrupt()
USB_Interrupt_Proc() ' USB servicing is done inside the interrupt
end sub

main:
     ADCON1 = ADCON1 or 0x0F                         ' Configura tutte le porte analogiche come digitali
     CMCON = CMCON or 7                             ' Disabilita i comparatori
     PORTB=0
     PORTA=0
     TRISB=%11110000
     TRISA.0=0
     HID_Enable(@readbuff,@writebuff)                ' Abilita la comunicazione HID

     while TRUE
           while(HID_Read() = 0)                     ' Leggo i dati provenienti dal pc
           wend

           if readbuff[0]="1" then                   ' Analizzo i primi 4 caratteri dell'intero
                portb.0=1                            ' pacchetto ricevuto e per ogni carattere
            else                                     ' decido l'uscita se deve essere alta o bassa
                portb.0=0
           end if

           if readbuff[1]="1" then
                portb.1=1
           else
                portb.1=0
           end if

           if readbuff[2]="1" then
                portb.2=1
           else
                portb.2=0
           end if

if readbuff[3]="1" then
 portb.3=1
 else
 portb.3=0
 end if

 if Button(PortB, 4, 1, 1) then ' Invece quì leggo lo stato delle porte
 writebuff="1" ' e creo il pacchetto di dati che
 else ' verrà inviato al pc
 writebuff="0" end if if Button(PortB, 5, 1, 1) then writebuff=writebuff+"1" else writebuff=writebuff+"0" end if if Button(PortB, 6, 1, 1) then writebuff=writebuff+"1" else writebuff=writebuff+"0" end if if Button(PortB, 7, 1, 1) then writebuff=writebuff+"1" else writebuff=writebuff+"0" end if while(HID_Write(@writebuff,64) = 0) ' Invio di dati al PC
 wend
 wend
end.

Anche questo è ampiamente commentato. La funzione Button ha 4 parametri: PORTB è il tipo di porta che dovrà tenere sotto controllo, 4 è il numero della porta, quindi RB4, 50 sono i millisecondi che deve durare l'impulso per essere riconosciuto come una pressione di un pulsante, questo per evitare disturbi e 1 è lo stato della porta nel momento in cui viene premuto il pulsante. La funziona è vera quando viene premuto il pulsante. Tutto il resto è identico al progetto base.

Se questa era la parte Hardware, ora passiamo alla parte software. Si basa sempre sul primo progetto, quello base; quello che cambia sono queste funzioni:

    Private Sub led0_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles led0.Click
        If led0.BackStyle = PowerPacks.BackStyle.Transparent Then
            led0.BackStyle = PowerPacks.BackStyle.Opaque
        Else
            led0.BackStyle = PowerPacks.BackStyle.Transparent
        End If
    End Sub

    Private Sub led1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles led1.Click
        If led1.BackStyle = PowerPacks.BackStyle.Transparent Then
            led1.BackStyle = PowerPacks.BackStyle.Opaque
        Else
            led1.BackStyle = PowerPacks.BackStyle.Transparent
        End If
    End Sub

    Private Sub led2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles led2.Click
        If led2.BackStyle = PowerPacks.BackStyle.Transparent Then
            led2.BackStyle = PowerPacks.BackStyle.Opaque
        Else
            led2.BackStyle = PowerPacks.BackStyle.Transparent
        End If
    End Sub

    Private Sub led3_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles led3.Click
        If led3.BackStyle = PowerPacks.BackStyle.Transparent Then
            led3.BackStyle = PowerPacks.BackStyle.Opaque
        Else
            led3.BackStyle = PowerPacks.BackStyle.Transparent
        End If
    End Sub

Private Sub Riempi(ByVal mod1 As String, ByVal mod2 As String, ByVal mod3 As String, ByVal mod4 As String) ' Analizza il pacchetto
 If mod1 = "1" Then ' ricevuto e aggiorna di
 If led4.BackStyle <> PowerPacks.BackStyle.Opaque Then led4.BackStyle = PowerPacks.BackStyle.Opaque ' conseguenza l'intrfaccia
 Else
 If led4.BackStyle <> PowerPacks.BackStyle.Transparent Then led4.BackStyle = PowerPacks.BackStyle.Transparent
 End If
 If mod2 = "1" Then
 If led5.BackStyle <> PowerPacks.BackStyle.Opaque Then led5.BackStyle = PowerPacks.BackStyle.Opaque
 Else
 If led5.BackStyle <> PowerPacks.BackStyle.Transparent Then led5.BackStyle = PowerPacks.BackStyle.Transparent
 End If
 If mod3 = "1" Then
 If led6.BackStyle <> PowerPacks.BackStyle.Opaque Then led6.BackStyle = PowerPacks.BackStyle.Opaque
 Else
 If led6.BackStyle <> PowerPacks.BackStyle.Transparent Then led6.BackStyle = PowerPacks.BackStyle.Transparent
 End If
 If mod4 = "1" Then
 If led7.BackStyle <> PowerPacks.BackStyle.Opaque Then led7.BackStyle = PowerPacks.BackStyle.Opaque
 Else
 If led7.BackStyle <> PowerPacks.BackStyle.Transparent Then led7.BackStyle = PowerPacks.BackStyle.Transparent
 End If
 End Sub

Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick ' Ogni 10ms aggiorna l'interfaccia
 Dim dato As String ' inviando un pacchetto di dati
 If led0.BackStyle = PowerPacks.BackStyle.Opaque Then ' con scritto quali led accendere
 dato = "1" Else dato = "0" End If If led1.BackStyle = PowerPacks.BackStyle.Opaque Then dato = dato & "1" Else dato = dato & "0" End If If led2.BackStyle = PowerPacks.BackStyle.Opaque Then dato = dato & "1" Else dato = dato & "0" End If If led3.BackStyle = PowerPacks.BackStyle.Opaque Then dato = dato & "1" Else dato = dato & "0" End If Invia(dato) End Sub Non credo sia molti complicato questo codice. Vorrei far notare che rappresento le uscite con dei cerchi simili a dei led di colore verde. Nel momento in cui passa allo stato alto l'uscita, il colore di sfondo del cerchio diventa opaco e quindi si vede il verde, mentre allo stato basso lo sfondo del cerchio diventa trasparente e qundi come la finestra, grigio. Ecco la foto dell'applicazione:

Nel riquadro delle uscite, si può cambiare lo stato di ognuna semplicemente cliccandoci sopra, questa diventerà verde o grigia, a seconda dello stato precedente. C'è un timer importante nell'applicazione. Le funzioni all'interno del timer vengono eseguite ogni 10 milli secondi e si tratta di un controllo simile a quello sul microcontrollore, ovvero, controlla lo stato delle porte RB0, RB1, RB2, RB3 e costruisce il pacchetto di dati, in questo caso come nell'immagine il pacchetto che il pc invierebbe al pic sarebbe "0111", ricordandosi sempre che il primo byte "BufferOut(0)" deve sempre essere posto a 0, questo vale per qualsiasi tipo di applicazione; e poi aspetta la risposta dal pic che a sua volta controlla lo stato delle porte RB4, RB5, RB6, RB7 e invia il relativo pacchetto dati al pc, il quale lo rappresenterà attraverso i 4 led degli ingressi.

LINK:

Secondo esempio: Display LCD

Questo esempio da la possibiltà di inviare un messaggio testuale al pic, il quale, lo visualizzerà su un display LCD. Esistono un pò di progetti simili a questo in rete, ma la maggior parte delle volte si trova solo li circuito, l'hex e il software sul pc. Anche in questo caso spiegherò tutto il procedimento, così che possa essere un punto di partenza per altri progetti, e che possa essere modificato, ampliato ed adattato alle proprie esigenze. Ecco il circuito:

clicca per ingrandire

Il circuito per il display LCD è identico al circuito base, ma con l'aggiunta dell'LCD. Per quanto riguarda i collegamenti, si può fare riferimento allo schema nell'help di mikrobasic, in cui vengono specificati tutti i pin del pic e tutti i pin dell'LCD. In questo caso io ho utilizzato un display con la sigla TBMC16265B, il cui datasheet è facilmente trovabile in rete. Per quanto riguarda il firmware non c'è molto da dire perchè anche quì è tutto ampiamente commentato. Posso aggiungere solo che la tringa da inviare al pic può essere lunga massimo 64 caratteri, perchè quando abbiamo configurato i parametri per la comunicazione HID abbiamo inserito 64byte di buffer sia in entrata che in uscita. Ecco il firmware:

program usb_lcd
' Moduli di connessione LCD
dim LCD_RS as sbit at RB4_bit
    LCD_EN as sbit at RB5_bit
    LCD_D4 as sbit at RB0_bit
    LCD_D5 as sbit at RB1_bit
    LCD_D6 as sbit at RB2_bit
    LCD_D7 as sbit at RB3_bit

    LCD_RS_Direction as sbit at TRISB4_bit
    LCD_EN_Direction as sbit at TRISB5_bit
    LCD_D4_Direction as sbit at TRISB0_bit
    LCD_D5_Direction as sbit at TRISB1_bit
    LCD_D6_Direction as sbit at TRISB2_bit
    LCD_D7_Direction as sbit at TRISB3_bit
' Fine Moduli di connessione LCD

dim readbuff as char[64] absolute 0x500 ' Il buffer dovrebbe essere in RAM, Invito a consultare i datasheet
dim writebuff as char[64] absolute 0x540

dim cnt as byte
dim txt as char[64] ' Variabile in cui viene immagazzinato il testo da visualizzare sull'LCD

sub procedure Interrupt()
USB_Interrupt_Proc() ' Il servizio USB viene eseguito nell'interrupt
end sub

main:
     ADCON1 = ADCON1 or 0x0F                   ' Setto tutti i pin analogici come digitali
     CMCON = CMCON or 7                        ' Disabilita i comparatori
     TRISA = 0                                 ' PORTA come output
     TRISB = 0                                 ' PORTB come output
     Lcd_Init()                                ' Inizializzo l'Lcd
     Lcd_Cmd(_LCD_CLEAR)                       ' Pulisco il display
     Lcd_Cmd(_LCD_CURSOR_OFF)                  ' Tolgo la segnalazione del cursore
     HID_Enable(@readbuff,@writebuff)          ' Enable HID communication

     while TRUE
           while(HID_Read() = 0)               ' Ricevo tutti i dati
           wend

           for cnt=0 to 63
               txt[cnt] = readbuff[cnt]        ' Assegno ogni byte ricevuto alla variabile txt
           next cnt

           Lcd_Cmd(_LCD_CLEAR)                 ' Pulisco il display
           Lcd_Out(1,1, txt)                   ' La visualizzo sull'Lcd
    wend

end.

Ovviamente, visto che verrà utilizzato un display, all'inizio del programma bisogna dichiarare tutti i pin che occorreranno per la comunicazione con il display, e successivamente bisogna inizializzare la comunicazione con Lcd_Init(). Per scrivere qualcosa sul display basterà usare il comando Lcd_Out(). Tutto il resto è identico al progetto base.

Se questa era la parte Hardware, ora passiamo alla parte software. Si basa sempre sul primo progetto, quello base; quello che cambia sono queste funzioni:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click

Invia(TextBox1.Text) ' Con questa funzione invio il testo scritto dentro una Textbox al pic

End Sub

Non c'è niente da aggiungere per l'applicazione, se non la foto:

Basta semplicemente eseguire il programma, collegare il circuito al pc tramite l'USB, a questo punto verrà fuori un messaggio con scritto "Collegato". Bene, a questo punto potrete scrivere tutto ciò che vorrete nella textbox e successivamente cliccare "Invia". Magicamente sull'LCD verrà fuori la stessa frase che avrete scritto :). Naturalmente essendo il display di 16 caratteri, se la frase sarò di 17 caratteri o più, verranno visualizzati solo i primi 16. Il testo scritto sul diplay rimmarrà sempre lo stesso finchè il pic non riceverà un nuovo messaggio dal pc.

LINK:

Terzo esempio: Oscilloscopio

Questo è l'esempio più difficile, secondo il mio parere, che presento. In questo ultimo esempio utilizzo l'entrata analogica del pic per simulare un oscilloscopio. Dato che il controller HID permette la comunicazione tra il pc e il pic ogni millisecondo, il sample di questo oscilloscopio base sarà proprio 1kHz. Nel caso in cui uno volesse aumentare la precisione si potrebbe benissimo creare un buffer per esempio di 10 letture e ogni millisecondo inviare tutto al pc; in questo caso il sample diverrebbe di 10kHz, ma non ci esaltiamo perchè è più facile a dirlo che a farlo ;). Ecco il circuito:

clicca per ingrandire

A differenza degli altri 2 esempi, questo esempio è esattamente identico al circuito base, l'unica cosa che serve in più, anche se non è necessario al funzionamento del circuito, è un filo dove collegheremo il nostro segnale. Su questo esempio bisogna precisare una cosa: Come si vede dallo schema, il segnale che il pic leggerà è privo di protezioni da sovratensioni e da disturbi; questo può provocare 2 cose: se applicheremo all'entrata analogica una tensione maggiore di Vcc molto probabilmente il vostro pic potrebbe subire dei gravi danni e non funzionare più ed infine, se vorrete analizzare un segnale dovrete accertarvi che non vi siano fonti fonti di disturbo, ad esempio le vostre semplici dita :D. Ecco il firmware:

program usb_oscilloscopio

dim readbuff as char[64] absolute 0x500           ' Buffers should be in USB RAM, please consult datasheet
dim writebuff as char[64] absolute 0x540
dim temp as word                                  ' Variabile dove viene immagazzinato il valore dall'Adc_Read
dim txt as char[4]                                ' Variabile in cui viene convertito il valore dell'Adc_Read

sub procedure Interrupt()
USB_Interrupt_Proc() ' Il servizio USB viene eseguito nell'interrupt
end sub

main:
     TRISA = 0xFF                             ' PORTA come input
     CMCON = CMCON or 7                       ' Disabilita i comparatori
     Delay_ms(1000)                            ' Pausa di 1 secondo
     HID_Enable(@readbuff,@writebuff)          ' Enable HID communication
     while TRUE
           temp = Adc_Read(0)                  ' Legge la tensione sulla porta AN0
           wordtostr(temp, txt)                ' Converte il valore da Word a String e lo memorizza in txt
           writebuff=txt                       ' Mette il valore txt dentro il buffer
           while(HID_Write(@writebuff,64) = 0) ' Invia i dati via USB
           wend
     wend
end.

Anche se può sembrare difficile, realizzare un oscilloscopio base non è così laborioso. E' sempre tutto commentato e fa semplicemente ciò di cui ho parlato sopra: dopo aver settato i vari pin, abilita la comunicazione USB ed esegue un ciclo infinito, in cui, legge la tensione sulla porta AN0, la converte in stringa e la invia al pc. Per le varie funzioni del'ADC si può studiare la sezione nell'help di mikrobasic.

Se questa era la parte Hardware, ora passiamo alla parte software. Si basa sempre sul primo progetto, quello base; quello che cambia sono queste funzioni:

    ' Queste dichiarazioni vanno inserite all'inizio
    Dim myPen As New System.Drawing.Pen(System.Drawing.Color.Red) ' Variabili necessarie
    Dim formGraphics As System.Drawing.Graphics                   ' per il disegno
    Dim oldy As Integer                         ' Vecchio valore di y
    Dim assex As Integer                        ' Valore di X
    Dim nuovay As Integer                       ' Nuovo valore di Y
    Dim cont As Integer                         ' Conteggio valori letti ogni secondo

    Private Sub Main_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load
        ' Non rimuovere!
        ConnectToHID(Me)
        ' Funzione per il disegno
        formGraphics = Me.CreateGraphics()
    End Sub

    '*****************************************************************
    ' Evento di lettura dei dati
    '*****************************************************************
    Public Sub OnRead(ByVal pHandle As Integer)
        ' Legge i dati (non dimenticarsi di analizzare l'intero array)...
        If hidRead(pHandle, BufferIn(0)) Then
            Dim txt As String
            For n = 1 To 5 ' Ricostruisce il dato composto da 5 caratteri
                txt = txt & Chr(BufferIn(n)) ' Trasforma il byte ricevuto in tipo Char e lo aggiunge alla variabile txt
            Next
            cont = cont + 1 ' Aumenta la variabile Cont per il conteggio dei valori letti ogni secondo
            If assex >= Me.Width Then ' Quando arriva alla fine del form torna da capo per disegnare di nuovo il segnale
                assex = 1
                formGraphics.Clear(Color.Black)
            Else
                assex = assex + 1
            End If
            nuovay = 600 - (Convert.ToInt32(txt) / 2) ' divide il valore Y per 2 perchè 1023 come valore massimo sarebbe
            ' troppo alto e uscirebbe dal form
            formGraphics.DrawLine(myPen, assex, oldy, assex + 1, nuovay) ' Disegna il pezzettino di linea
            oldy = nuovay ' tiene in memoria il vecchio valore di Y
            ' ** IL TUO CODICE QUI' **
            ' Il primo byte "BufferIn(0)" non è usato
            ' gli altri byte sono i dati dal microcontroller...
        End If
    End Sub

    '*****************************************************
    ' Timer per il conteggio degli impulsi in un secondo
    '*****************************************************
    Private Sub Timer1_Tick(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Timer1.Tick
        Me.Text = cont
        Cont = 0
    End Sub

Per visualizzare il segnale analizzato dal pic, sul pc, ho sfruttato la funzione di disegno del framework.NET ed ho utilizzato l'intero form come sfondo. Questa applicazione, oltre a scrivere sul suo titolo il numero dei dati ricevuti in un secondo, crea delle microlinee che ricostruiscono il segnale da analizzare. In pratica l'applicazione riceve dal pic un valore da 0 a 1023 ( siccome il pic ha una risoluzione di 10 bit = 2^10 = 1024), quello è il valore della y del punto di arrivo che formerà la nuova retta, il valore della x sarà semplicemente il valore di prima con l'aggiunta di 1(questo per muovere il segnale sempre più verso destra), mentre i valori di x e y del punto di partenza della nuova retta sono uguali ai valori del punto di arrivo della retta precedentemente tracciata. Nel codice ho diviso il valore ricevuto dal pic per 2 perchè altrimenti il segnale sarebbe uscito dalla finestra dell'applicazione e in alcuni casi non ci starebbe neanche nel monitor. Detto questo ecco la foto:

clicca per ingrandire

Non bisogna fare nient'altro che collegare il pic al pc tramite l'USB, avviare l'applicazione, e visualizzeremo istantaneamente il segnale in ingresso sulla porta AN0. In questo caso, il segnale in ingresso era un segnale sinusoidale a 100Hz con valore picco picco di 2V (valore minimo 1V, valore massimo 3V).

LINK: