Go Down

Topic: goto (Read 1 time) previous topic - next topic

#15
Apr 05, 2013, 12:52 pm Last Edit: Apr 11, 2013, 07:17 pm by SUBSEA Reason: 1
mi sembra più elegante il goto che un copia/incolla del codice con dei delay in mezzo per ogni carattere! :smiley-yell: comunque cosa mi consigliate di usare? degli if e degli serial.print?

erpomata

Ma che devi fare?
Ci fai vedere un pezzo di codice?
http://www.paologiammarco.it
http://www.valentinamagni.it

leo72


mi sembra più elegante il goto che un copia/incolla del cosice con dei delay in mezzo per ogni carattere!

Non ho capito che devi fare.

MauroTec



Esiste ma è bene non usarla.


Usare la GOTO in C è ammettere la propria sconfitta come programmatore  :smiley-mr-green:



Io paragono goto alla foglia di fico.

Usare il goto equivale a pulirsi il sedere con la foglia di fico. :smiley-mr-green:

Non è che viene proprio bene, ma se sei nella foresta e ti scappa, non vedo altra soluzione, tra l'altro raggiungi l'obbiettivo velocemente come veloce è il goto.

PS: Survival: Foglia di fico o altra pianta dal fogliame grande va pure bene. :P

Ciao.
AvrDudeQui front end per avrdude https://gitorious.org/avrdudequi/pages/Home

#19
Apr 05, 2013, 01:36 pm Last Edit: Apr 05, 2013, 01:38 pm by SUBSEA Reason: 1
Certo! Allora, praticamente ho scritto del cosice per ogni lettera/numero. Per esempio posto la A
Code: [Select]
{
      Serial.println(dato,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale, Data, LSBFIRST, dato);
      digitalWrite(Abilitazione, HIGH);
      dato=0b100000100;
   
      Serial.println(dato1,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale1, Data1, LSBFIRST, dato1);
      digitalWrite(Abilitazione, HIGH);
      dato1=0b10010000;
   
      Serial.println(dato2,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale2, Data2, LSBFIRST, dato2);
      digitalWrite(Abilitazione, HIGH);
      dato2=0b11010000;
   
      Serial.println(dato3,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale3, Data3, LSBFIRST, dato3);
      digitalWrite(Abilitazione, HIGH);
      dato3=0b10010000;
   
      Serial.println(dato4,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale4, Data4, LSBFIRST, dato4);
      digitalWrite(Abilitazione, HIGH);
      dato4=0b10000100;
    }

  delay(500);

poi magari devo far seguire la P, quindi:
Code: [Select]
{
    Serial.println(dato,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale, Data, LSBFIRST, dato);
    digitalWrite(Abilitazione, HIGH);
    dato=0b100000100;

    Serial.println(dato1,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale1, Data1, LSBFIRST, dato1);
    digitalWrite(Abilitazione, HIGH);
    dato1=0b10010000;
 
    Serial.println(dato2,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale2, Data2, LSBFIRST, dato2);
    digitalWrite(Abilitazione, HIGH);
    dato2=0b11010000;

    Serial.println(dato3,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale3, Data3, LSBFIRST, dato3);
    digitalWrite(Abilitazione, HIGH);
    dato3=0b10010000;
 
    Serial.println(dato4,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale4, Data4, LSBFIRST, dato4);
    digitalWrite(Abilitazione, HIGH);
    dato4=0b10000100;
  }
  delay(500);
  {
    Serial.println(dato,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale, Data, LSBFIRST, dato);
    digitalWrite(Abilitazione, HIGH);
    dato=0b00000000;
 
    Serial.println(dato1,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale1, Data1, LSBFIRST, dato1);
    digitalWrite(Abilitazione, HIGH);
    dato1=0b00000000;
 
    Serial.println(dato2,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale2, Data2, LSBFIRST, dato2);
    digitalWrite(Abilitazione, HIGH);
    dato2=0b00000000;
 
    Serial.println(dato3,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale3, Data3, LSBFIRST, dato3);
    digitalWrite(Abilitazione, HIGH);
    dato3=0b00000000;
 
    Serial.println(dato4,DEC);
    digitalWrite(Abilitazione, LOW);
    shiftOut(Seriale4, Data4, LSBFIRST, dato4);
    digitalWrite(Abilitazione, HIGH);
    dato4=0b00000000;
  }

  delay(500);

capito il problema?

erpomata

Scusa ci ho capito poco dal quel codice e magari altri più preparati di me ti aiuteranno meglio.
Io ci provo. Ma se fai una cosa del genere?

Code: [Select]

void scriviLettera(int dataPin, int clock, int value){
      Serial.println(value,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(dataPin, clock, LSBFIRST, value);
      digitalWrite(Abilitazione, HIGH);
      dato=0b100000100;  <-- questo non so a cosa serva.
}

void loop(){
scriviLettera(Seriale, Data, dato);
scriviLettera(Seriale1, Data1, dato1);
scriviLettera(Seriale2, Data2, dato2);
}


ecc...?

Bè l'ho buttato giù così come mi è venuto e soprattutto non l'ho provato.
Vedi un pò
http://www.paologiammarco.it
http://www.valentinamagni.it

ok, non ho ancora capito come usarla... Dopo che mia mamma mi ha praticamente distrutto il cuboled e averlo ripristinato, sono di nuovo sopra al software, senza capire come creare la funzione da richiamare col goto. Faccio un esempio:
Code: [Select]
void A(){
digitalWrite(13,HIGH);
}
void setup(){
pinMode(13,OUTPUT);
}
void loop(){
goto A;
}

così per voi va bene? Per l'ide no...

gpb01

#22
Apr 11, 2013, 06:05 pm Last Edit: Apr 11, 2013, 06:07 pm by gpb01 Reason: 1
Butta via quel "goto" ...

... basta che scrivi A(); e lui richiama la tua funzione void A()  ;)

Guglielmo

P.S. : Cerca di dimenticarti proprio che esiste il "goto" ... :)
Search is Your friend ... or I am Your enemy !

#23
Apr 11, 2013, 06:15 pm Last Edit: Apr 11, 2013, 07:10 pm by SUBSEA Reason: 1
Grazie gpb01!!! capito e risolto il problema! Quindi col goto stavo a complicarmi inutilmente la vita, giusto? bè, l'importante è che adesso funzioni!

gpb01

Usato come lo avevi usato, era proprio sbagliato sintatticamente ... si usa per saltare ad una "label" non per richiamare una funzione e ...

... ripeto, in ogni caso, cerca di dimenticare che esiste quell'istruzione e fa come se non ci fosse ! ;)

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

mmmmm.... purtroppo l'entusiasmo iniziale provato su un blinkè miseramente sfumato quando ho applicato il concetto allo scketch del cubo...
Faccio un esempio per la A e per la B:
Code: [Select]
int Abilitazione = 8;
int Seriale = 12;
int Data = 13;
int Seriale1 = 10;
int Data1 = 11;
int Seriale2 = 7;
int Data2 = 9;
int Seriale3 = 6;
int Data3 = 5;
int Seriale4 = 4;
int Data4 = 3;
byte dato  = 0;
byte dato1 = 0;
byte dato2 = 0;
byte dato3 = 0;
byte dato4 = 0;

void A(){
 
      Serial.println(dato,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale, Data, LSBFIRST, dato);
      digitalWrite(Abilitazione, HIGH);
      dato=0b100000100;
      Serial.println(dato1,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale1, Data1, LSBFIRST, dato1);
      digitalWrite(Abilitazione, HIGH);
      dato1=0b10010000;
      Serial.println(dato2,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale2, Data2, LSBFIRST, dato2);
      digitalWrite(Abilitazione, HIGH);
      dato2=0b11010000;
      Serial.println(dato3,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale3, Data3, LSBFIRST, dato3);
      digitalWrite(Abilitazione, HIGH);
      dato3=0b10010000;
      Serial.println(dato4,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale4, Data4, LSBFIRST, dato4);
      digitalWrite(Abilitazione, HIGH);
      dato4=0b10000100;
    }
void B(){
  {
   
      Serial.println(dato,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale, Data, LSBFIRST, dato);
      digitalWrite(Abilitazione, HIGH);
      dato=0b111111111;
      Serial.println(dato1,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale1, Data1, LSBFIRST, dato1);
      digitalWrite(Abilitazione, HIGH);
      dato1=0b10110100;
      Serial.println(dato2,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale2, Data2, LSBFIRST, dato2);
      digitalWrite(Abilitazione, HIGH);
      dato2=0b10010100;
      Serial.println(dato3,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale3, Data3, LSBFIRST, dato3);
      digitalWrite(Abilitazione, HIGH);
      dato3=0b10001100;
      Serial.println(dato4,DEC);
      digitalWrite(Abilitazione, LOW);
      shiftOut(Seriale4, Data4, LSBFIRST, dato4);
      digitalWrite(Abilitazione, HIGH);
      dato4=0b10000100;
    }
void setup()
{
  pinMode(Abilitazione, OUTPUT);
  pinMode(Data, OUTPUT);
  pinMode(Seriale, OUTPUT);
  pinMode(Data1, OUTPUT);
  pinMode(Seriale1, OUTPUT);
  pinMode(Data2, OUTPUT);
  pinMode(Seriale2, OUTPUT);
  pinMode(Data3, OUTPUT);
  pinMode(Seriale3, OUTPUT);
  pinMode(Data4, OUTPUT);
  pinMode(Seriale4, OUTPUT);
  Serial.begin(9600);
}
void loop(){
 
  A();
  delay(1000);
  B();
  delay(1000);
}

Praticamente dovrebbe alternare la A e la B ogni secondo, ma la compilazione non va abuon fine... :(

Brunello

prova a togliere qualche parentesi graffa di troppo

gpb01

... impara a leggere i messaggi di errore del compilatore e cerca di capirli ;)

Comunque ... c'è una parentesi graffa di troppo ... guarda la void B() hai messo una graffa subito dopo ed una subito sotto ... ;)

Se inoltre lasci una riga vuota tra le varie funzioni, migliori la leggibilità !

Code: [Select]

int Abilitazione = 8;
int Seriale = 12;
int Data = 13;
int Seriale1 = 10;
int Data1 = 11;
int Seriale2 = 7;
int Data2 = 9;
int Seriale3 = 6;
int Data3 = 5;
int Seriale4 = 4;
int Data4 = 3;

byte dato  = 0;
byte dato1 = 0;
byte dato2 = 0;
byte dato3 = 0;
byte dato4 = 0;

void A() {
     Serial.println(dato,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale, Data, LSBFIRST, dato);
     digitalWrite(Abilitazione, HIGH);
     dato=0b100000100;
     Serial.println(dato1,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale1, Data1, LSBFIRST, dato1);
     digitalWrite(Abilitazione, HIGH);
     dato1=0b10010000;
     Serial.println(dato2,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale2, Data2, LSBFIRST, dato2);
     digitalWrite(Abilitazione, HIGH);
     dato2=0b11010000;
     Serial.println(dato3,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale3, Data3, LSBFIRST, dato3);
     digitalWrite(Abilitazione, HIGH);
     dato3=0b10010000;
     Serial.println(dato4,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale4, Data4, LSBFIRST, dato4);
     digitalWrite(Abilitazione, HIGH);
     dato4=0b10000100;
   }

void B() {
     Serial.println(dato,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale, Data, LSBFIRST, dato);
     digitalWrite(Abilitazione, HIGH);
     dato=0b111111111;
     Serial.println(dato1,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale1, Data1, LSBFIRST, dato1);
     digitalWrite(Abilitazione, HIGH);
     dato1=0b10110100;
     Serial.println(dato2,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale2, Data2, LSBFIRST, dato2);
     digitalWrite(Abilitazione, HIGH);
     dato2=0b10010100;
     Serial.println(dato3,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale3, Data3, LSBFIRST, dato3);
     digitalWrite(Abilitazione, HIGH);
     dato3=0b10001100;
     Serial.println(dato4,DEC);
     digitalWrite(Abilitazione, LOW);
     shiftOut(Seriale4, Data4, LSBFIRST, dato4);
     digitalWrite(Abilitazione, HIGH);
     dato4=0b10000100;
   }

void setup() {
 pinMode(Abilitazione, OUTPUT);
 pinMode(Data, OUTPUT);
 pinMode(Seriale, OUTPUT);
 pinMode(Data1, OUTPUT);
 pinMode(Seriale1, OUTPUT);
 pinMode(Data2, OUTPUT);
 pinMode(Seriale2, OUTPUT);
 pinMode(Data3, OUTPUT);
 pinMode(Seriale3, OUTPUT);
 pinMode(Data4, OUTPUT);
 pinMode(Seriale4, OUTPUT);
 Serial.begin(9600);
}

void loop() {  
 A();
 delay(1000);
 B();
 delay(1000);
}


Guglielmo

Edit : M'ha preceduto Brunello ... lui la fatta breve ... :D :D :D
Search is Your friend ... or I am Your enemy !

leo72

Si chiama programmazione strutturata, nasce in risposta alla semplicità del BASIC per dare un ordine logico al flusso del programma.

In Basic potevi trovare dei codici così:
Code: [Select]
10 DIM A = 1
20 PRINT A
30 GOTO 60
40 GOTO 10
50 GOTO 20
60 A = A + 1
70 IF A = 10 THEN GOTO 90
80 GOTO 50
90 END

Il codice è funzionante ma non è logico. Se lo analizzi vedi che la riga 40 non verrà mai eseguita. E tutti quei salti sono inutili. Ovviamente è un caso estremo ma serve a farti capire perché l'uso del GOTO è osteggiato, perché il suo uso indiscriminato porta a scrivere programmi che saltano da un punto all'altro. Guarda com'è lineare scritto così:
Code: [Select]

10 DIM A = 1
20 DO
30 PRINT A
40 A = A + 1
50 WHILE A < 10

Madwriter

ed è quando trovi i goto nei programmi della più grande compagnia telefonica italiana che ti deprimi e ti chiedi che senso abbia la tua vita da programmatore  :.
"Due cose sono infinite: l'universo e la stupidità umana, ma riguardo l'universo ho ancora dei dubbi..." Albert Einstein

Go Up