dividere in 2 parti il numero 99999 e regolare 3 cifre, poi 2 cifre per volta

mannaggia non ho la piu pallida idea di come fare =( a fare una cosa del genere,

devo associare ad una variabile K un numero preso tramite potenziometro lineare 10 giri (tramite map (analogRead(A0)

solo che il numero potrebbe arrivare anche a 99999 (5 cifre) il potenziometro regola decentemente fino a 3 cifre, come posso fare per regolare le cifre dividendoli in 2 blocchi

faccio un esempio pratico es tenendo premuto un pulsante (o senza pulsante) associo solo le 3 cifre di sinistra girando il potenziometro

premendo un altro pulsante associo solo le 2 cifre di destra girando il potenziometro

moltiplichi per 1000 e sommi, non so se ho ben capito la damanda

variabile da due cifre 55 variabile da 3 cifre 845

55*1000 + 845 = 55845

allora: cerco di essere piu chiaro devo associare alla variabile K in poco tempo tramite potenziometro un numero es 12345 se faccio un map 0 1023 0 99999 poi mi riesce molto difficile regolare con precisione e velocemente le cifre 45

volevo regolare prima prima le prime tre cifre e poi le altre 2 con un map 0 1023 0 999

pablos:
moltiplichi per 1000 e sommi, non so se ho ben capito la damanda

variabile da due cifre 55
variabile da 3 cifre 845

55*1000 + 845 = 55845

ok dai non l’ho afferrato subito ma adesso forse ho compreso (tanks)
domani provo a mettere in pratica

GINGARDU: poi mi riesce molto difficile regolare con precisione e velocemente le cifre 45

Non le puoi regolare per il semplicissimo motivo che l'ADC ha una risoluzione di 10 bit, ovvero 1024 step e usando la map tra 0 e 99999 ottieni che ogni count del ADC diventano 10 count in uscita dalla map. Non ti serve la map, anzi è deleteria in questo caso, semplicemente regola il valore tra 0 e 1000 usando direttamente la lettura del ADC, poi regoli le due cifre delle migliaia, da 0 a 99, semplicemente moltiplicando per 1000 la lettura del ADC, usi un solo giro invece di 10, in questo modo ottieni variazioni di 1000 per volta e basta che le sommi al valore del contatore per integrare il tuo numero.

allora vediamo se ne "esco fuori"

faccio altre 2 variabili oltre a K millimetri centesimi

metto 2 pulsanti che portano HIGH pin 1 e 2 la cifra da immettere dentro k è 12345 (123 millimetri e 45 centesimi)

if (pin 1 == HIGH ) millimetri = AnalogRead (A0) *100 // tengo premuto il pulsante e col pot. metto 123

if (pin 2 == HIGH ) centesimi =AnalogRead (A0) //tengo premuto il pulsante e col pot. metto 45

if (pin 1 == HIGH ) K = millimetri + centesimi; if ( pin 2 == HIGH ) K = millimetri + centesimi;

// K assume il valore 12345 ed è pure libera incrementare decrementare .. GIUSTO??

scusa questa variabile k dove va a finire in seriale?

if (pin 1 == HIGH ) millimetri = AnalogRead (A0) *100 // tengo premuto il pulsante 1 e col pot. metto 123 if (pin 2 == HIGH ) centesimi =AnalogRead (A0) //tengo premuto il pulsante 2 e col pot. metto 45 K = millimetri + centesimi;

in effetti perchè non usi un solo giro come ti è stato suggerito sopra, comunque occhio che se la somma supera i 65000 ed è un INT si schianta il prog dovrai usare un long

ciao

k VA A pilotare 5 display a 7 segmenti K e anche "collegata" a un encoder incrementale che incrementa/decrementa in base al verso di rotazione

quindi usi 12 pin in tutto? 13 se usi la virgola forse un lcd era più semplice :.

purtroppo in questo tipo di applicazione ci vanno i led è un DRO

http://www.ebay.it/itm/3-Axis-Mill-Budget-DRO-Digital-Readout-Display-Console-/280900365387?pt=LH_DefaultDomain_3&hash=item4166f76c4b

Occhio che k poi diventa una variabile long o unsigned long Econ questa riga di codice

if (pin 1  ==  HIGH ) millimetri = AnalogRead (A0) *100  //  tengo premuto il pulsante 1 e col pot. metto 123

Anche millimetri diventa una variabile long Se vuoi risparmiare spazio di conviene leggerla singolarmente all'inizio e poi moltiplicarla per cento quando la sommi con centimetri , il risultato è lo stesso ma risparmi memoria Ciao Niko

k lho dichiarata come float ma effettivamente se moltiplico AnalogRead (A0) *100 a volte mi da un numero grande negativo :fearful: e mi sballa tutto

MA PERCHE ? ....

Perché i float sono numeri particolari, memorizzati in forma di una mantissa ed un esponente. Alle volte gli arrotondamenti nei calcoli portano poi a dei decimali che compaiono dal nulla.

Domanda. Leggendo un numero intero (il valore di una porta analogica), a che ti serve memorizzare il suo valore in un float?

all'inizio avevo messo int ma era una "tragedia" uscivano quasi sempre numeri col meno iniziale :fearful:

quasi sicuramente era perche l'int non puo essere usato per un numero troppo alto

qui c'è la prima parte del codice

se si puo usare qualcos'altro al posto di float (int proprio non va) lo provo

int A = 0;     // mappa per regolare le prime 3 cifre
int B = 1023 ; // mappa per regolare le prime 3 cifre
int C = 0 ;    // mappa per regolare le prime 3 cifre
int D = 180 ;    // mappa per regolare le prime 3 cifre

int E = 0;    // mappa per regolare le ultime   2 cifre
int F = 1023; // mappa per regolare le ultime   2 cifre
int G = 0;    // mappa per regolare le ultime   2 cifre
int H = 99;   // mappa per regolare le ultime   2 cifre



float millimetri ;
float centesimi ;

float CFR1;  //display 7 seg  per visualizzare il trattino se necessario
float CFR2;  //display 7 seg
float CFR3;  //display 7 seg



float sfarfallio = 3900;  //serve per aggistare lo sfarfallio se cè

float CFR4;  //display 7 seg
float CFR5;  //display 7 seg
float CFR6;  //display 7 seg

float K = 0;


                               

 void setup () {  
   

     
 // Serial.begin(9600); 
//pinMode (0, OUTPUT);   
//pinMode (1, INPUT);   
pinMode (2, OUTPUT); 
pinMode (3, OUTPUT); 
pinMode (4, OUTPUT);  
pinMode (5, OUTPUT);  
pinMode (6, OUTPUT);  
pinMode (7, OUTPUT); 
pinMode (8, OUTPUT);
pinMode (9, OUTPUT); 
pinMode (10, OUTPUT);  
pinMode (11, OUTPUT); 
pinMode (12, OUTPUT);  
pinMode (13, OUTPUT);
//pinMode (14, OUTPUT);
//pinMode (15, OUTPUT);
pinMode (16, INPUT);
pinMode (17, INPUT);
pinMode (18, OUTPUT);
pinMode (19, OUTPUT);

digitalWrite (16, HIGH);  //seconda cifra
digitalWrite (17, HIGH);  //prima cifra

digitalWrite (3, HIGH);  //seconda cifra
digitalWrite (4, HIGH);  //prima cifra
digitalWrite (2, HIGH);  //segmento  f  sinistra,alto
digitalWrite (5, HIGH);  //segmento  e  sinistra,basso
digitalWrite (6, HIGH);  //segmento  d  basso
digitalWrite (7, HIGH);  //segmento  c  destra,basso
digitalWrite (8, HIGH);  //segmento  b  destra,alto
digitalWrite (9, HIGH);  //segmento  a  alto
digitalWrite (10, HIGH); //segmento  g centrale
digitalWrite (11, HIGH); //terza cifra
digitalWrite (12, HIGH); //quarta cifra
digitalWrite (18, HIGH); // quinta cifra 
digitalWrite (19, HIGH); // sesta cifra 




}

void loop () 

 {
   
if ( digitalRead (16) == HIGH )  millimetri = map(analogRead(A0), A, B, C, D);
if ( digitalRead (17) == HIGH )  centesimi= map(analogRead(A0), E, F, G, H);
millimetri = millimetri*100;

if ( digitalRead (16) == HIGH ) K = millimetri + centesimi ;
if ( digitalRead (17) == HIGH ) K = millimetri + centesimi ;

Un "int" contiene un numero il cui valore oscilla da -32768 a +32767. Se dentro ad un int ci infili un valore superiore a $7FFF (32767) il numero cambia di segno. Per contenere un numero più grande usa un "unsigned int", che contiene un intero senza segno da 0 a 65535. Altrimenti usa l'unsigned long, che va da 0 a 2^32-1

tanks,

ho provato a sostituire tutti i float con long il risultato e che funzionano sia i float che i long

solo che con i long il codice passa da 24.000 a 15.000 kb :fearful:

quindi e meglio tenere i long perche mi serve spazioo per mettere il codice dell'encoder,

poi provo anche l'unsigned long per vedere cosa cambia

Tra long e unsigned long non cambia l'occupazione di memoria, sono sempre 4 byte. Cambia solo il modo in cui viene gestisto il contenuto delle variabili, con o senza segno.