volevo chiedere a qualcuno, se posso fare in modo di scrivere una sola volta 10 righe di codice
come queste
if (k0 >= 10 && k1s <= 20) k0=k0-10;
if (k0 >= 20 && k1s <= 30) k0=k0-20;
if (k0 >= 30 && k1s <= 40) k0=k0-30;
if (k0 >= 40 && k1s <= 50) k0=k0-40;
if (k0 >= 50 && k1s <= 60) k0=k0-50;
if (k0 >= 60 && k1s <= 70) k0=k0-60;
if (k0 >= 70 && k1s <= 80) k0=k0-70;
if (k0 >= 80 && k1s <= 90) k0=k0-80;
if (k0 >= 90 && k1s <= 99) k0=k0-90;
e poi richiamare questo codice magari inserendo una sola lettera o lettera piu numero al posto di tutta la "pappardella" per poter risparmiare memoria e ne avrei bisogno un po di piu a disposizione
leo72:
Mi par di capire che vuoi k0 compreso fra 0 e 9.
k0 %= 10
Così hai il modulo 10 di k0.
di preciso volevo imparare se un "sezione di codice" ripetuta nel codice decine o centinaia di volte
si puo fare diversamente che ripetere il tutto, non è che è un Problema "ripetere" e solo che se l'arduino ha la memoria che ha :0 e il progammino che sto tentando di fare l'esaurisce
e mi pare sopratutto per l'enorme quantita di codice ripetuto,
Se di preciso vuoi imparare quello che dici sopra devi creare una funzione che racchiude quel codice, in modo da riutilizzarlo semplicemente richiamando la funzione nel tuo codice.
Dai una lettura a wikipedia per capire di cosa stiamo parlando, ma ci sono miliardi di risorse sulla programmazone in rete, puoi provare a cercare quella a te più congeniale
Vista appunto la limitata quantità di Ram (più che di Flash), si cerca di ottimizzare sempre, non di fare esperimenti
Cmq se proprio vuoi ottimizzare il tuo codice, io proverei con un ciclo for per vedere cosa puoi ottenere. Tipo così:
Però rispetto al precedente consuma un sacco di più, anche in termini di calcolo perché se ad esempio k0 è compreso fra 90 e 99, devi farti 9 cicli for e 9 if a vuoto.
leo72:
Vista appunto la limitata quantità di Ram (più che di Flash), si cerca di ottimizzare sempre, non di fare esperimenti
Cmq se proprio vuoi ottimizzare il tuo codice, io proverei con un ciclo for per vedere cosa puoi ottenere. Tipo così:
Però rispetto al precedente consuma un sacco di più, anche in termini di calcolo perché se ad esempio k0 è compreso fra 90 e 99, devi farti 9 cicli for e 9 if a vuoto.
grazie lo stesso anche se non ho la minima idea di quello che fa il tuo codice e non so se hai intuito su che che cosa mi sto "allenando" sto cercando di fare una specie di "voltmetro" (analogRead) con i display a 7 segmenti in multiplex
solo l'arduino uno e i display collegati direttamente il tutto sembra funzionare ma se aggiungo la 5-6 cifra
supero i 32 k uff.....
adesso sto rifacendo il tutto (levandoalcune ripetizioni di codice) sono a 4 quasi cifre e circa 8 k di memoria
mi interessa completarlo perche questo sara il primo progetto che realizzero completo
ma almeno dovrebbe pilotare 6 cifre e lasciare un po di memoria per altro
e si potrebbe usare per tante cosette, tipo timer, visualizzatore di temperatura e umidita, calibri digitali ecc..
comunque la mia domanda è ancora valida,
c'è un sistema per associare una parte del programma a qualche "cosa" in modo da non ripetere sempre tutto la parte in caso di bosogno?
leo72:
Vista appunto la limitata quantità di Ram (più che di Flash), si cerca di ottimizzare sempre, non di fare esperimenti
Cmq se proprio vuoi ottimizzare il tuo codice, io proverei con un ciclo for per vedere cosa puoi ottenere. Tipo così:
Però rispetto al precedente consuma un sacco di più, anche in termini di calcolo perché se ad esempio k0 è compreso fra 90 e 99, devi farti 9 cicli for e 9 if a vuoto.
grazie lo stesso anche se non ho la minima idea di quello che fa il tuo codice e non so se hai intuito su che che cosa mi sto "allenando" sto cercando di fare una specie di "voltmetro" (analogRead) con i display a 7 segmenti in multiplex
solo l'arduino uno e i display collegati direttamente il tutto sembra funzionare ma se aggiungo la 5-6 cifra
supero i 32 k uff.....
adesso sto rifacendo il tutto (levandoalcune ripetizioni di codice) sono a 4 quasi cifre e circa 8 k di memoria
mi interessa completarlo perche questo sara il primo progetto che realizzero completo
ma almeno dovrebbe pilotare 6 cifre e lasciare un po di memoria per altro
e si potrebbe usare per tante cosette, tipo timer, visualizzatore di temperatura e umidita, calibri digitali ecc..
comunque la mia domanda è ancora valida,
c'è un sistema per associare una parte del programma a qualche "cosa" in modo da non ripetere sempre tutto la parte in caso di bosogno?
Io proverei a vedere come funzionano le "funzioni" (come ti suggerivano gli altri). Se ho capito bene fanno proprio al caso tuo e vedrai che non sono difficili per nulla
@Gingiardu:
come fai a superare 32K di firmware con il pilotaggio di un display? Mi sembra eccessivo. Hai altre cose insieme? Che lib carichi?
PS:
il mio codice fa esattamente quello che fanno i tuoi 10 if uno dietro l'altro. Se vuoi ti sviluppo i primi 2 passaggi:
for (byte temp=10; temp<99; temp +=10) {
if ((k0 >= temp) && (k0 <= (temp + 9))) {
k0-=(temp*1);
}
}
leo72: @Gingiardu:
come fai a superare 32K di firmware con il pilotaggio di un display? Mi sembra eccessivo. Hai altre cose insieme? Che lib carichi?
PS:
il mio codice fa esattamente quello che fanno i tuoi 10 if uno dietro l'altro. Se vuoi ti sviluppo i primi 2 passaggi:
for (byte temp=10; temp<99; temp +=10) {
if ((k0 >= temp) && (k0 <= (temp + 9))) {
k0-=(temp*1);
}
}
purtroppo non adopero nessun altra cosa,
con il nuovo codice sono a 9 k di memoria 3 cifre
provero il ciclo for per tutti gli if che alla fine dovrebbero essere il doppio di quelli postati
tutto il programma non deve superare i 12-15 millisecondi per "girare" se no i display iniziano a "vibrare"
if (k0 >= 1000 && k0 <= 2000) k0=k0-1000;
if (k0 >= 2000 && k0 <= 3000) k0=k0-2000;
if (k0 >= 3000 && k0 <= 4000) k0=k0-3000;
if (k0 >= 4000 && k0 <= 5000) k0=k0-4000;
if (k0 >= 5000 && k0 <= 6000) k0=k0-5000;
if (k0 >= 6000 && k0 <= 7000) k0=k0-6000;
if (k0 >= 7000 && k0 <= 8000) k0=k0-7000;
if (k0 >= 8000 && k0 <= 9000) k0=k0-8000;
if (k0 >= 9000 && k0 <= 9999) k0=k0-9000;
if (k0 >= 100 && k0 <= 200) k0=k0-100;
if (k0 >= 200 && k0 <= 300) k0=k0-200;
if (k0 >= 300 && k0 <= 400) k0=k0-300;
if (k0 >= 400 && k0 <= 500) k0=k0-400;
if (k0 >= 500 && k0 <= 600) k0=k0-500;
if (k0 >= 600 && k0 <= 700) k0=k0-600;
if (k0 >= 700 && k0 <= 800) k0=k0-700;
if (k0 >= 800 && k0 <= 900) k0=k0-800;
if (k0 >= 900 && k0 <= 999) k0=k0-900;
if (k0 >= 10 && k0 <= 20) k0=k0-10;
if (k0 >= 20 && k0 <= 30) k0=k0-20;
if (k0 >= 30 && k0 <= 40) k0=k0-30;
if (k0 >= 40 && k0 <= 50) k0=k0-40;
if (k0 >= 50 && k0 <= 60) k0=k0-50;
if (k0 >= 60 && k0 <= 70) k0=k0-60;
if (k0 >= 70 && k0 <= 80) k0=k0-70;
if (k0 >= 80 && k0 <= 90) k0=k0-80;
if (k0 >= 90 && k0 <= 99) k0=k0-90;
if (k1s >= 1000 && k1s <= 2000) k1s=k1s-1000;
if (k1s >= 2000 && k1s <= 3000) k1s=k1s-2000;
if (k1s >= 3000 && k1s <= 4000) k1s=k1s-3000;
if (k1s >= 4000 && k1s <= 5000) k1s=k1s-4000;
if (k1s >= 5000 && k1s <= 6000) k1s=k1s-5000;
if (k1s >= 6000 && k1s <= 7000) k1s=k1s-6000;
if (k1s >= 7000 && k1s <= 8000) k1s=k1s-7000;
if (k1s >= 8000 && k1s <= 9000) k1s=k1s-8000;
if (k1s >= 9000 && k1s <= 9999) k1s=k1s-9000;
if (k1s >= 100 && k1s <= 200) k1s=k1s-100;
if (k1s >= 200 && k1s <= 300) k1s=k1s-200;
if (k1s >= 300 && k1s <= 400) k1s=k1s-300;
if (k1s >= 400 && k1s <= 500) k1s=k1s-400;
if (k1s >= 500 && k1s <= 600) k1s=k1s-500;
if (k1s >= 600 && k1s <= 700) k1s=k1s-600;
if (k1s >= 700 && k1s <= 800) k1s=k1s-700;
if (k1s >= 800 && k1s <= 900) k1s=k1s-800;
if (k1s >= 900 && k1s <= 999) k1s=k1s-900;
if (k1s3 >= 1000 && k1s <= 2000) k1s3=k1s3-1000;
if (k1s3 >= 2000 && k1s <= 3000) k1s3=k1s3-2000;
if (k1s3 >= 3000 && k1s <= 4000) k1s3=k1s3-3000;
if (k1s3 >= 4000 && k1s <= 5000) k1s3=k1s3-4000;
if (k1s3 >= 5000 && k1s <= 6000) k1s3=k1s3-5000;
if (k1s3 >= 6000 && k1s <= 7000) k1s3=k1s3-6000;
if (k1s3 >= 7000 && k1s <= 8000) k1s3=k1s3-7000;
if (k1s3 >= 8000 && k1s <= 9000) k1s3=k1s3-8000;
if (k1s3 >= 9000 && k1s <= 9999) k1s3=k1s3-9000;
if (k1s3 >= 100 && k1s3 <= 200) k1s3=k1s3-100;
if (k1s3 >= 200 && k1s3 <= 300) k1s3=k1s3-200;
if (k1s3 >= 300 && k1s3 <= 400) k1s3=k1s3-300;
if (k1s3 >= 400 && k1s3 <= 500) k1s3=k1s3-400;
if (k1s3 >= 500 && k1s3 <= 600) k1s3=k1s3-500;
if (k1s3 >= 600 && k1s3 <= 700) k1s3=k1s3-600;
if (k1s3 >= 700 && k1s3 <= 800) k1s3=k1s3-700;
if (k1s3 >= 800 && k1s3 <= 900) k1s3=k1s3-800;
if (k1s3 >= 900 && k1s3 <= 999) k1s3=k1s3-900;
ma giusto per capire a te serve che k non sia maggiore di 10?
in tal caso basta un
while(k >= 10) k/10;
controlla che k non sia superiore uguale a 10, nel caso lo sia inizia un ciclio dividendo k per 10 continuamente finchè non rientra nella condizione del while ovvero k >= 10
non puoi spiegare meglio il tuo progetto per bene? magari esiste un altro modo più "bello" per fare le cose
Sbagli approccio, non puoi infarcire il programma di tutti quegli if.
Che poi alla fine sono tutti ridondanti e riducibili con diverse opzioni. Certe volte non conta cosa si vuol fare ma come lo si fa. Sul come farlo hai già diverse risposte: dalle funzioni ai metodi che ti ho mostrato.
Poi io non so esattamente cosa vuoi fare, anzi non l'ho proprio capito quindi non giudico bene.
Hai una lettura che vuoi scomporre nelle singole cifre?
Se ti può far comodo, questo è un pezzettino di poche righe del firmware della mia stazioncina meteo che spedisce via I2C un numero di 4 cifre nel formato NNNNN ad un Tiny84 che poi lo visualizza.
Ma tu puoi estrarre l'algoritmo e riproporlo per il tuo display:
void inviaNumeroGrande(int numero) {
int temp, num;
int misura;
if (numero>9999) {
misura=9999;
} else if (numero>999) {
misura=999;
} else if (numero>99) {
misura=99;
} else {
misura=9;
}
num=numero;
Wire.beginTransmission(LCD);
Wire.send(0x02);
do {
if (num>misura) {
temp=int(num/(misura+1));
Wire.send(char(temp+4void inviaNumeroGrande(int numero) {
int temp, num;
int misura;
if (numero>9999) {
misura=9999;
} else if (numero>999) {
misura=999;
} else if (numero>99) {
misura=99;
} else {
misura=9;
}
num=numero;
Wire.beginTransmission(LCD);
Wire.send(0x02);
do {
if (num>mivoid inviaNumeroGrande(int numero) {
int temp, num;
int misura;
if (numero>9999) {
misura=9999;
} else if (numero>999) {
misura=999;
} else if (numero>99) {
misura=99;
} else {
misura=9;
}
num=numero;
Wire.beginTransmission(LCD);
Wire.send(0x02);
do {
if (num>misura) {
temp=int(num/(misura+1));
Wire.send(char(temp+48));
num-=(temp*(misura+1));
} else {
Wire.send("0");
}
misura/=10;
} while (misura>0);
Wire.send(char(num+48));sura) {
temp=int(num/(misura+1));
Wire.send(char(temp+48));
num-=(temp*(misura+1));
} else {
Wire.send("0");
}
misura/=10;
} while (misura>0);
Wire.send(char(num+48));8));
num-=(temp*(misura+1));
} else {
Wire.send("0");
}
misura/=10;
} while (misura>0);
Wire.send(char(num+48));
(.....)
}
Dovrebbe accettare numeri da 0 a 9999, se non ricordo male.
Spedisce 1 cifra alla volta partendo da quella più a SX.
non puoi spiegare meglio il tuo progetto per bene? magari esiste un altro modo più "bello" per fare le cose
perché a volte capita di prendere una strada tortuosa fin dall'inizio e poi ci si incasina.
Credo che questo abbia a che fare con l'altro topic in cui chiedevi sull'analogRead.
Capendo bene cosa vorresti fare è molto più semplice aiutarti
non puoi spiegare meglio il tuo progetto per bene? magari esiste un altro modo più "bello" per fare le cose
perché a volte capita di prendere una strada tortuosa fin dall'inizio e poi ci si incasina.
Credo che questo abbia a che fare con l'altro topic in cui chiedevi sull'analogRead.
Capendo bene cosa vorresti fare è molto più semplice aiutarti
quello che voglio fare principalmente è imparare, e per quanto riguarda questo progetto voglio far pilotare, ad arduino uno,
** 6 display 7 segmenti, direttamente senza altri integrati di mezzo, che ovviamente devono visualizzare un valore che viene letto in un ingresso analogico o digitale**
l'ingresso analogico puo essere qualsiasi cosa potenziometro, sensore temperatura, ecc,
di sicuro poi il codice verra leggermente modificato in base a quello che devi visualizzare
o se servono solo 3 cifre es per visualizzare un valore standard basta adoperare le prime tre a destra
PS:
il mio codice fa esattamente quello che fanno i tuoi 10 if uno dietro l'altro. Se vuoi ti sviluppo i primi 2 passaggi:
for (byte temp=10; temp<99; temp +=10) {
if ((k0 >= temp) && (k0 <= (temp + 9))) {
k0-=(temp*1);
}
}
OK PERFETTO ho inserito il tuo codice con copia e incolla e sembra funzionare perfettamente (display stabili e luminosi) poi alla fine ne faccio 2 versioni una con i FOR e l'altra "normale" se funzionano tutti e 2 teniamo quella che occupa meno spazio
PS:
il mio codice fa esattamente quello che fanno i tuoi 10 if uno dietro l'altro. Se vuoi ti sviluppo i primi 2 passaggi:
for (byte temp=10; temp<99; temp +=10) {
if ((k0 >= temp) && (k0 <= (temp + 9))) {
k0-=(temp1);
}
}
temp parte da 10
confronto: k0>=10 && k0<=19? Sì: k0 = k0-(101)
no: temp = temp+10
confronto: k0>=20 && k0<=29? Sì: k0 = k0-(10*2)
ecc...
OK PERFETTO ho inserito il tuo codice con copia e incolla e sembra funzionare perfettamente (display stabili e luminosi) poi alla fine ne faccio 2 versioni una con i FOR e l'altra "normale" se funzionano tutti e 2 teniamo quella che occupa meno spazio
secondo me è ancora meglio creare una funzione che ti divida in un array i vari numeri che poi mandi al display, magari usi il leOS per scrivere sui dispaly ad intervalli regolari così sei sicuro che non "sflashino" tanto non credo sia una funzione lunga..
allora ho quasi finito .... :~ il tutto occupa 25.416 bytes per 6 cifre 7 segmenti adesso vorrei provare a smagrire con i cicli for ma purtroppo non so come adattarli =( al programma (ho tentato ma nulla)
esempio una sequenza del genere e possibile fare un ciclo for unico? o piu cicli for, e come ?
C1= map(analogRead(A0), a, b, c, d);
//Serial.println ( C1, DEC );
if (C1>= 100000 && C1<= 200000) C1=C1-100000;
if (C1>= 200000 && C1<= 300000) C1=C1-200000;
if (C1>= 300000 && C1<= 400000) C1=C1-300000;
if (C1>= 400000 && C1<= 500000) C1=C1-400000;
if (C1>= 500000 && C1<= 600000) C1=C1-500000;
if (C1>= 600000 && C1<= 700000) C1=C1-600000;
if (C1>= 700000 && C1<= 800000) C1=C1-700000;
if (C1>= 800000 && C1<= 900000) C1=C1-800000;
if (C1>= 900000 && C1<= 999999) C1=C1-900000;
if (C1>= 10000 && C1<= 20000) C1=C1-10000;
if (C1>= 20000 && C1<= 30000) C1=C1-20000;
if (C1>= 30000 && C1<= 40000) C1=C1-30000;
if (C1>= 40000 && C1<= 50000) C1=C1-40000;
if (C1>= 50000 && C1<= 60000) C1=C1-50000;
if (C1>= 60000 && C1<= 70000) C1=C1-60000;
if (C1>= 70000 && C1<= 80000) C1=C1-70000;
if (C1>= 80000 && C1<= 90000) C1=C1-80000;
if (C1>= 90000 && C1<= 99999) C1=C1-90000;
if (C1>= 1000 && C1<= 2000) C1=C1-1000;
if (C1>= 2000 && C1<= 3000) C1=C1-2000;
if (C1>= 3000 && C1<= 4000) C1=C1-3000;
if (C1>= 4000 && C1<= 5000) C1=C1-4000;
if (C1>= 5000 && C1<= 6000) C1=C1-5000;
if (C1>= 6000 && C1<= 7000) C1=C1-6000;
if (C1>= 7000 && C1<= 8000) C1=C1-7000;
if (C1>= 8000 && C1<= 9000) C1=C1-8000;
if (C1>= 9000 && C1<= 9999) C1=C1-9000;
if (C1>= 100 && C1<= 200) C1=C1-100;
if (C1>= 200 && C1<= 300) C1=C1-200;
if (C1>= 300 && C1<= 400) C1=C1-300;
if (C1>= 400 && C1<= 500) C1=C1-400;
if (C1>= 500 && C1<= 600) C1=C1-500;
if (C1>= 600 && C1<= 700) C1=C1-600;
if (C1>= 700 && C1<= 800) C1=C1-700;
if (C1>= 800 && C1<= 900) C1=C1-800;
if (C1>= 900 && C1<= 999) C1=C1-900;
//Serial.print ( " C1 ");
//Serial.println (C1, DEC );
//Serial.println ( " ");
if (C1>= 10 && C1<= 20) C1=C1-10;
if (C1>= 20 && C1<= 30) C1=C1-20;
if (C1>= 30 && C1<= 40) C1=C1-30;
if (C1>= 40 && C1<= 50) C1=C1-40;
if (C1>= 50 && C1<= 60) C1=C1-50;
if (C1>= 60 && C1<= 70) C1=C1-60;
if (C1>= 70 && C1<= 80) C1=C1-70;
if (C1>= 80 && C1<= 90) C1=C1-80;
if (C1>= 90 && C1<= 99) C1=C1-90;
leo72:
Ti avevo già messo un codice di poche righe nel mio replay #10 che scompone un numero in un array di char da spedire poi al tuo display.
si quel codice funziona bene al posto di quelle 10 righe, ma per il resto non riesco ad adattarlo, al resto del codice sicuramente è colpa della mia non troppa capacità di comprensione del ciclo for
provero a studiare per vedere se ci arrivo
quindi non giudico bene.