next topic »

[on:]

C'è un modo per evitare il reset di arduino  ad ogni connessione ? E uno per evitare che si resetti lo sketch di arduino quando manca alimentazione? In pratica, per la seconda domanda, chiedo se si può caricare lo sketch in ROM invece che in RAM.
Per la prima so che basta mettere un condesatore tra i pin reset e GND oppure reset e 5V.C'è anche un modo software? Qual'è il più semplice?

[Reply #1 on:]

C'è un modo per evitare il reset di arduino  ad ogni connessione ? E uno per evitare che si resetti lo sketch di arduino quando manca alimentazione?

Soluzioni permanenti:
1) cambiare firmware del micro che fa da convertitore USB/seriale:
http://arduino.cc/forum/index.php/topic,130621.0.html
oppure
2) tagliare la pista RESET-EN che c'è sulla scheda (ma poi devi risaldarla se vuoi recuperare la funzione originale)

Oppure, soluzione temporanea: infili un condensatore da 10uF nei pin RST e 5V

In pratica, per la seconda domanda, chiedo se si può caricare lo sketch in ROM invece che in RAM.

Lo sketch sta già in una memoria non volatile, la Flash.

Per la prima so che basta mettere un condesatore tra i pin reset e GND oppure reset e 5V.C'è anche un modo software? Qual'è il più semplice?

Il più semplice è il condensatore, come ti ho detto sopra. La più raffinata è quella di cambiare il firmware.

[Reply #2 on:]

a me succede che quando tolgo l'alimentazione arduino mi si resetta.Nel senso che non fa ciò che è scritto nel codice.

[Reply #3 on:]

a me succede che quando tolgo l'alimentazione arduino mi si resetta.Nel senso che non fa ciò che è scritto nel codice.

Mi pare che ovvio che si resetta, esattamente come fa il tuo pc se stacchi la 220 

[Reply #4 on:]

leo diceva che lo sketch andava in FLASH.Non si dovrebbe cancellare se va li.Quella dovrebbe essere la ROM e non la RAM

[Reply #5 on:]

leo diceva che lo sketch andava in FLASH.Non si dovrebbe cancellare se va li.Quella dovrebbe essere la ROM e non la RAM

Infatti non si cancella, però se va via l'alimentazione è più che normale che il micro resetti, figurati che c'è un apposito controllo che lo fa resettare, e lo tieni in reset, se la tensione scende sotto un certo livello.

[Reply #6 on:]

unico modo per evitare ciò e mettere una batteria giusto? Qual'è la minima tensione?

[Reply #7 on:]

unico modo per evitare ciò e mettere una batteria giusto? Qual'è la minima tensione?

Dipende anche dal clock.
Per i 16 MHz, ti conviene mantenere i 5V dell'Arduino.
Puoi scendere di un po', ma non andare sotto ai 3V perché potresti poi avere problemi a scrivere in EEPROM ( non mi ricordo la tensione minima che serve per questa operazione). Metti 3 pile AA alcaline, con 4,5V sei tranquillo.

[Reply #8 on:]

Avevo pensato a una da 9 V attaccata allo spinotto dell'Arduino.Ho pensato di realizzare tipo  sistema come le lampade d'emergenza:Quando va via la corrente che alimenta arduino si attacca la corrente della batteria.
Mi trovo in una situazione in cui arduino è montato in una fabbrica su un pc che a fine giornata di lavoro viene spento.Quindi mi serve l'antireset alla riaccensione del pc e in più qualcosa che non facci spegnere arduino e mi faccia tenere in memoria lo sketch.Come unica soluzione vedo la batteria.Sapete qualè il lasso di tempo massimo che può passare tra lo stacco dell'alimentazione di arduino e l'attivazione della corrente tramite batteria?In pratica mi occorrerebbe sapere il tempo di carica dei due condensatori che sono su arduino.

[Reply #9 on:]

Mi trovo in una situazione in cui arduino è montato in una fabbrica su un pc che a fine giornata di lavoro viene spento.

Non riesco a capire per quale motivo non dovresti resettare Arduino quando il pc a cui è collegato è spento, voglio sperare che non usi il pc solo per alimentare Arduino.
In tutti i casi per ovviare alla cosa basta che Alimenti Arduino tramite l'apposito connettore con un idoneo alimentatore stabilizzato, 9V 1 A, taglia la pista del reset, o metti il condensatore, e in questo modo Arduino non si resetta mai.

[Reply #10 on:]

unico modo per evitare ciò e mettere una batteria giusto? Qual'è la minima tensione?

I moderni PC hanno una tensione 5V standby che é presente anche a PC spento (ma alimentato dalla rete e non spento con un interuttore) e si puó selezionare se gli USB o alcuni sono alimentati da quella tensione. Cosí anche a PC spento l' arduino funziona.

Non cpisco comunque il problema del reset. Quando qualsiasi computer o microcontroller viene acceso deve partire a inizializzare il HW e far partire il SO o il programma che ha memorizzato. queto si fa sempre tramite reset. Adesso dipende come é gestito puoi anche ripredere il lavoro nel punto che c'era prima di essere spento; basta memorizzare in una memoria non volatile alcuni parametri o l' intera memoria volatile che viene ripristinata.

Ciao Uwe

[Reply #11 on:]

mi faccia tenere in memoria lo sketch.

Francesco, lo sketch è in una memoria NON volatile, ciò significa che se stacchi l'alimentazione all'Arduino il programma resta memorizzato. Non viene cancellato.
Quello che perdi sono i dati elaborati dallo sketch, che sono salvati su RAM e che spariscono non appena va via l'alimentazione o la scheda viene resettata.

Ora, se tu dici che cerchi qualcosa per evitare il reset e mantenere i dati in memoria, segui la via che ti è stata suggerita da astrobeed: prendi un alimentatore esterno da 9V e collegao al jack dell'Arduino e taglia la pista RESET-EN oppure metti il condensatore sui pin che ti ho detto (se non hai uno shield sulla scheda).
In questo modo, anche se il PC a cui è collegato viene spento, quando lo riaccendi l'Arduino non si resetterà.

[Reply #12 on:]

io intendo a livello di sketch.Non mi interessa dei dati.Il mio arduino , quando lo stacco dall'alimentazione e lo riattacco non fa nulla.Come se non ci fosse alcun sketch caricato sopra.

[Reply #13 on:]

Ribadisco il concetto:

Francesco, lo sketch è in una memoria NON volatile, ciò significa che se stacchi l'alimentazione all'Arduino il programma resta memorizzato. Non viene cancellato.

L'Arduino lo sketch non lo perde perché è stata tolta l'alimentazione. Forse lo sketch resta bloccato, e questo è un altro discorso. Se ad esempio c'è sopra uno sketch che comunica sulla seriale e questo programma parte prima che il PC a cui è connesso inizi a ricevere i dati, probabilmente si può saturare la seriale e l'Arduino resta bloccato perché il PC non può aprire la connessione verso la scheda.

Ma la mia è una supposizione, non sapendo come stai operando e con che programma.

[Reply #14 on:]

il codice con cui sto lavorando e' questo

Code:

const byte ButtonPinuno = 11;        //pin pulsante incremento
const byte ButtonPindue = A0;    //pin pulsante decremento
int CurrentStateuno;                  //variabile per lo stato uno corrente
int LastStateuno = 0;                //variabile per l'ultimo stato uno
int CurrentStatedue;                  //variabile per lo stato due corrente
int LastStatedue = 0;            //variabile per l'ultimo stato due
byte contprima = 0;          //Holds number of button presses.
const byte ButtonPintre = 3;        //pin pulsante incremento
const byte ButtonPinquattro = 4; //pin pulsante decremento
int CurrentStatetre;                  //variabile per lo stato uno corrente
int LastStatetre = 0;                //variabile per l'ultimo stato uno
int CurrentStatequattro;              //variabile per lo stato due corrente
int LastStatequattro = 0;            //variabile per l'ultimo stato due
byte contseconda = 0;          //Holds number of button presses
const byte ButtonPincinque = 5;        //pin pulsante incremento
const byte ButtonPinsei = 6; //pin pulsante decremento
int CurrentStatecinque;              //variabile per lo stato uno corrente
int LastStatecinque = 0;              //variabile per l'ultimo stato uno
int CurrentStatesei;                  //variabile per lo stato due corrente
int LastStatesei = 0;                //variabile per l'ultimo stato due
int short contterza = 0;            //Holds number of button presses
unsigned long currentTime = 0;
unsigned long loopTime = 0;
unsigned long lastTimeReed = 0;
unsigned long loopTimeReed = 0;
const byte moton = 7;
const byte motoff= 8;
const byte aumenta= 9;
const byte diminuisci= 10;

const byte sensvel = 2;
const float radius = 13.5;// tire radius (in inches)
const float circumference = TWO_PI*radius*0.0254; // (in metri)
unsigned int ms = 0;
byte reedCounter = 0; // max 255
const byte reedNumber = 1; // numero di magneti per giro

void setup(void)
{
  delay(1000);
  Serial.begin(9600);          //Begins communication with computer
  pinMode(ButtonPinuno,INPUT);    //Sets ButtonPin as input.
  pinMode(ButtonPindue,INPUT);    //Sets ButtonPin as input.
  pinMode(ButtonPintre,INPUT);    //Sets ButtonPin as input.
  pinMode(ButtonPinquattro,INPUT);    //Sets ButtonPin as input.
  pinMode(ButtonPincinque,INPUT);    //Sets ButtonPin as input.
  pinMode(ButtonPinsei,INPUT);    //Sets ButtonPin as input.
  pinMode(moton, OUTPUT);
  pinMode(motoff, OUTPUT);
  pinMode(aumenta, OUTPUT);
  pinMode(diminuisci, OUTPUT);
  pinMode(sensvel, INPUT); // sensore reed velocità
  attachInterrupt(0, Counter, RISING);
}

void Counter(void){
  reedCounter++;
}

void loop(void)
{
  CheckButton();
  CheckSerial();
  SpeedCalc();

  currentTime = millis();
  if(abs(currentTime - loopTime) >= 1000)
  {
    Serial.print(contprima);
    Serial.print(F(","));
    Serial.print(contseconda);
    Serial.print(F(","));
    Serial.print(contterza);
    Serial.print(F(","));
    Serial.print(ms);
    Serial.print(F(","));
    Serial.println(reedCounter);
    loopTime = currentTime;
  }
}

void SpeedCalc(void){
  loopTimeReed =  abs(lastTimeReed - millis()); // intervallo in millisecondi degli n rilevamenti
  if (reedCounter > 1){ // MAX >254
    int rpm = (60*reedCounter)*(1000/loopTimeReed)/reedNumber; // giri al minuto dell'asse del motore
    reedCounter = 0;
    lastTimeReed = millis();
    ms = ((rpm * circumference)/60); // velocità lineare in metri al secondo
  }
  if (loopTimeReed > 2000){
    Serial.print(F("Motore fermo?"));
  }
}

void CheckButton(void){
  CurrentStateuno = digitalRead(ButtonPinuno);         
  CurrentStatedue = digitalRead(ButtonPindue);       
  CurrentStatetre = digitalRead(ButtonPintre);         
  CurrentStatequattro = digitalRead(ButtonPinquattro);   
  CurrentStatecinque = digitalRead(ButtonPincinque); 
  CurrentStatesei = digitalRead(ButtonPinsei);
  delay(10);  // debounce                                                 

  if(CurrentStateuno != LastStateuno)
  {
    if(CurrentStateuno == HIGH)
    {
      contprima++;
    }
  }
  LastStateuno = CurrentStateuno;

  if(CurrentStatedue != LastStatedue)
  {
    if(CurrentStatedue == HIGH)
    {
      contprima--;
    }
  }
  LastStatedue = CurrentStatedue;

  if(CurrentStatetre != LastStatetre)
  {
    if(CurrentStatetre == HIGH)
    {
      contseconda++;
    }
  }
  LastStatetre = CurrentStatetre;

  if(CurrentStatequattro != LastStatequattro)
  {
    if(CurrentStatequattro == HIGH)
    {
      contseconda--;
    }
  }
  LastStatequattro = CurrentStatequattro;

  if(CurrentStatecinque != LastStatecinque)
  {
    if(CurrentStatecinque == HIGH)
    {
      contterza++;
    }
  }
  LastStatecinque = CurrentStatecinque;

  if(CurrentStatesei != LastStatesei)
  {
    if(CurrentStatesei == HIGH)
    {
      contterza--;
    }
  }
  LastStatesei = CurrentStatesei;
}

void CheckSerial(void){
  if(Serial.available() >0)
  {
    switch (Serial.read()){

    case 'A':
      digitalWrite(moton, HIGH);
      delay(1000);
      digitalWrite(moton, LOW);
      break;

    case 'B':
      digitalWrite(motoff, HIGH);
      delay(1000);
      digitalWrite(motoff, LOW);
      break;

    case 'C':
      digitalWrite(aumenta, HIGH);
      delay(1000);
      digitalWrite(aumenta, LOW);
      break;

    case 'D':
      digitalWrite(diminuisci, HIGH);
      delay(1000);
      digitalWrite(diminuisci, LOW);
      break;

    default:
      break;
    }
  }   
}

restituisce la velcoità di un motore e il valore di alcune variabili