[RISOLTO] Problema di esportazione progetto su ATtiny85

Ola! come da titolo ho un problema a far funzionare un progetto su Attiny85. Si tratta di un inseguitore solare dotato di 2 servo e 4 fotoresistenze per determinare la posizione del sole.
Al momento per i test alimento l’ATtiny85 direttamente da 5v e GND di Arduino.

Premetto che con arduino il codice funziona normalmente. L’unica differenza però è che con l’Attiny85 devo usare la libreria Servo8Bit.h, mentre con arduino uso quella classica.

Quando faccio partire il tutto su ATtiny85 in pratica i servo impazziscono e si muovono in continuazione da 0 a 180 e viceversa.

ecco il codice per l’ATtiny85:

// CON L'UTILIZZO DI 2 SERVO E 4 FOTORESISTENZE
#include <Servo8Bit.h>

 
// Generale 
int valoreLuceO = 420;         //Valore di confronto (default 512)
int tolleranzaO = 40;
int valoreLuceV = 670;         //Valore di confronto (default 512)
int tolleranzaV = 40;
int pausa=1;                        //Pausa in secondi tra ogni ciclo
long tempo=0;                     //Controllo tempo di esecuzione spostamenti (per evitare che i servi rimangano sotto sforzo in caso l'inseguitore si bloccasse)
long tempoNow=0;

//Orizzontale BLU
const int sensorPinO = 3;
const int servoPinO  = 1;
int ampminO=0;    
int ampmaxO=180;
int sensorValO = 0;
int servoGradO = 90;
Servo8Bit servoO; 

//Verticale NERO
const int sensorPinV = 4;
const int servoPinV  = 0;
int ampminV=0;    
int ampmaxV=180;
int sensorValV = 0;
int servoGradV = 90;
Servo8Bit servoV;



void setup() 
{
  pinMode( sensorPinO, INPUT);
  pinMode( sensorPinV, INPUT);
  servoO.attach( servoPinO, 544, 2400);
  servoO.write( servoGradO );
  servoV.attach( servoPinV,  544, 2151);
  servoV.write( servoGradV );
  delay(500);  
}
 
void loop() 
{
  sensorValO = analogRead(sensorPinO);
  sensorValV = analogRead(sensorPinV);
  while ( sensorValO < (valoreLuceO-tolleranzaO) ||  sensorValO > (valoreLuceO+tolleranzaO) ||  sensorValV < (valoreLuceV-tolleranzaV) || sensorValV > (valoreLuceV+tolleranzaV))
  {
    sensorValO = analogRead(sensorPinO);
    sensorValV = analogRead(sensorPinV);
    controlloTempo();
    if (sensorValO < (valoreLuceO-tolleranzaO) && servoGradO > ampminO )
    {
      servoGradO++;
      servoO.write( servoGradO );
      delay(50);
    }
    if (  sensorValO > (valoreLuceO+tolleranzaO) && servoGradO < ampmaxO)
   {
     servoGradO--;
     servoO.write( servoGradO );
     delay(50);    
    }
    if (sensorValV < (valoreLuceV-tolleranzaV) && servoGradV < ampmaxV )
   {
     servoGradV++;
     servoV.write( servoGradV );
     delay(50);
    }
    if (  sensorValV > (valoreLuceV+tolleranzaV) && servoGradV > ampminV  )
   {
     servoGradV--;
     servoV.write( servoGradV );
     delay(50);    
   }  
  }
  letargo();    
}



void letargo()
{
  for (int i=0; i<pausa; i++)
  {
    delay(1000);
  }
}

void controlloTempo(){
  if (tempo == 0)
  {
    tempo = millis();
  }
  tempoNow=millis();
  if (tempoNow - tempo > 10000)
  {
    tempo=0;
    tempoNow=0;
    letargo();
  }
  delay(50);    
}

Riuscite a darmi qualche dritta?

Grazie Giacomo

PS: allego anche i progetti Fritzing, spero si capisca… :wink:

Inseguitore_solare_FINAL_attiny85.fzz (4.42 KB)

Inseguitore_solare.fzz (8.94 KB)

Ma l'attiny a che frequenza lo stai facendo lavorare?

Lavora a 8 Mhz…

I pin dove hai collegato i servi sono corretti? Non uso fritzing perciò non posso verificarlo.

//                           +-\/-+
//  Ain0       (D  5)  PB5  1|    |8   VCC
//  Ain3       (D  3)  PB3  2|    |7   PB2  (D  2)  INT0  Ain1
//  Ain2       (D  4)  PB4  3|    |6   PB1  (D  1)        pwm1
//                     GND  4|    |5   PB0  (D  0)        pwm0
//                           +----+

Un'altra cosa, nel setup non serve dichiarare i pin come input se li usi come pin analogici

Mi associo a Pelletta. Ricontrolla i pin. Ah, e se riesci a pubblicare uno schema non fatto con Fritzing (basta una immagine PNG o JPEG) sarebbe meglio almeno lo apriamo tutti. ;)

Qui trovi tutti i pinout di Arduino/ATmega/ATtiny --> http://forum.arduino.cc/index.php?topic=151646.0 :grin:

grazie per l'aiuto ragazzi! ;)

mi pare che i pin siano corretti... comunque posto i png, magari ho fatto qualche sciocchezza, sono un principiante... :P

Hai sbagliato la dichiarazione dei pin a cui hai agganciato le fotoresistenze. Se hai visto lo schema di Pelletta, i pin analogici che vuoi usare tu sono il 3 ed il 2, non il 4 e lo 0.

ho paura di non aver capito bene come leggere i pin del tiny, forse è anche colpa dell'orario... :roll_eyes:

io uso questo schema:

in pratica qui mi indica come input i pin 3-4 e come output 1-0 e sono quelli che ho dichiarato, rispettivamente per i sensori e i servo...

però ora mi sorge un dubbio, forse i numeri dello schema che seguo sono sbagliati o non indicano il numero effettivo che va dichiarato nel codice... :fearful:

mi aiutate a chiarire le idee? :)

La figura che stai linkando è identica allo schema pubblicato da Pelletta, che vedo non vuoi guardare ;) Io però faccio riferimento a quest'ultimo perché contiene diciture più complete.

Prendiamo il 3° piedino del microcontrollore. Esso si chiama PB5PB4, come vedi. Poi ha 2 distinte nomenclature: è indicato come Analog In 2 e D4. Quindi se lo vuoi usare come ingresso analogico, devi indicarlo con "2" nella funzione analogRead. Se invece lo vuoi usare come ingresso o uscita digitale, diventa "4" in una ipotetica funzone pinMode o digitalWrite.

Tu hai nel tuo codice:

const int sensorPinV = 4;
....
sensorValV = analogRead(sensorPinV);

Pensando di leggere dal pin 4 ma in realtà stai leggendo dal pin analogico 4, che non esiste come vedi dalla piedinatura.

Leo, in realtà la figura di Pelletta dice che il 3° piedino è il PB4 :D

Grazie della correzione, piccola svista ;)

Quindi devi variare da 4 a 2:
//Verticale NERO
const int sensorPinV = 4;

Però essendo i 2 servomotori indipendenti, ognuno pilotato dalla sua fotoresistenza questo errore non basta per spiegare che i 2 sermotori oscillano entrambi

Sei sicuro delle 2 comparazioni in grassetto? Nel caso di if affermativa servoGradO aumenta quindi il limite è errato, dovrebbe essere < ampmaxV.

    if (sensorValO < (valoreLuceO-tolleranzaO) && servoGradO [b]> ampminO[/b] )
    {
      servoGradO++;
      servoO.write( servoGradO );
      delay(50);
    }

accc... il grassetto non funziona all'interno del code tag

leo72: La figura che stai linkando è identica allo schema pubblicato da Pelletta, che vedo non vuoi guardare ;) Io però faccio riferimento a quest'ultimo perché contiene diciture più complete.

Prendiamo il 3° piedino del microcontrollore. Esso si chiama PB5PB4, come vedi. Poi ha 2 distinte nomenclature: è indicato come Analog In 2 e D4. Quindi se lo vuoi usare come ingresso analogico, devi indicarlo con "2" nella funzione analogRead. Se invece lo vuoi usare come ingresso o uscita digitale, diventa "4" in una ipotetica funzone pinMode o digitalWrite.

Tu hai nel tuo codice:

const int sensorPinV = 4;
....
sensorValV = analogRead(sensorPinV);

Pensando di leggere dal pin 4 ma in realtà stai leggendo dal pin analogico 4, che non esiste come vedi dalla piedinatura.

grazie mille! ora dovrei aver capito... ;)

questa notte provo e vi faccio sapere! :)

icio:
Quindi devi variare da 4 a 2:
//Verticale NERO
const int sensorPinV = 4;

Però essendo i 2 servomotori indipendenti, ognuno pilotato dalla sua fotoresistenza questo errore non basta per spiegare che i 2 sermotori oscillano entrambi

Sei sicuro delle 2 comparazioni in grassetto? Nel caso di if affermativa servoGradO aumenta quindi il limite è errato, dovrebbe essere < ampmaxV.

    if (sensorValO < (valoreLuceO-tolleranzaO) && servoGradO [b]> ampminO[/b] )

{
     servoGradO++;
     servoO.write( servoGradO );
     delay(50);
   }

eheh che occhio! 8)

effettivamente c’è un grave errore!

if (sensorValO < (valoreLuceO-tolleranzaO) && servoGradO > ampminO )
    {
      servoGradO++;
      servoO.write( servoGradO );
      delay(50);
    }
    if (  sensorValO > (valoreLuceO+tolleranzaO) && servoGradO < ampmaxO)
   {
     servoGradO--;
     servoO.write( servoGradO );
     delay(50);    
    }

dovrei modificarlo così se non sbaglio…

if (sensorValO < (valoreLuceO-tolleranzaO) && servoGradO < ampmaxO )
    {
      servoGradO++;
      servoO.write( servoGradO );
      delay(50);
    }
    if (  sensorValO > (valoreLuceO+tolleranzaO) && servoGradO > ampminO)
   {
     servoGradO--;
     servoO.write( servoGradO );
     delay(50);    
    }

giusto?

niente da fare ragazzi… =(

al momento con questo codice:

// CON L'UTILIZZO DI 2 SERVO E 4 FOTORESISTENZE
#include <Servo8Bit.h>

 
// Generale 
int valoreLuceO = 420;         //Valore di confronto (default 512)
int tolleranzaO = 40;
int valoreLuceV = 670;         //Valore di confronto (default 512)
int tolleranzaV = 40;
int pausa=1;                        //Pausa in secondi tra ogni ciclo
long tempo=0;                     //Controllo tempo di esecuzione spostamenti (per evitare che i servi rimangano sotto sforzo in caso l'inseguitore si bloccasse)
long tempoNow=0;

//Orizzontale BLU
const int sensorPinO = 3;
const int servoPinO  = 1;
int ampminO=0;    
int ampmaxO=180;
int sensorValO = 0;
int servoGradO = 90;
Servo8Bit servoO; 

//Verticale NERO
const int sensorPinV = 2;
const int servoPinV  = 0;
int ampminV=0;    
int ampmaxV=180;
int sensorValV = 0;
int servoGradV = 90;
Servo8Bit servoV;



void setup() 
{
  pinMode( sensorPinO, INPUT);
  pinMode( sensorPinV, INPUT);
  servoO.attach( servoPinO, 544, 2400);
  servoO.write( servoGradO );
  servoV.attach( servoPinV,  544, 2151);
  servoV.write( servoGradV );
  delay(500);  
}
 
void loop() 
{
  sensorValO = analogRead(sensorPinO);
  sensorValV = analogRead(sensorPinV);
  while ( sensorValO < (valoreLuceO-tolleranzaO) 
          || sensorValO > (valoreLuceO+tolleranzaO) 
          ||  sensorValV < (valoreLuceV-tolleranzaV) 
          || sensorValV > (valoreLuceV+tolleranzaV))
  {
    sensorValO = analogRead(sensorPinO);
    sensorValV = analogRead(sensorPinV);
    if (sensorValO < (valoreLuceO-tolleranzaO) && servoGradO < ampmaxO )
    {
      servoGradO++;
      servoO.write( servoGradO );
      delay(50);
    }
    if (  sensorValO > (valoreLuceO+tolleranzaO) && servoGradO > ampminO)
   {
     servoGradO--;
     servoO.write( servoGradO );
     delay(50);    
    }
    if (sensorValV < (valoreLuceV-tolleranzaV) && servoGradV < ampmaxV )
   {
     servoGradV++;
     servoV.write( servoGradV );
     delay(50);
    }
    if (  sensorValV > (valoreLuceV+tolleranzaV) && servoGradV > ampminV  )
   {
     servoGradV--;
     servoV.write( servoGradV );
     delay(50);    
   }
   controlloTempo();  
  }
  letargo();    
}



void letargo()
{
  for (int i=0; i<pausa; i++)
  {
    delay(1000);
  }
}

void controlloTempo(){
  if (tempo == 0)
  {
    tempo = millis();
  }
  tempoNow=millis();
  if (tempoNow - tempo > 10000)
  {
    tempo=0;
    tempoNow=0;
    letargo();
  }
  delay(50);    
}

mi da il solito errore: il servoO (orizzontale) mi fa 0-180 180-0 di continuo…

prima però ho tralasciato una cosa; quando vado a caricare lo sketch sul tiny mi viene fuori questo errore:

avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85
avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85

potrebbe essere influente? :cold_sweat:

Quegli errori sono ininfluenti. Sono solo un paio di dichiarazioni di PAGEL e BS2, che sono costanti che ti mancano nel file avrdude.conf, ma che non danno noia alla programmazione del chip.

Fai una prova stupida: inverti i collegamenti mettendo il servo 0 ai pin del servo 1 e viceversa.

leo72: Quegli errori sono ininfluenti. Sono solo un paio di dichiarazioni di PAGEL e BS2, che sono costanti che ti mancano nel file avrdude.conf, ma che non danno noia alla programmazione del chip.

Fai una prova stupida: inverti i collegamenti mettendo il servo 0 ai pin del servo 1 e viceversa.

in questo modo si muove all'impazzata il servoV (verticale) ma ho notato che in reatà non fa da 0-180 180-0 ma si muove proprio senza un senso logito, tipo ad occhio fa 0-130-60-180... immagino lo facesse anche l'orizzontale ma essendo interno non riuscivo a vederlo bene...

ormai ho perso la speranza... mi sa che mi tocca sprecare un arduino per fare sto progettino... :~

PS: mi viene da pensare.. non è che potrebbe essere l'alimentazione? oppure la libreria servo 8 bit?

Ma hai provato ad eliminare la componente "ADC", quindi il sensore luce (mi pare...), e a pilotare direttamente i soli servi, per vedere se rispondono bene?