problema prestazioni arduino senza bootloader

ciao a tutti
Ho un problema di prestazioni sul mio arduino dopo il caricamento del progetto senza il bootloader, è un progetto che comprende l’utilizzo di varie librerie esterne per decodificare un telecomando per pilotare dei led.
Fin che ho lavorato col bootloader non ho avuto problemi il programma non aveva rallentamenti, dopo aver seguito attentamente la guida del Professor Mennitti sono riuscito a farlo girare senza bootloader ma le prestazioni sono diminuite notevolmente: la risposta alla pressione dei tasti è rallentata e anche l’aggiornamento delle uscite è lenta… come se funzionasse a 8mhz al posto di 16mhz.
All’inizio pensavo fosse un problema di fuse che lo facevano girare a 8mhz ma l’ho escluso altrimenti i timer per la decodifica del segnale proveniente dal ricevitore radio sarebbero sballati e non riceverebbe più nulla.
Così ho ricaricato il bootloader e ricaricato il progetto, ma sorpresa: le prestazioni sono rimaste pessime anche col bootloader, i timing sono rispettati al 100% ma le prestazioni del micro, se caricato con parecchi cicli e librerie, sono terribilmente inferiori!
Ho riacquistato un arduino nuovo e verificato la fluidità con la nuova scheda con esito positivo.
Ho lavorato ancora sul micro rallentato provando a ricaricare bootloader progetti con e senza bootloader ma nulla il risultato è sempre lo stesso la scheda nuova ha prestazioni molto maggiori di quella dove ho caricato il progetto senza bootloader; timing rispettati per il 16mhz ma se si fa girare un programma di appena qualche decina di kb è come se se fosse “impastato”…
credo mi sfugga qualcosa! :smiley:
grazie in anticipo per le risposte

Un chip non ha un sistema operativo che si riempie di malware e virus che ti rallentano tutto :wink:
Se il micro va piano è perché... va piano :stuck_out_tongue:

I timing tornano sempre perché se compili per 8 MHz, i timer interni vengono preimpostati per questa velocità. Quindi il Blink funziona sempre con 1 secondo anche se il micro va a 1 MHz.

Potresti fare alcune cose: copiarci la voce in boards.txt che hai usato per impostare il micro; pubblicare il codice che stai usando; dirci più precisamente come ti accorgi di questi rallentamenti.

Carissimo, posso garantirti che la presenza/assenza del bootloader non ha alcuna incidenza sulle prestazioni del micro che dipendono fondamentalmente dal clock e dal firmware. Anzi la presenza del bootloader ritarda l'avvio del firmware perché c'è la verifica sulla seriale di una eventuale presenza di dati per il caricamento di un nuovo sketch (semplificando al massimo).
Ciò che succede a te al 99% dipende proprio da un errato settaggio dei fuse o da un non corretto funzionamento del sistema di oscillatore esterno (quarzo e condensatori). Probabilmente in qualche manovra hai creato una particolare situazione "bricked" per la quale stranamente riesci a programmare il micro ma non a modificare i fuse, dando ovviamente per scontato che tu non stia commettendo errori nell'uso delle boards. Se vuoi possiamo verificare tutto ma servono molte altre info, non ultima il fatto che mi pare di capire che tu abbia caricato lo schetch senza bootoloader sul micro e poi abbia rimesso il micro su Arduino per farlo lavorare, che senso ha questa manovra, se le cose stanno così?

Leo mi ha anticipato, posto comunque scusandomi per le parti ripetute

ciao innanzitutto grazie;

la board che uso per scrivere senza bootloader è questa:

atmega.name=Atmega (w/ Arduino as ISP)
atmega.upload.protocol=stk500
atmega.upload.maximum_size=32768
atmega.upload.speed=115200
atmega.upload.using=arduino:arduinoisp
atmega.bootloader.low_fuses=0xff
atmega.bootloader.high_fuses=0xdf
atmega.bootloader.extended_fuses=0x07
atmega.bootloader.path=optiboot
atmega.bootloader.file=optiboot_atmega328.hex
atmega.bootloader.unlock_bits=0x3F
atmega.bootloader.lock_bits=0x0F
atmega.build.mcu=atmega328p
atmega.build.f_cpu=16000000L
atmega.build.core=arduino

Descrivo il progetto meglio:
Decodifico un telecomando rf per led con la libreria RCSwitch e riassegno ai valori funzioni diverse da quelle che i cinesi gli hanno dato per poterlo rendere decente:-) piloto 4 canali Rosso Verde Blu Bianco. Aggingo funzioni di memoria e il gioco è fatto.
Nonostante la mia neoficità e vergogna nel postare un listato scritto da un tornitore lo condivido nella speranza di trovare la soluzione…
Il listato ha sicuramente problemi nella scrittura di un “int” nella eprom ma ci sto lavorando, e sicuramente va snellito, ma le mie conoscenze mi portano fin qua…

Mi accorgo dei rallentamenti xchè la ricezione dei comandi è sporadica e legata a una pressiona prolungata del tasto, la versione con la board originale è reattiva al 100%
grazie del consiglio sui timing credo stia girando a 8mhz, a 1mhz credo non possa funzionare devo capire dov’è il problema.

ecco il listato, appena risolto poi pubblico anche il tutto xchè in qualche post avevo visto la richiesta di un progetto come questo…

#include <EEPROM.h>
#include <RCSwitch.h>  //libreria ricezione telecomando rf
#include <MoodLight.h> //creazione ra ga ba in funzione di hue e brightness

const int whitepin = 6;
const int redpin = 9;
const int greenpin = 10;
const int blupin = 11;

long previousMillis = 0;
long interval = 150; //ogni quanto fare la ricezione in millisecondi         
long interval2 = 250; //ogni quanto aggiornare le uscite in millisecondi

int addwhite = 1; //indirizzo memoria step bianco
int addstepc = 2; //indirizzo memoria step colore
int addhue = 3;   //indirizzo memoria hue (colore)


int wh =0;  //valore binco hold (hold e new sono la predisposizione per un fade sull'uscita)
int wa = 0; //valore bianco attuale (hold e new sono la predisposizione per un fade sull'uscita)


int value = 0; //lettura ricevitore
int   saturation = 255;       //saturazione colore
int   brightness = 0;         //luminosità bianco
int hue = 0 ;                 // valore per libreria moodlight da 0 a 359 
MoodLight ml = MoodLight();


int rh =0; //valore rosso hold (hold e new sono la predisposizione per un fade sull'uscita)
int ra =0; //valore rosso attuale (hold e new sono la predisposizione per un fade sull'uscita)

int gh =0; //valore verde hold (hold e new sono la predisposizione per un fade sull'uscita)
int ga =0; //valore verdeo attuale (hold e new sono la predisposizione per un fade sull'uscita)

int bh =0; //valore blu attuale (hold e new sono la predisposizione per un fade sull'uscita)
int ba =0; //valore blu attuale (hold e new sono la predisposizione per un fade sull'uscita)

int s = 0; //stato programma
int stepw = 0 ; //step intensità bianco da 0 a 8
int r = 0; //stato ricezione on / off
int stepc = 0 ; //step intensità colore da 0 a 8



RCSwitch mySwitch = RCSwitch();


void setup() {
  pinMode(whitepin, OUTPUT);
  pinMode(redpin, OUTPUT);
  pinMode(greenpin, OUTPUT);
  pinMode(blupin, OUTPUT);
  Serial.begin(9600);
  mySwitch.enableReceive(0);  // Receiver pin #2
  
}


//******************************************************************* 

void loop() {
  unsigned long currentMillis = millis();
  value = 0 ;

//*****************************************************************
//accensione

if ( s == 0)
  {
    stepw = 8;
    s =1;
    r =1;
  }
  
//************************************************************
// se R = 1 (ricezione attivata) esegue ogni (interval) il ciclo d'ascolto

if (r == 1)
{
  if(currentMillis - previousMillis > interval ) 
  {
   if (mySwitch.available()) 
    {
       value = mySwitch.getReceivedValue();  
       mySwitch.resetAvailable();
    } 
  }
}

//************************************************************
//on off telecomando
if (s >= 1 && value == 26245)    //on
{
      stepw = EEPROM.read(addwhite);
      stepc = EEPROM.read(addstepc);  
      hue = EEPROM.read(addhue);
      //hue = 200 ;
      
      s=2;
      ///*
      Serial.println("**********************");
      Serial.println(stepw);
      Serial.println(stepc);
      Serial.println(hue);
      Serial.println("**********************");
      //*/
}

if (s == 2 && value == 26241)    //off
{
     ///*
     Serial.println("**********************");
     Serial.println(stepw);
     Serial.println(stepc);
     Serial.println(hue);
     Serial.println("**********************");
     //*/
     EEPROM.write(addwhite, stepw);
     EEPROM.write(addstepc, stepc );
     EEPROM.write(addhue, hue ); 
     stepc = 1; 
     stepw = 1;
     s=1;    
} 

//***********************************************************
//+ - bianco
if (s==2)
{
  if ( value == 26240)   //bianco +
    {
      stepw = stepw ++;
       if (stepw > 8) 
       {
        stepw = 8 ;
       }   
    }

  if ( value == 26244) //bianco -
    {
      stepw = stepw --;
       if (stepw < 1) 
       {
        stepw = 1;
       }    
    } 
}
//**********************************************    
//+- colori
if (s==2)
{
  if ( value == 26243) //luminosità colore +
  {
    stepc = stepc ++;
     if (stepc > 8) 
     {
      stepc = 8 ;
     }   
  }

  if ( value == 26246) //luminosità colore -
  {
    stepc = stepc --;
     if (stepc < 1) 
     {
      stepc = 1;
     }    
  } 
 

//*******************************************
//impostazione colore

  if (value > 26114 && value < 26237) //valore telecomando
  {
    if (value >=26115 && value <= 26220) // correzione sfalsamento fra ghiera telecomando e libreria hue
    {
      hue = map (value , 26115 , 26220 ,  48 , 359 );
    }
    if (value >26220 && value <= 26236) // correzione sfalsamento fra ghiera telecomando e libreria hue
    {
      hue = map (value , 26221 , 26236 ,  0 , 47 );
    }
    if ( hue > 115 && hue <125 )  { hue = 120;  } // ampliato intervallo dove i colori sono puri (scarsa sensibilità telecomando)
    if ( hue > 235 && hue <245 )  { hue = 240;  } // ampliato intervallo dove i colori sono puri (scarsa sensibilità telecomando)
    if ( hue > 355  )  { hue = 0;  }              // ampliato intervallo dove i colori sono puri (scarsa sensibilità telecomando)
    if ( hue < 5  )  { hue = 0;  }                // ampliato intervallo dove i colori sono puri (scarsa sensibilità telecomando)

  }

}
//**********************************************    
//aggiornamento uscite eseguo ogni (interval2)
    







if(currentMillis - previousMillis > interval2 ) {
    previousMillis = currentMillis;
//if (wh != wa || rh != ra || gh != ga || bh != ba)
//{
            //aggiorno intensità bianco
if (stepw == 1) {wa = 0; }
if (stepw == 2) {wa = 1; }
if (stepw == 3) {wa = 5; }
if (stepw == 4) {wa = 15; }
if (stepw == 5) {wa = 30; }
if (stepw == 6) {wa = 70 ;}
if (stepw == 7) {wa = 150; }
if (stepw == 8) {wa = 255; }
            //aggiorno intensità colore
if (stepc == 1) {brightness = 0; }  
if (stepc == 2) {brightness = 1; }
if (stepc == 3) {brightness = 10; }
if (stepc == 4) {brightness = 70; }
if (stepc == 5) {brightness = 100; }
if (stepc == 6) {brightness = 180 ;}
if (stepc == 7) {brightness = 220; }
if (stepc == 8) {brightness = 255; }
            //calcolo ra ba ga in funzione di brightness e hue 
            //saturation non attiva fissa a 255
ml.setHSB(hue, saturation , brightness); 
ra =  ml.getRed();
ba =  ml.getGreen();
ga =  ml.getBlue(); 
            //assegno il nuovo valore alle variabili in uscita
            //sostituendo l' uguale secco con una funzione si può creare un fade
            //in questo caso inserire condizione in cui non si esce dal ciclo fin
            //chè il valore scritto è uguale a quello impostato
            //per velocizzare il fade e alleggerire il programma consiglio di spegnere 
            //la ricezione con r=0 fin che il valore hold è uguale a quello attuale
 wh = wa ;
 rh = ra;
 gh = ga;
 bh = ba;
            //scrivo le uscite
analogWrite(whitepin, wh); 
analogWrite(redpin, rh); 
analogWrite(greenpin, gh); 
analogWrite(blupin, bh);
}

 
   /* 
    Serial.println(ra);
    Serial.println( ga);
    Serial.println(ba);
    Serial.println("************");
    Serial.println( stepw ,(DEC) );
    Serial.print("value");
    Serial.println( value );
    Serial.print("wh");
    Serial.println( wh , (DEC) );
    Serial.print("dw");
    Serial.println( dw );
    Serial.print("wn");
    Serial.println( wn );
    Serial.println( "****************************************" );
    */

} //fine programma

passatemi l’italiano e i commenti e l’inesperienza nello scrivere il listato forse in questo istante non è nemmeno compilabile xchè ci sto lavorando e ho condiviso l’originale

il codice racchiudilo tra i tag 'code' altrimenti non si capisce nulla
quella board con che versione di IDE la stai usando? Ti anticipo che con l'iDE 1.0.x non va bene....

grazie davvero mille di tutto:
vi spiego meglio:
il micro non l'ho mai smontato dalla board quindi escludiamo quarzo condensatori ecc.. le due board sono identiche e originali.
prima di smontare il micro dalla board, stagnare ecc ho provato tramite isp a caricargli lo schetch tramite l'altra board per verificare l'assenza del ritardo all'accensione senza dover ricreare, almeno in questa fase una nuova scheda, non avendolo mai smontato e avendo letto che molto probabilmente era un problema dei fuse che vengono scritti solo al momento del caricamento del bootloader ho provato più volte a ricaricare il bootloader e ricaricare lo scketch in accoppiata al bootloader ma per qualche motivo è come se il mio micro dopo la scrittura tramite isp del solo sketch lavori a 8mhz e non più a 16.. anche ricaricandogli sopra il bootloader originale..
scusate i miei termini poco consoni ma sono un tornitore :slight_smile:

uso l'ide 022 proprio come da guida del prof. Mennitti
sistemo il codice
scusate

Pepazzo, stai rischiando la vita, il mio cognome è Menniti, con una sola "t", di solito sparo al primo colpo, tu l'hai fatta franca per due, non ce ne sarà un terzo ]:smiley:
La board va bene per l'IDE 022 ma SOLO per il caricamento degli sketch, se la usi per caricaare il bootloader NON VA BENE.

:astonished: senza parole vado a farmi un caffè e ragiono su quello che mi ha detto grazie mille!:slight_smile: le chiedo scusa

Guarda che stavo (quasi) scherzando :smiley:
Ma non sulla questine tecnica! MI spiego meglio: con quella board tu fai l'operazione di caricamento del bootloader solo per settare i fuses, ma poi quei fuse non sono compatibili con il bootloader stesso, visto che non riservano la specifica area di memoria e non settano correttamente l'indirizzo di memoria per la partenza del bootloader stesso; in sostanza una volta settati i fuses il bootloader non serve più e ti puoi mettere a caricare direttamente gli sketch via ISP.
Se vuoi ripristinare il corretto funzionamento del micro su Arduino devi semplicemente ricaricare il bootloader usando come board quella originale di Arduino UNO, quindi rimetti il micro su Arduino, lo colleghi all'USB e gli carichi lo sketch. Sei sicuro di aver agito in questo modo?
Al ritorno dal caffé io sarò a nanna, nel caso ci sentiamo domattina, ma se fai come ti ho detto vedrai che risolvi tutto correttamente. Notte

ho ragionato e provato quello che mi ha suggerito, ho in mente 2 casi:

1: micro nuovo con fuse non "paciugati":
la prima volta che ho sovrascritto il bootloader col solo sketch e il micro sempre inserito sulla scheda sarebbe dovuto funzionare alla frequenza giusta in quanto l'avevo appena finito di testare con bootloader sul medesimo micro e non ho fatto altro che caricare lo sketch tramite isp con la board che ho incollato prima. in questo caso mi viene da dire che sarebbe dovuto funzionare a 16mhz, ivece ho notato subito una scarsa risposta ai comandi; presumo che durante questa operazione abbia commesso qualche errore e già subito dopo il caricamento lavorasse a 8mhz.. (e quindi lavorasse con l'oscillatore interno e non col quarzo esterno un po' come se sui picmicro, che conosco meglio, avessi impostato "_intosh" e non "_hs")

2:micro terribilmente "paciugato"
per ripristinare il bootloader originale si ho sicuramente selezionato la board "arduino 1" e non quella per scrivere lo sketch tramite isp, ciò nonostante caricando lo sketch tramite usb presumo (vista la pastosità della risposta ai comandi) non sia andata a buon fine la scrittura corretta dei fuse della frequenza di lavoro.

A questo punto mi chiedo: come posso verificare a quale frequenza sta girando il micro? (per escludere che non mi sia sia bruciato a me qualche fuse e che stiamo lavorando nella direzione giusta per risolvere il problema);
Ordino qualche micro vergine, intanto medito...

Non riuscirò a essere online prima di martedì...
Per il momento vi ringrazio e vi aguro buona pasqua!

grazie
Ivan

Hai due Arduino UNO, usa quello buono come Programmatore, quello da testare come target.
Carica sul Prog il programma ArduinoISP (restiamo sempre con la 0022)
Collega i due Arduino via ISP
Copia la cartella "avr" che trovi all'interno dell'IDE in C:
entra in modalità DOS
posizionati su C:
scrivi sulla riga di comando:
"C:\avr\bin\avrdude.exe" -C "C:\avr\etc\avrdude.conf" -p m328p -c stk500v1 -b 19200 -P COM2 -U lfuse:r:-:h -U hfuse:r:-:h -U efuse:r:-:h
l'unico dato che devi eventualmente modificare è la porta COM, devi mettere quella a cui è collegato Arduino UNO Programmatore e NON deve superare il valore COM9, in caso contrario devi rinominare la porta di collegamento con un numero da 3 a 9.
Se va tutto bene nella maschera DOS dovresti riuscire a leggere il valore dei tre fuse del tuo micro lento, così capiamo qualcosa in più.
Buona Pasqua anche a te.

@pepazzo:

  1. i micro di fabbrica escono a 1 MHz, che sono dati dall'oscillatore interno ad 8 MHz a cui viene applicato un divisore x8.
  2. la board è errata, come ti è stato detto. la velocità di upload non va bene ed inoltre non ho capito se vuoi riservare spazio per il bootloader oppure no

buongiorno: mi sono ricavato due minuti per fare la prova e questi sono i risultati:
Michele concedimi qualche giorno per tradurre il risultato della prova, mi interessa capire…

scusa leo non ho capito:
ho sbagliato board? ho spiegato qualche post fa che board ho utilizzato e in che frangente, una volta chiarito come le avevo usate non mi sembrava mi avessero detto che erano sbagliate…
velocità sbagliata? :astonished: ho copiato e incollato dalla guida di michele e che qualche post fa mi ha detto che la board va bene…
scusa non ho capito e francamente mi sono perso con quello che mi hai detto…

devo scappare
grazie ancora e buona pasqua

Leo mi pare di aver capito, dalle risposte che mi ha dato ieri sera, che abbia fatto tutto correttamente, penso solo ad una svista, un errore che gli ha inchiodato un fuse, ecco perché voglio leggerli.

pepazzo: scusa ma intanto avevo corretto la stringa di comando, purtroppo hai testato quella sbagliata, mi spiace ma devi rifare la prova, qurel risultato non significa niente. Quando puoi metti la nuova immagine, vedrai tu stesso che ti saranno indicati chiaramente i valori dei tre fuse, confrontali con la board di Arduino UNO e vedrai se ci sono problemi o meno; comunque non ti preoccupare, siamo qui a disposizione, risolviamo la cosa e ti spiegheremo per bene ogni passaggio.

mi metto da parte :stuck_out_tongue:

leo72:

[quote author=Michele Menniti link=topic=157262.msg1178389#msg1178389 date=1364643578]
ecco perché voglio leggerli.

mi metto da parte :stuck_out_tongue:
[/quote]
non scherzare, vorresti lasciarmi solo? :disappointed_relieved:

Sai come si dice, in questi casi, no? guida.. tu :stuck_out_tongue_closed_eyes: :stuck_out_tongue_closed_eyes:

Ma la 0022 non è quella senza optiboot che è comparso nella 0023? Uno da 2Kb e l'altro da 0.5Kb?
So che forse non centra una mazza, ma era per chiedere.

PaoloP:
Ma la 0022 non è quella senza optiboot che è comparso nella 0023? Uno da 2Kb e l'altro da 0.5Kb?

L'optiboot è apparso con la UNO (2010) e se non mi ricordo male con la 0021, di sicuro no con la 0023 che è relativamente recente.