Programmo videogiochi con un programma basato su javascript.
Avendo queste due variabili:
int valoreStepper1 = 0
int valoreStepper2 = 0
int qualeStepper = 1;
vorrei richiamare il valore della variabile Stepper1 oppure Stepper2 in base alla variabile qualeStepper.
in Javascript farei così:
oled.print("valoreStepper"&qualeStepper));
cioè "valoreStepper1" e richiamare così il valore della variabile.
Oppure non è il modo corretto questo, quale è?
Sono alle prime armi in C.
In C lo puoi fare con un if o con l'operatore ternario
if(qualestepper==1){
oled.print(valoreStepper1);
}
else{
...
}
oppure
oled.print(qualeStepper==1?valoreStepper1:valoreStepper2);
Non credo che @fedekr intendesse una cosa di questo genere...
Sospetto che vorrebbe tipo identificare quale variabile da usare a runtime in funzione del valore di qualeStepper, cosa che in questo modo è impossibile da fare!
Forse facciamo prima se descrivi l'esigenza e non il modo in cui hai pensato di implementarne lo sviluppo software.
Array?
Però non vedo il nesso con Arduino...
Io do fiducia a OP e presumo che il nesso ci sia
Basta passare per due macro
int array[2];
int quale;
#define variabile0 array[0]
#define variabile1 array[1]
Ecco che "quale" diventa l'indice dellarray che casualmente corrisponde al "numero" della variabile
Ma è una 'porcellata' peggio che usare il "goto"
Pessima programmazione
Grazie delle vostre risposte
mi ritrovo con la risposta di cotestatnt che dice che è impossibile, credo che intendevo fare quello.
Comunque il mio progetto sarebbe quello di utilizzare uno schermo oled e almeno 2 motori stepper. Ci sono 2 pulsanti avanti e indietro per muovere il motore selezionato e vorrei che venisse riportato il valore in gradi del motore in questione.
Ma essendoci più di un motore, con altri 2 pulsanti avanti e indietro seleziono un altro motore e lo schermo oled visualizza la variabile riferita a quel motore, quindi ci saranno 2-3 o più variabili ognuna che segna la posizione di quel motore, e una che definisce il motore in questione.
Così è come ho pensato di fare per ora...
Perchè so già più o meno cosa voglio fare aldilà di Arduino cioè con gli stepper, ma non ancora con certezza, ho solo pensato di organizzarmi momentaneamente e poi vedere come continuare, se volete posso spiegarvi a cosa servirebbero ma forse va aldilà della programmazione.
Ciò che intendevo fare era selezionare la variabile del motore in questione (tutto ciò che deve mostrare l'oled) automaticamente in base alla variabile "qualeStepper". c'è una funzione che cancella tutto ogni sec e riscrive la variabile e il numero del motore. Cioè se qualeStepper è 1, lo schermo ogni sec mostra la variabile riferita al primo motore, se 2 il sec ecc...
Non so come si fa in questi casi...
Alla fine avevo capito bene, ti serve stampare sullo schermo un valore in base a quale motore stai gestendo. E da quel che dici il resto del codice è già presente e quindi la variabile qualeStepper è già valorizzata in modo corretto quindi se vuoi evitare una serie di if per stampare il valore credo che un array con i gradi di ogni motore possa fare al caso tuo, ad esempio:
int qualeStepper = 2;
int arrStepper[4] = {14, 18, 5, 9};
oled.print(arrStepper[(qualeStepper-1)]));
L'array è una possibilità, anche se io in questi casi preferisco usare un array di struct invece di tanti singoli array.
Si ma in questo caso deve memorizzare un solo valore quindi mi sfugge il senso dell'uso delle struct
Era più un discorso in generale il mio.
Magari le variabili da visualizzare potrebbero diventare più di una in futuro e dover duplicare/triplicare tutto secondo me è "poco elegante".
E' vero che con una struct ed eventuali funzioni che lavorano su questa struct aggiungi un livello di astrazione in più, ma se devi introdurre una modifica oppure incrementare gli elementi dell'array la modifica la fai una volta soltanto e si propaga in automatico a tutto l'insieme.
Qualcosa del genere... (lasciando perdere i collegamenti dei motori che non hanno senso... ma nel simulatore funziona quindi va bene cosi)
In questo caso l'applicazione è talmente semplice che non ha senso come giustamente facevi notare, però io ormai l'ho adottato come approccio "standard".
Se devo scrivere del codice che viene eseguito da due o più oggetti diversi, allora lo implemento come un array di struct o meglio ancora come una classe.
Scusatemi, cotestatnt ti ringrazio per il tuo esempio, ma è troppo complicato per me adesso, ho cercato di scrivere un codice prendendo l'esempio di fabpolli, ci sto provando da quasi un ora e non ci riesco.
Potreste correggere il mio codice?
Mi succede che quando cambio e passo allo stepper2 con il pulsante va in tilt il valore nello schermo oled continua a dare dei numeri a caso prima positivi poi negativi, dove sto sbagliando?
Forse c'è solo qualcosa che non fa contatto nella breadboard, ma per il primo elemento dell'array funziona... aiuto...
#include <Adafruit_SSD1306.h>
#define OLED_12C_ADDRESS 0x3C
#define OLED_WIDTH 128
#define OLED_HEIGHT 64
#define INPUT_PIN A0
int qualeStepper = 1;
int arrStepper[2] = {0, 0};
Adafruit_SSD1306 oled(OLED_WIDTH,OLED_HEIGHT);
void setup() {
if(!oled.begin(SSD1306_SWITCHCAPVCC, OLED_12C_ADDRESS)){
while(true);
}
oled.clearDisplay();
showHeader();
oled.display();
pinMode(8,INPUT);
pinMode(9,INPUT);
pinMode(7,INPUT); //qualeStepper
pinMode(6,INPUT); //qualeStepper
}
void loop() {
showHeader();
showValue();
oled.display();
delay(100);
if (digitalRead(8) == HIGH){
incrementovar();
}
if (digitalRead(9) == HIGH){
decrementovar();
}
if (digitalRead(7) == HIGH&&qualeStepper==1){ // prox stepper
++qualeStepper;
}
if (digitalRead(6) == HIGH&&qualeStepper==2){ // prev stepper
--qualeStepper;
}
}
void showHeader (){
oled.clearDisplay();
oled.setTextSize(1);
oled.setTextColor(WHITE);
oled.setCursor(4,4);
oled.print("Stepper"+String(qualeStepper));
oled.setCursor(112,4);
oled.drawLine(0, 15, 128, 15,WHITE);
}
void showValue(){
//oled.clearDisplay();
oled.fillRect(0,16,128,15,BLACK);
oled.setTextSize(1);
oled.setCursor(OLED_WIDTH/2,OLED_HEIGHT/2+8);
printCenteredText();
}
void printCenteredText(){
oled.print(String(arrStepper[(qualeStepper)]));
}
//-------
void incrementovar(){
++arrStepper[qualeStepper];
}
//------
//-------
void decrementovar(){
--arrStepper[qualeStepper];
}
Bruttissimo!
oled.print("Stepper"); oled.print(qualeStepper);
Hai messo le resistenze di pull-down sui pulsanti?
Considera anche che nulla definisce espressamente la velocità degli incrementi e dei decrementi: vanno alla velocità del loop... arrStepper è int, perciò che succede quando va in overflow?... 
if (digitalRead(7) == HIGH&&qualeStepper==1){ // prox stepper
++qualeStepper;
}
if (digitalRead(6) == HIGH&&qualeStepper==2){ // prev stepper
--qualeStepper;
lo scriverei più semplicemente:
if (digitalRead(7)==HIGH && qualeStepper==1) qualeStepper=2;
if (digitalRead(6)==HIGH && qualeStepper==2) qualeStepper=1;
Ok in quel senso si mi torna
Se le variabili fossero solo 2 si potrebbe
if (digitalRead(7)) qualeStepper=2;
if (digitalRead(6)) qualeStepper=1;
Più leggibili mi sembra
This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.