Go Down

Topic: funzioni e puntatori (Read 1 time) previous topic - next topic

makalu1

ciao a tutti , ho un problema che non riesco a spiegarmi sul perche´ quanto scritto in una funzione non vada, essendo semplicissimo come programma.
allora spiego :
il primo sketch allegato funziona e va bene , in pratica serve a pilotare un motore con un ponte h in pwm.
ossia ho collegato un potenziometro a slitta ad un ingresso analogico.
con potenziometro al centro motore fermo e setto un bit a uno che mi indica che sta fermo, riferimento pwm fermo, se vadosopra lo  zero con il potenziometro il motore gira da una parte e alzo un bit che mi indica arbitrariamente che gira in un verso, idem se vado sotto lo zero.
fino a qui ci siamo funziona come voglio io .
allego sketch che funziona:

/programma per il rilevamento del valore analogico da dare ad un motore che gira in due sensi e al centro e´fermo
Code: [Select]

//DICHIARAZIONE VARIABILI

int ref_in_elevator=0;//inizializzazione variabile reff in elevatore
const int low_ref_backward=0;//range valore motore indietro min
const int high_ref_backward=487;//range valore motore indietro max
const int low_ref_for_stop=488;//range di valori per motore fermo min
const int high_ref_for_stop=532;//range di valori per motore fermo max
const int low_ref_forward=533;//range valore motore avanti min
const int high_ref_forward=1023;//range valori motore avanti max
int ref_out_elevator=0; //inizializzazione riferimento analogico dopo elaborazione
boolean elevator_stop; //motore elevatore in stop
boolean elevator_sense_rotation;  //motore elevatore gira in senso orario true antiorario false
//fine dichiarazione variabili
void setup() {
  Serial.begin (9600);
}
void loop() {
ref_in_elevator=analogRead (0);
if (ref_in_elevator>=low_ref_backward && ref_in_elevator <= high_ref_backward) //caso motore indietro
{
elevator_stop=false; //motore in running bit false
elevator_sense_rotation=false; //senso di rotazione indietro
ref_out_elevator=255-(ref_in_elevator/2);
}
if (ref_in_elevator>=low_ref_for_stop && ref_in_elevator <= high_ref_for_stop) //caso potenziometro al centro motore fermo
{
elevator_stop=true;//motore in stop bit true
elevator_sense_rotation=true;// motore che gira avanti anche se e´fermo, per convenzione a motore fermo il led o bit lo setto alto
ref_out_elevator=0;
}
if (ref_in_elevator >= low_ref_forward && ref_in_elevator <= high_ref_forward) //caso potenziometro per motore avanti
{
elevator_stop=false; //motore in running bit false
elevator_sense_rotation=true;//motore avanti
ref_out_elevator=(ref_in_elevator-512)/2;
  } 
}  //fine main loop

Essendo in futuro 3 i motori da gestire ho voluto inserire una funzione che mi accorpi la gestione dei riferimenti da dare all´uscita pwm e la gestione del senso di rotazione.
Ecco qui non va piu´e lúscita pwm e´sempre a zero (visualizzabile anche da monitor seriale).
Abbiamo guardato in piu´persone dove puo´essere lérore ma nulla, il programma si compila correttamente ma di fatto non va.
ho perfino fatto una modifica utilizzano un puntatore per allocare i dati fuori dalla funzione ed in questo caso lúscita pwm (monitorata dal serial monitor )spara fuori sempre una serie di valori !pp!pp!pp .
allego i due sketch:

SKETCH CON FUNZIONI (SENZA PUNTATORI)
Code: [Select]

//programma per il rilevamento del valore analogico da dare ad un motore che gira in due sensi e al centro e´fermo

const int low_ref_backward=0;//range valori motore indietro min
const int high_ref_backward=487;//range valore motore indietro max
const int low_ref_for_stop=488;//range di valori per motore fermo min
const int high_ref_for_stop=532;//range di valori per motore fermo max
const int low_ref_forward=533;//range valore motore avanti min
const int high_ref_forward=1023;//range valori motore avanti max
boolean elevator_stop; //motore elevatore in stop
boolean elevator_sense_rotation;  //motore elevatore gira in senso orario true antiorario false
int ref_out_elevator=0;//riferimento dopo eleborazione funzione
int ref_in_elevator=0;//riferimento analogico prima dell elaborazione
//provvisorio comando uscite  ma in futuro si andra a settare variabili da trasmettere su seriale
int led_pwm=13;
int led_stop=12;
int led_sense=11;
//********************************START SET UP FUNCTION************************
void setup() {
pinMode(led_stop,OUTPUT);
pinMode(led_sense,OUTPUT);
pinMode(7,OUTPUT);
Serial.begin(300);
}
//*******************************END SET UP FUNCTION**************************
//*******************************MAIN LOOP***********************************
void loop() {
  //elaborazione motore elevatore
  ref_in_elevator=analogRead (0);

ref_out_elevator=refManageFunction(ref_in_elevator);

elevator_sense_rotation=rotationDefineFunction(ref_in_elevator);

if (ref_out_elevator=0) { elevator_stop=true;}
  else { elevator_stop=false;}
  //elaborazione motore dx
  //elaborazione motore sx
  //temporaneo per provare la funzione su dei led
   Serial.println(ref_out_elevator);
  analogWrite(led_pwm,ref_out_elevator);
  digitalWrite (led_stop,elevator_stop);
  digitalWrite(led_sense,elevator_sense_rotation);
  } 
//****************************END MAIN LOOP****************************
//*********************************ANALOG SIGNAL MANAGE FUNCTION*****************
int refManageFunction (int ref_in) {
static int ref_out;
if (ref_in>=low_ref_backward && ref_in <= high_ref_backward) //caso motore indietro
{
ref_out=255-(ref_in/2);
}
if (ref_in>=low_ref_for_stop && ref_in <= high_ref_for_stop) //caso potenziometro al centro motore fermo
{
ref_out=0;
}
if (ref_in >= low_ref_forward && ref_in <= high_ref_forward) //caso potenziometro per motore avanti
{
ref_out=(ref_in-512)/2;


return ref_out;

//***************************************END FUNCTION**************
//*****************SENSE ROTATION DEFINITION FUNCTION**********************
int rotationDefineFunction (int ref_in) {
boolean sense_rotation;
if (ref_in>=low_ref_backward && ref_in_elevator <= high_ref_backward) //caso motore indietro
{
sense_rotation=false;
}
if (ref_in>=low_ref_for_stop && ref_in <= high_ref_for_stop) //caso potenziometro al centro motore fermo
{
sense_rotation=false;
}
if (ref_in >= low_ref_forward && ref_in <= high_ref_forward) //caso potenziometro per motore avanti
{
sense_rotation=true;

return sense_rotation;

//*********************END FUNCTION***********************


Ho pure inserito la gestione della variabile elaborata dalla funzione come puntatore in questo modo:
Code: [Select]

int ref_out; //puntatore funzione  dichiarazione in coda alle dichiarazioni variabili

//elaborazione motore elevatore
ref_in_elevator=analogRead (0);
ref_out_elevator=refManageFunction(ref_in_elevator,&ref_out);
elevator_sense_rotation=rotationDefineFunction(ref_in_elevator);/code]
zanini marco

makalu1

dimenticavo un pezzo nello sketch che fa uso dei puntatori:
Code: [Select]
//*********************************ANALOG SIGNAL MANAGE FUNCTION*****************

int refManageFunction (int ref_in,int*ref_out) {
 
if (ref_in>=low_ref_backward && ref_in <= high_ref_backward) //caso motore indietro
*ref_out=255-(ref_in/2);
if (ref_in>=low_ref_for_stop && ref_in <= high_ref_for_stop) //caso potenziometro al centro motore fermo
*ref_out=0;
if (ref_in >= low_ref_forward && ref_in <= high_ref_forward) //caso potenziometro per motore avanti
*ref_out=(ref_in-512)/2;   

return *ref_out;
}  /code]
zanini marco

makalu1

trovato il baco

la funzione non va causa la riga che testa il riferimento uguale a zero e mette a true il boleano del motore in stop.

sinceramente non lho capita
zanini marco

leo72

Se ti riferisci a questo:
Code: [Select]
if (ref_out_elevator=0)
Hai sbagliato a scrivere il codice. In C/C++ il confronto di uguaglianza si fa usando 2 segni di uguale, quindi "==" e non "=". Tu fai un'operazione di assegnazione che, essendo vera, ti farà entrare nel blocco di codice definito nell'if.

lesto


trovato il baco

la funzione non va causa la riga che testa il riferimento uguale a zero e mette a true il boleano del motore in stop.

sinceramente non lho capita


l'= matematicamente ha tanti significati differenti, cosa che spesso in matematica non spiegano per bene..

in insiemistica indica l'identita': l'uguaglianza di 2 elementi o di 2 insiemi.
equivalenza, intesa come relazione insiemistica A=B
uguaglianza algebrica A=B
uguaglianza logica A=B (puo' essere vero o falso)
assegnazione A=B alla lettera A viene assegnato il valore di B
sei nuovo? non sai da dove partire? leggi qui: http://playground.arduino.cc/Italiano/Newbie

makalu1

vero! scusate ma tendo a fare casi no co altro linguaggio da plc che uso piu spesso
grazie ancora
zanini marco

Go Up