Migrazione codice Arduino vs codice PIC18F (MikroC)

Sto diventando pazzo a convertire un semplice codice Arduino versus dei PIC18F, con il compilatore MikroC.

In pratica sono due Arduino che comunicano via seriale.
Uno "Slave" configurato come lettore di alcuni sensori analogici, il quale spedisce su seriale i valori ad un "master" che provvede a visualizzarli su un GLCD su base T6963. Il tutto funziona da mesi alla perfezione.

Ora vorrei fare il porting su due PIC18F4550 ma mi sto incartando sulla comunicazione seriale.

Il codice Arduinesco, molto semplice, è questo:

unsigned char buff[3]; // buffer per infilarci dentro i dati della seriale

if (Serial.available() >= 3) { // conta 3 byte e poi passa
for(int i = 0 ; i < 3; i++) // ad un ciclo for con cui ci riempe
buff = Serial.read(); // i 3 elementi del buffer char.
Serial.flush(); // Pulisco il buffer di ricezione

Non riesco a convertirlo in MikroC perchè non esiste una funzione come Serial.available che conta i bit, e se faccio una roba così i dati con cui riempo il buffer sono incoerenti "a caso".


unsigned char buff[3];
if (UART_Data_Ready() == 1)
{
buff[byte_counter] = UART_Read();
if (byte_counter < 3) {
byte_counter++;
}
else
byte_counter = 0;

Il Buffer in questo caso contiene dati che a Display non hanno relazione con quanto spedito dallo Slave.

Qualche anima buona mi dà una dritta?

Grazie

Guido

Disclaimer: livello elettronica molto alto, ma programmazione C livello modesto.

Ciao,

effettivamente quello che devi creare e´ un buffer o semplicemente un array dove mettere i dati in ricezione fino a quando non raggiungi il numero di byte necessari.

In linea di principio il codice che hai scritto mi sembra corretto.
Mi aspetto pero' che sia incluso in un while che si interrompe solo al riempimento dell´array o sia all´interno di un´ISR richiamata alla ricezione del byte.

Se visualizzi codici errati sul display accertati prima di poter scrivere altri dati correttamente sul display.

Accertati inoltre che il baud rate tra i due sistemi sia lo stesso.

Prova per esempio ad inviare un solo byte e vedere se lo scrivi correttamente.

Se hai problema in questo vuol dire che il problema non e´ il buffer/array ma sta prima.

Saluti,

Mauro

Grazie Mauro, bentornato dalle ferie.

Comprendo dalle tue parole di aver colpevolmente messo poco codice per poter far comprendere bene il problema. Adesso posto qualche riga di codice in più così si capisce meglio.

Questo è il codice Arduino funzionante:

---

buff[3];

if (Serial.available() >= 3) {
for(int i = 0 ; i < 3; i++) // ciclo di 3
buff = Serial.read(); // con cui ci riempo il buffer con i tre Byte

Serial.flush(); // azzero il buffer di ricezione della UART

int code = 0; // assegno a code il valore della prima cella del buffer buff[0]
code = buff[0]; // quindi il primo Byte che è l'identificatore del sensore


if (code == 10){ // se code = 10 significa che è il sensore dei volt

int c1 = 0; // variabili per gli altri due Bytes che sono il valore
int c2 = 0; // del sensore
int cc = 0;

c1 = buff[1]; // siccome il valore spedito era un 16 bit, devo ricostruirlo
c2 = buff[2]; // con i due pezzi, i due Bytes spediti in uno
c1 = c1 << 8; // quindi faccio uno shift del MSB di 8 bit a SX
cc = c1 | c2; // e poi un OR con il LSB per riavere un INT a 16 bit

float ccc = cc*30.0; // calcoli per avere il valore da bit in un float
ccc /= 1024.0; // con la proporzione che mi serve (30 V fondo scala)

char c[10]; // buffer per il Typecasting da float a string
dtostrf(ccc, 2, 2, c); // conversione float a stringa per il display

LCD.TextGoTo(0,3); // cursore alla riga 3
LCD.writeString(c); // stampo c, ovvero il float con il valore sensore
LCD.writeString(" V"); // stampo il carattere 'V'

}


if (code == 11){ // passo a verificare il secondo sensore
// con codice C identico al primo
int c1 = 0;
int c2 = 0;
int cc = 0;
...........
...........
ecc. ecc.

---

Codice MikroC (che non funziona)

---

unsigned char buff[3];
if (UART_Data_Ready() == 1)
{
buff[byte_counter] = UART_Read();
if (byte_counter < 3) {
byte_counter++;
}
else
byte_counter = 0;

int c1 = 0
int c2 = 0
int cc = 0

c1 = buff[1]; // siccome il valore spedito era un 16 bit, devo ricostruirlo
c2 = buff[2]; // con i due pezzi, i due Bytes spediti in uno
c1 = c1 << 8; // quindi faccio uno shift del MSB di 8 bit a SX
cc = c1 | c2; // e poi un OR con il LSB per riavere un INT a 16 bit

float ccc = cc*30.0; // calcoli per avere il valore da bit in un float
ccc /= 1024.0; // con la proporzione che mi serve (30 V fondo scala)

char c[10]; // buffer per il Typecasting da float a string
FloatToStr(ccc, c); // funzione diversa da arduino per convertire il float

T6963C_write_text(c, 0, 3, T6963C_ROM_MODE_TEXT); // stampo il float
T6963C_write_text(" V", 0, 3, T6963C_ROM_MODE_TEXT); // stampo il carattere V

---

Nella seconda versione del codice mi da "i numeri" sul displai, con valori non coerenti.

Mi sembra che i buffer 0,1,2 non si riempano correttamente con i valori in arrivo.

Personalmente, se possibile, prima di collegare tra di loro i PIC userei RS232 terminal e collegherei il PC con il PIC (magari usando la FREEDOM II)in modo da escludere eventuali errori di trasmissione .Inoltre, in questo modo, si avrebbe la possibilità di inviare un carattere per volta e cambiare baud molto facilmente per fare delle prove.
Ciao
Renato