Scheda di interfaccia universale incorporata - Controllo USB/Bluetooth/WIFI: 6 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:03

Trovo spesso che creo librerie per nuovi moduli incorporati da zero in base al foglio dati del dispositivo. Nel generare la libreria mi ritrovo bloccato in un ciclo di codice, compilazione, programma e test per garantire che le cose funzionino e siano prive di bug. Spesso i tempi di compilazione e programmazione possono essere molto più lunghi del tempo necessario per modificare il codice e quindi un modo per eliminare questi passaggi durante lo sviluppo sarebbe molto utile.

Mi capita spesso di voler interfacciare un modulo embedded con un PC. Se il modulo non dispone di una connessione USB specifica, come spesso accade, in genere è necessario acquistare un convertitore USB troppo costoso che svolgerà un singolo lavoro come solo SPI o solo I2C.

È per questi motivi che ho deciso di creare la scheda di interfaccia universale. È progettato per consentire comunicazioni facili basate su PC con moduli incorporati.

Le caratteristiche dell'interfaccia incorporata della scheda su cui ho deciso includono.

• I/O digitali
• I2C
• SPI
• UART
• PWM
• Servomotore
• Ingresso ADC
• Uscita DAC

Tutto ciò può essere utilizzato in modo completamente indipendente.

La scheda di interfaccia può essere controllata tramite una connessione USB al PC, ma dispone anche di connessioni Wi-Fi o modulo Bluetooth opzionali per consentire l'utilizzo della scheda da remoto o in uno scenario di tipo IoT.

Utilizzando connettori standard SIL con passo da 2,54 mm è possibile collegare direttamente cavi dupont femmina tra la scheda e il modulo integrato consentendo connessioni rapide, affidabili e senza saldature.

Ho anche pensato di aggiungere cose come CAN, LIN, H-bridge ecc. Ma queste possono forse venire in seguito con una revisione v2.

Passaggio 1: progettazione del PCB

Quando progetto il PCB mi piace cercare di mantenere le cose il più semplici possibile. Quando si costruiscono schede a mano, è importante aggiungere componenti solo quando hanno uno scopo specifico e utilizzare il maggior numero possibile di funzionalità interne del microcontrollore.

Guardando il mio fornitore di elettronica preferito ho trovato un chip con cui mi sentivo a mio agio che aveva le caratteristiche che stavo cercando e aveva un costo ragionevole. Il chip su cui sono atterrato era il PIC18F24K50.

Con i 23 pin I/O disponibili questo mi ha permesso queste funzionalità

• I/O. digitali
• I2C
• SPI
• UART
• PWM x 2
• Servomotore x 6
• Ingresso ADC x 3
• Uscita DAC x 1
• I/O pilotato da 5V o 3V3
• LED di stato

Uno svantaggio dell'IC che ho scelto è che ha solo una periferica UART e quindi l'utilizzo del metodo di controllo Bluetooth o Wifi ti impedirà di utilizzare la connessione UART.

Mostrato nelle immagini sopra sono lo schema finito e PCB.

Passaggio 2: progettazione del protocollo

Il primo passo nella progettazione del protocollo è decidere cosa in particolare sarà necessario che la scheda sia in grado di fare. Rompere le cose aggiunge un migliore livello di controllo, mentre l'unione delle cose semplifica l'interfaccia e riduce il traffico di comunicazione tra la scheda e il PC. È un gioco di equilibrio e difficile da perfezionare.

Per ogni funzione della scheda è necessario indicare eventuali parametri e ritorni. Ad esempio, una funzione per leggere un input ADC potrebbe avere un parametro per specificare quale input campionare e un valore restituito contenente il risultato.

Nel mio progetto ecco l'elenco delle funzioni che volevo includere:

• I/O digitali

  • ImpostaPin (NumeroPin, Stato)
  • Stato = GetPin (PinNumber)

• SPI

  • Inizializza (modalità SPI)
  • DataIn = Trasferimento (DataOut)
  • ControlChipSelect (canale, stato)
  • SetPrescaler (Tariffa)

• I2C

  • Inizializza ()
  • Cominciare ()
  • Ricomincia ()
  • Fermare ()
  • SlaveAck = Invia (DataOut)
  • DataIn = Ricevi (ultimo)

• UART

  • Inizializzare()
  • Byte TX (DataOut)
  • Byte disponibili = Conteggio RX ()
  • DataIn = Byte RX ()
  • Imposta Baud (Baud)

• PWM

  • Abilita (canale)
  • Disattiva (canale)
  • ImpostaFrequenza (Canale, Frequenza)
  • GetMaxDuty (Duty)
  • SetDuty (Duty)

• Servo

  • Abilita (canale)
  • Disattiva (canale)
  • ImpostaPosizione (canale, posizione)

• ADC

  ADCsample = Campione (canale)

• DAC

  • Abilitare
  • disattivare
  • Imposta uscita (tensione)

• WIFI

  • Imposta SSID (SSID)
  • Imposta password (password)
  • Stato = CheckConnectionStatus ()
  • IP = Ottieni indirizzo IP ()

I parametri sono mostrati tra parentesi e i ritorni sono mostrati prima del simbolo uguale.

Prima di iniziare a codificare assegno a ciascuna funzione un codice di comando a partire da 128 (binario 0b10000000) e procedendo verso l'alto. Documento completamente il protocollo per assicurarmi che una volta che la mia testa è nel codice ho un bel documento a cui fare riferimento. Il documento completo del protocollo per questo progetto è allegato e include i codici dei comandi in entrata e le larghezze di bit.

Passaggio 3: progettazione del firmware

Una volta stabilito il protocollo, si tratta di implementare la funzionalità sull'hardware.

Adotto un semplice approccio al tipo di macchina a stati durante lo sviluppo di sistemi slave per cercare di massimizzare il potenziale comando e il throughput dei dati mantenendo il firmware semplice da comprendere ed eseguire il debug. Un sistema più avanzato come Modbus potrebbe essere utilizzato invece se hai bisogno di una migliore interazione con altri dispositivi collegati, ma questo aggiunge un sovraccarico che rallenterà le cose.

La macchina degli stati è composta da tre stati:

1) In attesa di comandi

2) Ricezione dei parametri

3) Rispondi

I tre stati interagiscono come segue:

1) Passiamo attraverso i byte in entrata nel buffer finché non abbiamo un byte con il bit più significativo impostato. Una volta ricevuto tale byte, lo controlliamo con un elenco di comandi noti. Se troviamo una corrispondenza, assegniamo il numero di byte del parametro e restituiamo i byte in modo che corrispondano al protocollo. Se non ci sono byte di parametro, possiamo eseguire il comando qui e passare allo stato 3 o riavviare lo stato 1. Se ci sono byte di parametro, allora ci spostiamo allo stato 2.

2) Esaminiamo i byte in ingresso salvandoli fino a quando non abbiamo memorizzato tutti i parametri. Una volta che abbiamo tutti i parametri eseguiamo il comando. Se ci sono byte di ritorno, allora passiamo alla fase 3. Se non ci sono byte di ritorno da inviare, torniamo alla fase 1.

3) Passiamo attraverso i byte in entrata e per ogni byte sovrascriviamo l'echo byte con un byte di ritorno valido. Una volta inviati tutti i byte di ritorno torniamo alla fase 1.

Ho usato Flowcode per progettare il firmware in quanto dimostra visivamente bene cosa sto facendo. La stessa cosa potrebbe essere fatta ugualmente bene in Arduino o in altri linguaggi di programmazione embedded.

Il primo passo è stabilire la comunicazione con il PC. Per fare questo il micro deve essere configurato per funzionare alla giusta velocità e dobbiamo aggiungere il codice per pilotare le periferiche USB e UART. In Flowcode è facile come trascinare nel progetto un componente USB Serial e un componente UART dal menu del componente Comms.

Aggiungiamo un interrupt e un buffer RX per catturare i comandi in arrivo sull'UART e interroghiamo regolarmente l'USB. Possiamo quindi a nostro piacimento elaborare il buffer.

Il progetto Flowcode e il codice C generato sono allegati.

Passaggio 4: interfacciamento tramite codice di flusso

La simulazione Flowcode è molto potente e ci permette di creare un componente per parlare con la scheda. Nella creazione del componente ora possiamo semplicemente trascinare il componente nel nostro progetto e avere immediatamente a disposizione le funzioni della scheda. Come bonus aggiuntivo, qualsiasi componente esistente che disponga di una periferica SPI, I2C o UART può essere utilizzato nella simulazione e i dati delle comunicazioni possono essere convogliati alla scheda di interfaccia tramite un componente dell'iniettore. Le immagini allegate mostrano un semplice programma per stampare un messaggio sul display. I dati delle comunicazioni inviati tramite la scheda di interfaccia all'hardware del display effettivo e alla configurazione dei componenti con i componenti del display I2C, dell'iniettore I2C e della scheda di interfaccia.

La nuova modalità SCADA per Flowcode 8.1 è un ulteriore vantaggio assoluto in quanto possiamo quindi prendere un programma che fa qualcosa nel simulatore di Flowcode ed esportarlo in modo che funzioni da solo su qualsiasi PC senza problemi di licenza. Questo potrebbe essere ottimo per progetti come banchi di prova o cluster di sensori.

Uso questa modalità SCADA per creare lo strumento di configurazione WIFI che può essere utilizzato per configurare SSID e password, nonché per raccogliere l'indirizzo IP del modulo. Ciò mi consente di configurare tutto utilizzando la connessione USB e quindi di trasferirlo su una connessione di rete WIFI una volta che le cose sono in esecuzione.

In allegato alcuni progetti di esempio.

Passaggio 5: altri metodi di interfacciamento

Oltre a Flowcode puoi praticamente usare il tuo linguaggio di programmazione preferito per comunicare con la scheda di interfaccia. Abbiamo usato Flowcode perché aveva già una libreria di parti inclusa che potevamo mettere in funzione immediatamente, ma questo vale anche per molte altre lingue.

Ecco un elenco di lingue e metodi per comunicare con la scheda di interfaccia.

Python - Utilizzo di una libreria seriale per lo streaming di dati a una porta COM o indirizzo IP

Matlab - Utilizzo dei comandi File per trasmettere i dati a una porta COM o indirizzo IP

C++ / C# / VB - Utilizzo di una DLL pre-scritta, accesso diretto alla porta COM o API TCP/IP di Windows

Labview - Utilizzo di una DLL pre-scritta, del componente VISA Serial o del componente TCP/IP

Se qualcuno desidera vedere implementate le lingue di cui sopra, per favore me lo faccia sapere.

Passaggio 6: prodotto finito

Il prodotto finito sarà probabilmente una caratteristica importante nel mio kit di strumenti incorporato per gli anni a venire. Mi ha già aiutato a sviluppare componenti per vari display e sensori Grove. Ora posso ottenere il codice completamente inchiodato prima di ricorrere a qualsiasi compilazione o imbrogli di programmazione.

Ho anche distribuito alcune schede ai colleghi in modo che anche loro possano migliorare il loro flusso di lavoro e sono state accolte molto bene.

Grazie per aver letto il mio Instructable, spero che tu lo abbia trovato utile e spero che ti ispiri a creare i tuoi strumenti per accelerare la tua produttività.