Go Down

Topic: Misuratore Ampere / Volt / Continuità per pista Slot (Read 16078 times) previous topic - next topic

gpb01

1. Studia QUI e QUI come funziona un bus SPI e come viene selezionato il device con cui vuoi parlare

2. Il bus SPI è un bus molto veloce e ... collegarlo con i "cavetti", come dovrai fare (visto che la Pro Mini NON ha quel connettore che è fatto per la MEGA) può essere fonte di molti problemi! Tienili molto corti e speriamo bene.

Guglielmo
Search is Your friend ... or I am Your enemy !

Standardoil

E perché non cominciare semplicemente con 4 comparatori tra Vcc e +Alimentatore?
4 bei led rossi di superamento soglia, a seguire 4 flip-flop per mantenere l'informazione
e poi passi ad arduino, ma intanto hai anche una "controprova" HW che nessuno tarocca nulla.
poi non ho capito come farebbe un concorrente a taroccare il suo regolatore, cosa è? la sua manetta di comando?, e cosa ci tiene dentro? un reattore nucelare tascabile, una pila ricaicabile? un supercondensatore?
Prima legge di Nelson (che sono io): Non scambiare il fine con il mezzo: ricorda "cosa" devi fare, non "come" devi farlo

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

ricki158

1. Studia QUI e QUI come funziona un bus SPI e come viene selezionato il device con cui vuoi parlare

2. Il bus SPI è un bus molto veloce e ... collegarlo con i "cavetti", come dovrai fare (visto che la Pro Mini NON ha quel connettore che è fatto per la MEGA) può essere fonte di molti problemi! Tienili molto corti e speriamo bene.

Guglielmo
1. Grazie mille! Per quanto riguarda l'infarinatura, mi ci metto sotto. Invece volevo avere qualche consiglio sul collegamento alla breakout board. Perché ci sono molti pin e non capisco quali usare. Purtroppo ho richiesto il datasheet ma mi hanno mandato quello del controller che hanno tutti e le dimensioni della board.

2. In che senso problemi sul connettore? Io metterò degli strip femmina su una millefori sulla quale mi collego con dei cavetti da 0.30 mm2. La lunghezza massima dei cavetti sarà sui 50 mm. Potrei usare anche un cavo con i poli twistati e schermati. Io pensavo comunque di mettere i due display e al centro Arduino Pro Micro. E se serve metto due pulsanti, uno per selezionare la pista, l'altro per resettare i valori massimi.

ricki158

E perché non cominciare semplicemente con 4 comparatori tra Vcc e +Alimentatore?
4 bei led rossi di superamento soglia, a seguire 4 flip-flop per mantenere l'informazione
e poi passi ad arduino, ma intanto hai anche una "controprova" HW che nessuno tarocca nulla.
poi non ho capito come farebbe un concorrente a taroccare il suo regolatore, cosa è? la sua manetta di comando?, e cosa ci tiene dentro? un reattore nucelare tascabile, una pila ricaicabile? un supercondensatore?
Guarda, per quanto riguarda il come si fa a barare, non lo so (e rabbrividisco pensando che, non essendoci nulla in palio, ci sia qualcuno che lo fa), però ho sentito di pile, ho sentito di induttanze... però non so come si debba fare per far funzionare l'accrocchio. So solo che su una tensione massima di 12 v qualcuno girava con picchi di 13.1-2 v in rettilineo (qualcuno sapendo di queste cose ha fatto un voltmetro di questo tipo in altre piste... potrei copiare il loro progetto ma mi piacerebbe imparare qualcosa e farlo mio, specialmente nella gestione del display ed eventualmente in quella del touchscreen). Oppure la prima parte della gara era normale, la seconda superlativa. Oppure in uscita della curva e nel primo pezzo di rettilineo si è affiancati, poi l'avversario va via in una maniera che non è imputabile ad un rapporto finale diverso o cosa.

Per quanto riguarda l'hardware, può essere un'idea anche la tua, ma siccome ho Arduino, volevo fare tutto tramite lui.

Etemenanki

... poi l'avversario va via in una maniera che non è imputabile ad un rapporto finale diverso o cosa.
... quello dipende dal flusso canalizzatore ... :D
"Sopravvivere" e' attualmente l'unico lusso che la maggior parte dei Cittadini italiani,
sia pure a costo di enormi sacrifici, riesce ancora a permettersi.

ricki158

Pigliate pigliate in giro :D Non pensavo nemmeno io mi prendesse così.

ricki158

Allora, per quanto riguarda i collegamenti:

I due display devono avere in comune il "Clock" e il "MOSI" dell'SPI, perché la comunicazione è unidirezionale verso i display. Quello che cambia sono i pin CS, A0 e RESET che devono essere specifici dei due display. Quindi in pratica per pilotarne due mi bastano 2 + 3 + 3 = 8 pin.

Quindi sostanzialmente devo collegare ad Arduino i pin 8 e 9 (SDA e SCK) dei display e i pin 10, 7 e 6 (CS, A0, RESET) di ogni display. Questo a seguito di quello che ho visto fare per la libreria di Adafruit per la gestione del chip ST7735.

Per quanto riguarda il codice, ho trovato qualcosa in internet di già pronto, però volevo fare (di testa mia) una funzione, che però alla fine ricalca perfettamente quella che ho trovato in un sito: in poche parole vado a fare una misurazione con salvataggio in un array.

Code: [Select]

#define sclk 13               /* clock della comunicazione SPI, in comune */
#define mosi 11               /* comunicazione unidirezionale master -> slave, in comune */
#define cs1 10                /* selezione dello slave 1, primo display */
#define rs1 9                 /* , primo display */
#define rst1 8                /* reset dello slave 1, primo display */
#define cs2 7                 /* selezione dello slave 2, secondo display */
#define rs2 6                 /* , secondo display */
#define rst2 5                /* reset dello slave 2, secondo display */

#include <SPI.h>              /* libreria per comunicazione SPI */
#include <Adafruit_GFX.h>     /* libreria grafica di Adafruit */
#include <Adafruit_ST7735.h>  /* libreria per il chip ST7735 di gestione del display */

Adafruit_ST7735 display1 = Adafruit_ST7735(cs1, rs1, rst1);   /* creazione oggetto display1 per la libreria Adafruit di gestione del chip del display */
Adafruit_ST7735 display2 = Adafruit_ST7735(cs2, rs2, rst2);   /* creazione oggetto display2 per la libreria Adafruit di gestione del chip del display */

#define VREF  5.0             /* calibrazione della tensione di riferimento delle misure */
#define nCanali  4            /* numero dei canali da leggere */
#define nCampioni  128        /* numero dei campionamenti per leggere una media */

/* siccome Arduino legge in entrata al massimo 5 v, devo dividere con un partitore di tensione la Vin. Per fare ciò utilizzo una Ra = 680 k Ohm e una Rb = trimmer 200 k Ohm. */
/* il valore dei seguenti div sarà dato da Vin(max) / 5 . Vin(max) viene calcolata con 5 / (Rb / (Ra + Rb)). Quindi div = (Ra + Rb) / Rb. Ma siccome Ra è fisso, basta inserire il valore di Rb */

int Ra1 = 680000;             /* valore in Ohm di Ra1 */
int Rb1 = 200000;             /* valore in Ohm di Rb1 */
int Ra2 = 680000;             /* valore in Ohm di Ra2 */
int Rb2 = 200000;             /* valore in Ohm di Rb2 */
int Ra3 = 680000;             /* valore in Ohm di Ra3 */
int Rb3 = 200000;             /* valore in Ohm di Rb3 */
int Ra4 = 680000;             /* valore in Ohm di Ra4 */
int Rb4 = 200000;             /* valore in Ohm di Rb4 */

int divisore[4] = {((Ra1 + Rb1) / Rb1), ((Ra2 + Rb2) / Rb2), ((Ra3 + Rb3) / Rb3), ((Ra4 + Rb4) / Rb4)};   /* array di valori fissi dati dalle resistenze di ogni canale */
int misura[4] = {0, 0, 0, 0};                     /* array di valori delle misure digitali sui vari canali */
int Vmisura[4] = {0.00, 0.00, 0.00, 0.00};        /* array di valori delle misure delle tensioni sui vari canali in riferimento a VREF */
int Vmax[4] = {0.00, 0.00, 0.00, 0.00};           /* array di valori delle misure delle tensioni massime sui vari canali in riferimento a VREF */
int Vmin[4] = {100.00, 100.00, 100.00, 100.00};   /* array di valori delle misure delle tensioni minime sui vari canali in riferimento a VREF */

byte contCampioni = 0;        /* contatore dei campionamenti  */
byte contGenerale = 0;        /* contatore generale per cambiare di volta in volta la lettura e la scrittura nell'array corrispondente */

void lettura(){
  while (contCampioni < nCampioni) {    /* finché il contatore dei campionamenti è inferiore al numero dei campionamenti voluti */
    for (contGenerale = 0; contGenerale < nCanali; contGenerale++) {    /* varia contGenerale da 0 al numero dei canali */
      misura[contGenerale] += analogRead(A0 + contGenerale);    /* salva nell'array misura i valori dei canali in digitale */
    }
    contCampioni++;           /* aggiungi un "passo" al contatore dei campionamenti */
    delay(0);                 /* tempo nel quale aspetto */
  }
}

void maxmin(){
  for (contGenerale = 0; contGenerale < nCanali; contGenerale++) {   /*  */
    Vmisura[contGenerale] = ((misura[contGenerale]>>7) * VREF) / 1024.0;    /*  */
    if(Vmisura[contGenerale] > Vmax[contGenerale]){                 /*  */
      Vmax[contGenerale] = Vmisura[contGenerale];                   /*  */
    }
    if(Vmisura[contGenerale] < Vmin[contGenerale]){                 /*  */
      Vmin[contGenerale] = Vmisura[contGenerale];                   /*  */
    }        
  }
}


Una delle cose che non capisco è l'uso dei campionamenti. Cioè il ciclo while mi fa continuare fino a che non arrivo al 128° passo. Poi? Che senso ha? (Per inciso la mia funzione è praticamente identica, c'è solo il ciclo while in più). Dopodiché anziché il ciclo while non posso usare un semplice millis() con il quale ciclo tutte le funzioni che mi interessano? Infine dovrò fare una funzione di reset maxmin collegata a due pulsanti, in maniera che uno gestisca l'avanzamento del contatore dell'array e l'altro, quando premuto, azzera quel tale oggetto presente nell'array.

Standardoil

Alcune non chiare cose: come hai calcolato il divisore di tensione? Mi sembra sbagliato.
Tutte le misure intere? Sei sicuro?
 Perché tenere traccia del minimo? Sarà zero, per auto ferma o frenata in corto circuito, è  inutile da memorizzare
Il riferimento di tensione difficile che sia costante, conviene magari prevedere un riferimento esterno oppure una funzione di taratura, dove fai leggere ad ogni canale la piena tensione delalimentatore e la usi per autotarare i rapporti dei partitori
Invece per rispondere alla tua domanda,  Perché  128 letture?
Chi ha scritto aveva idee strane, la somma di 128 letture di un intero potrebbe superare (e probabile lo farà ) la capacità  di un intero, mandando a quel paese i calcoli.
Ho letto che in passato hai già fatto qualcosa con gli ingressi analogici, parti da quello che sai tu, non copiare a muzzo
Prima legge di Nelson (che sono io): Non scambiare il fine con il mezzo: ricorda "cosa" devi fare, non "come" devi farlo

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

ricki158

Alcune non chiare cose: come hai calcolato il divisore di tensione? Mi sembra sbagliato.
Beh, 5 v x 4.34 fanno 21.7 v che sono i volt massimi in entrata.

Quote
Tutte le misure intere? Sei sicuro?
No, gli array con i valori con due cifre dopo la virgola no. Solo che non ho grande esperienza di tipi di variabili e sarei andato a cambiarli più avanti.

Quote
Perché tenere traccia del minimo? Sarà zero, per auto ferma o frenata in corto circuito, è  inutile da memorizzare
Pensavo potesse essere utile in qualche modo.

Quote
Il riferimento di tensione difficile che sia costante, conviene magari prevedere un riferimento esterno oppure una funzione di taratura, dove fai leggere ad ogni canale la piena tensione dell'alimentatore e la usi per auto tarare i rapporti dei partitori
Come riferimento prendo i 5 volt massimi del riferimento per i convertitori A/D. C'è un modo per auto tarare questo valore in maniera interna?

Quote
Invece per rispondere alla tua domanda,  Perché  128 letture?
Chi ha scritto aveva idee strane, la somma di 128 letture di un intero potrebbe superare (e probabile lo farà ) la capacità  di un intero, mandando a quel paese i calcoli.
Ah ecco mi sembrava! Quindi non cambia nulla se faccio la funzione come voglio io.

Standardoil

Beh, 5 v x 4.34 fanno 21.7 v che sono i volt massimi in entrata.


non era 12V? ho letto male?
Prima legge di Nelson (che sono io): Non scambiare il fine con il mezzo: ricorda "cosa" devi fare, non "come" devi farlo

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

ricki158

Si, l'alimentatore è a 12 v, ma siccome voglio andare a vedere se ci sono dei picchi massimi sopra i 12 v, devo calcolare il partitore in modo che la mia Vout sia 5 volt e la mia Vin sia, diciamo 15 volt, ma mettiamo almeno 20 volt per sicurezza. Il partitore fatto dalla resistenza da 680 k Ohm e il trimmer da 200 k Ohm fanno in modo che come tensione massima posso avere 21,7 volt, se voglio leggere con Arduino al massimo 5 volt (più di 5 volt lo danneggerei).

Standardoil

appena venuta in menta cosina alternativa, molto KaTTiva verso i furbi
4 bei diodi Schottky tra il piu' delle piste e il piu' dell'alimentatore, se uno fa il furbo lo schottky gli cortocircuita la manetta di comando sul +12, vedi che dalla volta dopo non lo fà più nessuno
Prima legge di Nelson (che sono io): Non scambiare il fine con il mezzo: ricorda "cosa" devi fare, non "come" devi farlo

Non bado a studenti, che copino altrove

Tu hai problema-Io ti domando-Tu non mi rispondi: vuol dire che non ti serve più

ricki158

No ma un voltmetro per tenere sotto controllo le tensioni comunque ci serve e ci interessa avere, al di là dei furbetti.

ricki158

#58
Mar 27, 2018, 11:46 am Last Edit: Mar 29, 2018, 03:08 pm by ricki158
Buongiorno a tutti, torno sul topic dopo un pezzo che non scrivevo nulla.
Sto ancora aspettando i display dalla Cina, intanto però è arrivato l'Arduino Pro Micro di concorrenza.

Subito una domanda: come lo alimento? Vedo sullo schema che c'è un ponte fra "valle" e "monte" del regolatore di tensione. Chiudendo il ponte il microprocessore e tutte le uscite sono alimentate a 5 volt, mentre lasciandolo aperto viene alimentato a 3.3 volt. I 5 volt però provengono dalla presina USB che non mi piace, io vorrei un'alimentazione dedicata senza tenere collegata la USB e in caso collegarmi con il PC per fare degli aggiustaggi nel software.
In pratica mi dovrei fare un circuito di regolazione della tensione da 12 Volt (trasformatore esterno dalla 220 di rete) a 5 Volt con un semplice LM7805 e poi portare il positivo al VCC sul pin 4.

Ho capito che posso gestire due display diversi tramite SPI, due pin di reset, due pin cs, due pin rs, un pin per il clock e uno mosi, in tutto fanno 8 pin. Però dovrò scoprire come funzionano i pin dei display.

Per il codice, l'ho rifatto con le mie idee, non so se sia corretto e spero si capisca "fra le righe" che cosa voglio fare:

Code: [Select]

#define sclk 13                                       /* clock della comunicazione SPI, in comune */
#define mosi 11                                       /* comunicazione unidirezionale master -> slave, in comune */
#define cs1 10                                        /* selezione dello slave 1, primo display */
#define rs1 9                                         /* , primo display */
#define rst1 8                                        /* reset dello slave 1, primo display */
#define cs2 7                                         /* selezione dello slave 2, secondo display */
#define rs2 6                                         /* , secondo display */
#define rst2 5                                        /* reset dello slave 2, secondo display */

#include <SPI.h>                                      /* libreria per comunicazione SPI */
#include <Adafruit_GFX.h>                             /* libreria grafica di Adafruit */
#include <Adafruit_ST7735.h>                          /* libreria per il chip ST7735 di gestione del display */

Adafruit_ST7735 display1 = Adafruit_ST7735(cs1, rs1, rst1);   /* creazione oggetto display1 per la libreria Adafruit di gestione del chip del display */
Adafruit_ST7735 display2 = Adafruit_ST7735(cs2, rs2, rst2);   /* creazione oggetto display2 per la libreria Adafruit di gestione del chip del display */

#define Vref  5.0                                     /* calibrazione della tensione di riferimento delle misure */

/*
siccome Arduino legge in entrata al massimo 5 v, devo dividere con un partitore di tensione la Vin.
Per fare ciò utilizzo una Ra = 680 k Ohm e una Rb = trimmer 200 k Ohm.
*/

/*
il valore dei seguenti div sarà dato da Vin(max) / 5 .
Vin(max) viene calcolata con 5 / (Rb / (Ra + Rb)). Quindi div = (Ra + Rb) / Rb.
Ma siccome Ra è fisso, basta inserire il valore di Rb.
*/

int Ra1 = 680000;                                     /* valore in Ohm di Ra1 */
int Rb1 = 200000;                                     /* valore in Ohm di Rb1 */
int Ra2 = 680000;                                     /* valore in Ohm di Ra2 */
int Rb2 = 200000;                                     /* valore in Ohm di Rb2 */
int Ra3 = 680000;                                     /* valore in Ohm di Ra3 */
int Rb3 = 200000;                                     /* valore in Ohm di Rb3 */
int Ra4 = 680000;                                     /* valore in Ohm di Ra4 */
int Rb4 = 200000;                                     /* valore in Ohm di Rb4 */

int Vdigital[4] = {0, 0, 0, 0};
int VdigitalMAX[4] = {0, 0, 0, 0};
int Vanalog[4] = {0.00, 0.00, 0.00, 0.00};
int VanalogMAX[4] = {0.00, 0.00, 0.00, 0.00};
int coef[4] = {((Ra1 + Rb1) / Rb1), ((Ra2 + Rb2) / Rb2), ((Ra3 + Rb3) / Rb3), ((Ra4 + Rb4) / Rb4)};   /* array di valori fissi dati dalle resistenze di ogni canale */

void readCH(byte n){
  unsigned int Somma;
  byte Sample = 0;
  for (Sample <= 31; Sample++;){
    Somma = Somma + analogRead(n);
  }
  Vdigital[n] = Somma / 32;
  Somma = 0;
  Sample = 0;
}

void conversionDA(byte n){
  Vanalog[n] = (Vref * Vdigital[n]) / 1023 ;
  VanalogMAX[n] = (Vref * Vdigital[n]) / 1023 ;
}

void detectMAX(){
  for (byte contCH = 0; contCH < 3; contCH++) {
    if(Vdigital[contCH] > VdigitalMAX[contCH]){
      VdigitalMAX[contCH] = Vdigital[contCH];
    }
  }
}

bool select = false;
bool reset = false;

void keyboard(){
  byte keyboard = analogRead(A4);
  if (keyboard > 725){select = true;}
  else {select = false;}
  if(keyboard < 724 && keyboard > 0){reset = true;}
  else {reset = false;}
}

void resetMAX(){
  byte contMAX = 0;
  if (select){contMAX++;}
  for (byte contMAX; contMAX <= 3;){
    if (reset){VdigitalMAX[contMAX] = 0;}
  }
}

void printCH0(){
  display1.setTextColor(ST7735_GREEN,ST7735_BLACK);
  display1.setTextSize(2);
  display1.setCursor(40, 15);
  display1.print("VERDE ");
  display1.setCursor(40, 33);
  display1.print(Vanalog[0] * coef[0], 1);
  display1.print("V ");

  display1.setTextColor(ST7735_WHITE,ST7735_BLACK);
  display1.setTextSize(1);
  display1.setCursor(30, 53);
  display1.print("Vmax ");
  display1.print(VanalogMAX[0] * coef[0], 1);
  display1.print("V ");
}

void printCH1(){
  display1.setTextColor(ST7735_YELLOW,ST7735_BLACK);
  display1.setTextSize(2);
  display1.setCursor(25, 80);
  display1.print("GIALLA ");
  display1.setCursor(40, 100);
  display1.print(Vanalog[1] * coef[1], 1);
  display1.print("V ");

  display1.setTextColor(ST7735_WHITE,ST7735_BLACK);
  display1.setTextSize(1);
  display1.setCursor(30, 120);
  display1.print("Vmax ");
  display1.print(VanalogMAX[1] * coef[1], 1);
  display1.print("V ");
}

void printCH2(){
  display2.setTextColor(ST7735_RED,ST7735_BLACK);
  display2.setTextSize(2);
  display2.setCursor(40, 15);
  display2.print("ROSSO ");
  display2.setCursor(40, 33);
  display2.print(Vanalog[2] * coef[2], 1);
  display2.print("V ");

  display2.setTextColor(ST7735_WHITE,ST7735_BLACK);
  display2.setTextSize(1);
  display2.setCursor(30, 53);
  display2.print("Vmax ");
  display2.print(VanalogMAX[2] * coef[2], 1);
  display2.print("V ");
}

void printCH3(){
  display2.setTextColor(ST7735_BLUE,ST7735_BLACK);
  display2.setTextSize(2);
  display2.setCursor(25, 80);
  display2.print("BLU ");
  display2.setCursor(40, 100);
  display2.print(Vanalog[3] * coef[3], 1);
  display2.print("V ");

  display2.setTextColor(ST7735_WHITE,ST7735_BLACK);
  display2.setTextSize(1);
  display2.setCursor(30, 120);
  display2.print("Vmax ");
  display2.print(VanalogMAX[3] * coef[3], 1);
  display2.print("V ");
}

void setup() {
  display1.initR(INITR_BLACKTAB);      /* inizializza il chip ST7735 per il display1 */
  display1.fillScreen(ST7735_BLACK);   /* pulisci il display1 */
  display1.setTextColor(ST7735_WHITE); /* imposta il bianco come colore del testo */
 
  display1.setTextSize(1);             /* imposta la grandezza del testo */
  display1.setCursor(5,0);             /* imposta la posizione sul display1 */
  display1.println("GOSLOT");          /* scrivi */
  display1.setTextColor(0XFF00);       /* imposta il colore rosso per il testo */
  display1.setCursor(12,150);          /* imposta la posizione sul display1 */
  display1.println("Voltaggio MAX: 22 v"); /* scrivi */

  display2.initR(INITR_BLACKTAB);      /* inizializza il chip ST7735 per il display2 */
  display2.fillScreen(ST7735_BLACK);   /* pulisci il display2 */
  display2.setTextColor(ST7735_WHITE); /* imposta il bianco come colore del testo */

  display2.setTextSize(1);             /* imposta la grandezza del testo */
  display2.setCursor(5,0);             /* imposta la posizione sul display2 */
  display2.println("GOSLOT");          /* scrivi */
  display2.setTextColor(0XFF00);       /* imposta il colore rosso per il testo */
  display2.setCursor(12,150);          /* imposta la posizione sul display2 */
  display2.println("Voltaggio MAX: 22 v"); /* scrivi */
}

void loop() {
  keyboard();
  readCH(0);
  readCH(1);
  readCH(2);
  readCH(3);
  detectMAX();
  resetMAX();
  conversionDA(0);
  conversionDA(1);
  conversionDA(2);
  conversionDA(3);
  printCH0();
  printCH1();
  printCH2();
  printCH3();
}

ricki158

In pratica, i pin dei display dovrò provarli per vedere le connessioni da fare.
Ho il dubbio sull'alimentazione dell'Arduino.
Non sono sicuro che le funzioni di acquisizione siano corrette: l'idea è di acquisire 32 valori e farne la media. Tutto mantenendomi in digitale. Solo nel momento in cui ho bisogno di un valore da stampare vado a convertire in analogico e poi solo nel momento in cui devo stampare fisicamente sullo schermo moltiplico il valore analogico per il proprio coefficiente.
Ho qualche problema sul capire i tipi di variabili da usare:

- ho degli array formati da 4 elementi che vanno da 0 a 1023;
- ho degli array formati da 4 elementi che vanno da 0 a 5 volt con 2 cifre dopo la virgola;
- ho un array formato da 4 elementi che saranno costanti ma composti da un numero con virgola attorno ai 4,4;
- i valori delle resistenze potrei inserirli come #define, non ha senso dichiararli come variabili. idem l'array precedente;
- Vref c'è modo di controllarlo automaticamente e internamente all'Arduino oppure devo fare una misura e inserirlo a mano? Questo perché se lo facesse automaticamente non avrei problemi dovuti a qualsiasi tipo di fluttuazione e la misura finale non sarebbe affetta da quel errore;
- ho cercato di essere il più "generico" possibile, così da riusare la stessa funzione soltanto cambiando la variabile in ingresso, ma è giusto quello che ho scritto? Si poteva fare meglio?

In realtà non so nemmeno se questo codice funziona, la pista non è a casa mia e dobbiamo trovare una sera per tirare i cavi e fare un bel lavoro con un bel connettore, quindi sostanzialmente sto lavorando alla "cieca" senza poter provare sul campo il codice.

Go Up