Una volta verificato il funzionamento della comunicazione Wi-Fi, `e sorta la necessit`a di salvare in un file di testo i dati acquisiti tramite il modulo ESP-WROOM-32, per poterli successivamente analizzare. Tuttavia, PuTTY non offre tale possibilit`a, perci`o si `e deciso di non gestire pi`u la comunicazione con questo software, bens`ı di utilizzare il protocollo TCP/IP di Matlab.
5.1 Modifica del software utilizzato per la co-municazione
Inizialmente, `e stata modificata la struttura delle istruzioni inviate attraverso il protocollo TCP/IP alla scheda Renensas, in quanto Matlab non ha i limiti imposti dal software usato precedentemente.
Infatti, sono stati eliminati l’Header e lo Splitter dal comando da inviare alla scheda Renesas, per semplificare l’operazione svolta dall’utente. Di conseguenza,
`e stato necessario implementare una funzione denominata split matlab(char*
data), similare alla funzione split(char* data) utilizzata precedentemente. Si `e difatti preferito non andare a modificare quest’ultima funzione, per lasciare la possibilit`a di eseguire prove con i software PuTTY e Docklight.
La differenza principale tra queste due funzioni `e la suddivisione dell’istruzione inviata alla scheda Renesas tra Header e Command, che viene effettuata esclu-sivamente dalla funzione split. Attraverso la split matlab, invece, viene soltanto salvato l’istruzione nel vettore command della struttura myPacket pointer di tipo Packet, che sar`a necessario poi per il parsing del comando.
char* split_matlab(char* data){
int i = 0;
int j = 0;
while(j<DIM_COMMAND) /* j is the index of the command array in the packet structure */
{
myPacket_pointer->command[j] = data[i];
i++; /* i is the index of the data array */
j++;
}
return parseCommand(); /* parse the command */
}
Infine, si `e modificato l’interrupt di ricezione, il quale non richiama pi`u la fun-zione split(char*data) per andare ad analizzare il comando inviato, bens`ı la funzione split matlab(char* data).
#pragma interrupt SCI12_RXI12_int (vect = VECT_SCI12_RXI12, enable) static void SCI12_RXI12_int()
{
int timeout=0;
/* Frame and Parity Error handling */
while(SCI12.SSR.BIT.ORER && timeout++<=10000) {
uint8_t read_byte=SCI12.RDR; /* Read byte from RDR register */
/* Putting the data from RDR register into the reception buffer */
rx_queue_pointer->data[rx_queue_pointer->tail]= read_byte;
rx_queue_pointer->counterElements++;
/* Incrementing the counter of received elements */
rx_queue_pointer->tail++; /* Incrementing the tail pointer to the next position (it will point to an empty element) */
/* if the rx queue is full or last element of the rx queue is the ’\n’ we can start processing the received packet */
if (queue_is_full(rx_queue_pointer) ||
rx_queue_pointer->data[rx_queue_pointer->tail-1]==’\n’) /* The wifi module sends the received command to renesas with
’\n’ in the final position */
{
//char command[DIM_COMMAND]=split(rx_queue_pointer);
/* splitting the received data from wifi module with putty*/
char command[DIM_COMMAND]=split_matlab(rx_queue_pointer);
clearCommand(); /* clear the command array for being ready for the next communication */
/* it is not necessary to clear the header because it is overwritten every time that a packet (correct or incorrect) is received */
interrupt_rx_disable(); /* Disabling the rx interrupt in order to clear the rx queue completely without the risk of getting other packets */
queue_clear(rx_queue_pointer);
}
5.2 Implementazione del codice Matlab
Per l’implementazione della nuova comunicazione Wi-fi si `e utilizzato il proto-collo TCP/IP di Matlab. Il protoproto-collo TCP/IP unisce due protocolli di per la trasmissione di dati, ovvero il Transmission Control Protocol (TCP) e l’Internet Protocol(IP). Attraverso il TCP si stabilisce la connessione tra due host e si gestisce la consegna dei pacchetti tra questi, mentre l’IP fornisce le istruzioni per il trasferimento dei dati.
Perci`o,per prima cosa, si `e creata la connessione tra i dispositivi coinvolti at-traverso la funzione tcpclient(address,port) di Matlab. Quest’ultima, infatti, crea la connessione tra l’host remoto dall’indirizzo passatogli e la porta remota specificata. Dopo aver dichiarato la variabile command per salvare il comando da inviare, la si trasmette al TCP/IP client (t) attraverso la funzione write-line(t,data).
Poi, `e stata creata una funzione di Callback, con la quale leggere i dati inviati dall’e-Bike mediante la funzione di readline(t) e conseguentemente salvarli nel file di testo deciso dall’utente con la writematrix. Per settare tale funzione si
`e utilizzata la configureCallback, con la quale si `e impostata la chiamata della callback ogni qual volta si incontri il terminatore LF.
Dopo aver implementato la connessione, `e stata verificata la sua funzionalit`a, andando a connettere il personal computer alla rete Wi-Fi dell’ESP-WROOM-32, Automa, non riscontrando tuttavia successo, in quanto i dati ricevuti non erano completi e non corrispondevano ai dati richiesti. Quindi, per risolvere tale problema, si `e deciso di mettere una pausa di un secondo per permettere alla callback di terminare la sua esecuzione.
Successivamente, si `e andato ad analizzare il motivo per il quale non si ricevessero i dati voluti. In un primo momento, si `e provato a sostituire la funzione read-line con una read(t), la quale legge singoli byte alla volta; tuttavia, con questa soluzione, si creavano problemi in fase di traduzione del codice ASCII, perci`o si `e tornati all’implementazione originaria. Cos`ı si `e pensato di andare a
verifi-care la compatibilit`a del codice Matlab con la configurazione del modulo Wi-Fi, trovando ci`o che non permetteva la corretta trasmissione dei dati. Si vedr`a nella sezione successiva quanto svolto per risolvere il problema.
Infine, si `e aggiunta una flush prima della chiamata alla callback per pulire il buffer del dispositivo della porta seriale, poich´e altrimenti vi era sovrapposizione di byte e una conseguente traduzione errata del codice ASCII.
Dopo aver effettuato questi cambiamenti, si `e quindi riusciti a salvare i dati rice-vuti dalla scheda Renesas attraverso la comunicazione implementata con Matlab e andarli ad analizzare.
5.3 Modifiche nel codice di programmazione dell’ESP-WROOM-32
Come anticipato precedentemente, si `e andati a verificare l’implementazione del software presente sull’ESP-WROOM-32. Inizialmente, si `e andati a con-trollare se la scheda Renesas trasmettesse correttamente i dati voluti in codice ASCII al modulo Wi-Fi, per escludere, infine, errori nel software implementato su e2studio. Perci`o, si `e passati ad analizzare ci`o che veniva ricevuto dalla connessione TCP/IP, prima che i dati venissero letti dalla readline all’interno della funzione di callback, riscontrando in questo passaggio l’errore. Infatti, si
`e notato che quest’ultimi erano la traduzione in codice ASCII dei singoli byte ricevuti dalla scheda Renesas, che a sua volta traduceva i dati da trasmettere in codice ASCII. Perci`o, avveniva una duplice traduzione e si era impossibili-tati a ricostruire i dati acquisiti. La causa di questa duplice traduzione era la funzione di print presente nel codice di Arduino IDE per la programmazione dell’ESP-WROOM-32, che stampa i dati sulla porta seriale come testo ASCII.
Per risolvere il problema, si `e deciso di sostituire tale funzione con la write, che permette di scrivere dati binari come byte o serie di byte sulla porta seriale.