Advertisement
pippero

Untitled

Nov 10th, 2022
220
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 4.43 KB | None | 0 0
  1.  
  2.  
  3. unsigned long calc_crc32(unsigned char* buf, unsigned int len)
  4. {
  5. unsigned long crc;
  6. unsigned int i;
  7.  
  8.  
  9. crc = 0xffffffff;
  10. for (i = 0; i < len; i++)
  11. #if defined(__SAM3X8E__)
  12. crc = ((crc >> 8) & 0x00ffffff) ^ crctab32[(crc ^ *buf++) & 0xff];
  13. #else
  14. //crc = ((crc >> 8) & 0x00ffffff) ^ pgm_read_dword_near(&crctab32[(crc ^ *buf++) & 0xff]);
  15. #endif
  16. return (crc ^ 0xffffffff);
  17. }
  18.  
  19.  
  20.  
  21.  
  22. #ifndef CHR_START
  23. #define CHR_START '['
  24. #endif
  25. #ifndef CHR_STOP
  26. #define CHR_STOP ']'
  27. #endif
  28. #ifndef CHR_SEP
  29. #define CHR_SEP ','
  30. #endif
  31. #ifndef TIMEOUT
  32. #define TIMEOUT 500
  33. #endif
  34.  
  35. // - 0 = ricezione non completata
  36. // - 1 = dati ricevuti correttamente
  37. // - 2 = errore timeout
  38. // - 3 = errore dati in arrivo oltre la dimensione massima
  39. // - 4 = errore dati incompleti
  40. #define RX_WAIT 0
  41. #define RX_OK 1
  42. #define RX_TIMEOUT 2
  43. #define RX_HIGH 3
  44. #define RX_LOW 4
  45.  
  46. // funzione che trasmette
  47. // i dati vengono trasmessi un byte alla volta
  48. // parametri:
  49. // - seriale = canale su cui trasmettere (serial / HC12)
  50. // - pacchetto = dati da trasmettere. serve un puntatore per scorrere la struttura dati un byte alla volta
  51. // - dimensione = numero di byte da trasmettere
  52.  
  53.  
  54.  
  55. void Trasmetti(Stream &seriale, unsigned char * pacchetto, size_t dimensione) {
  56. // invio il carattere di start
  57. seriale.print(CHR_START);
  58. // invio i dati
  59. for (byte i = 0; i < dimensione; i++) {
  60. seriale.print(*(pacchetto + i), HEX);
  61. seriale.print(CHR_SEP);
  62. }
  63. // invio il carattere di stop
  64. seriale.print(CHR_STOP);
  65.  
  66. return;
  67. }
  68.  
  69. // funzion che riceve
  70. // i dati arrivano sotto forma di caratteri che presi a 2 a 2 formano
  71. // un byte rappresentato in HEX
  72. // parametri:
  73. // - seriale = canale da cui ricevere (serial / HC12)
  74. // - pacchetto = contenitore dei dati da ricevere. serve un puntatore per scorrere la struttura dati un byte alla volta
  75. // - dimensione = numero di byte massimo da ricevere
  76. // ritorna:
  77. // - 0 = ricezione non completata
  78. // - 1 = dati ricevuti correttamente
  79. // - 2 = errore timeout
  80. // - 3 = errore dati in arrivo oltre la dimensione massima
  81. // - 4 = errore dati incompleti
  82. byte Ricevi(Stream &seriale, unsigned char * pacchetto, size_t dimensione) {
  83. // dimensione array di appoggio
  84. #define MAX 2
  85. //indice del byte ricevuto all'interno della struttura di destinazione
  86. //inizializzo con un valore fuori range massimo
  87. static uint32_t i = dimensione;
  88. // indice del carattere arrivato dentro l'array di appoggio
  89. static uint8_t j = 0;
  90. // array di appoggio per decodificare la stringa HEX in numero
  91. static char stringa[MAX + 1] = "";
  92. // valore millis per controllo timeout
  93. static uint32_t inizio = millis();
  94. // valore appena ricevuto
  95. byte valore;
  96.  
  97. while (seriale.available()) {
  98. valore = seriale.read();
  99. // controllo che carattere è
  100. switch (valore) {
  101. case CHR_START:
  102. // è il carattere di inizio trasmissione
  103. // azzero gli indici
  104. i = 0;
  105. j = 0;
  106. // azzero l'array di appoggio;
  107. stringa[0] = '\0';
  108. stringa[1] = '\0';
  109. stringa[2] = '\0';
  110. // faccio partire il tempo per il timeout
  111. inizio = millis();
  112. break;
  113. case CHR_STOP:
  114. // è il carattere di fine trasmissione
  115. if (i == dimensione) {
  116. return RX_OK;
  117. } else {
  118. //il terminatore è arrivato troppo presto
  119. return RX_LOW;
  120. }
  121. break;
  122. case CHR_SEP:
  123. // è il carattere separatore
  124. // salvo il byte
  125. if (i < dimensione) {
  126. *(pacchetto+i) = strtol(stringa, NULL, 16);
  127. } else {
  128. // ho superato la dimensione della struttura
  129. return RX_HIGH;
  130. }
  131. // devo passare al byte successivo
  132. i++;
  133. j = 0;
  134. // azzero l'array di appoggio;
  135. stringa[0] = '\0';
  136. stringa[1] = '\0';
  137. stringa[2] = '\0';
  138. break;
  139. default:
  140. // è un carattere da convertire
  141. if (j < MAX) {
  142. stringa[j] = valore;
  143. j++;
  144. }
  145. break;
  146. }
  147. // controllo il timeout
  148. if ((millis() - inizio) > TIMEOUT) {
  149. // azzero tutto prima di restituire errore
  150. i = 0;
  151. j = 0;
  152. // azzero l'array di appoggio;
  153. stringa[0] = '\0';
  154. stringa[1] = '\0';
  155. stringa[2] = '\0';
  156. return RX_TIMEOUT;
  157. }
  158. }
  159.  
  160. return RX_WAIT;
  161. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement