Arduino come iniziare?

[v200]

Grazie Salvatore, per ora ho seguito le indicazioni dello sketch poi provo a variare i tempi.
Qualche errore di compilazione sono riuscito a farlo [:I] poi corretto con il controllo ortografico del IDE
Sono già contento di aver capito un po di più del sistema Arduino

[Edgardo_Rosatti]

A dire il vero i tempi vanno bene delay(1000) imposta 1000 millisecondi di pausa, quindi 1 secondo.

Roby, ti lancio una sfida giocosa per ottimizzare il programma:
Prova a vedere se riesci ad eliminare comandi ripetitivi

Ciao

[sal727]

A dire il vero i tempi vanno bene delay(1000) imposta 1000 millisecondi di pausa, quindi 1 secondo....

Chiedo venia [:I], ho toppato io, ho letto uno 0 in più.

[v200]

Ed mi vuoi far sudare? [:o)]
Penso che si debba agire sul voidLoop in modo da raggruppare le direttive,corretto?
Sal non preoccuparti pensa che al posto degli zeri immettevo il carattere O [:I]

[Edgardo_Rosatti]

Nessun problema Sal

Roby, se pensi di sudare adesso non sai quello che ti aspetta

No, scherzi a parte, intendevo dire che nel listato che hai scritto alcuni comandi si ripetono. Void e Loop sono corretti.
In particolare mi riferisco alle linee evidenziate sotto con il commento "// eliminare", perchè si ripetono 2 volte per ogni uscita digitale.
Il funzionamento non cambia, tuttavia si risparmia memoria che in un microcontrollore è sempre preziosa.
Su Arduino Uno la memoria flash è di 32 kilobyte (ATmega328)


// Semaforo led tre colori
int ROSSO=9;
int GIALLO =10;
int VERDE=11;
void setup() {
pinMode (ROSSO,OUTPUT);
pinMode (GIALLO,OUTPUT);
pinMode (VERDE, OUTPUT);
}
void loop() {
digitalWrite (ROSSO, HIGH );
digitalWrite ( GIALLO,LOW); // eliminare
digitalWrite ( VERDE,LOW );
delay (1000);
digitalWrite (ROSSO, LOW);
digitalWrite ( GIALLO,HIGH);
digitalWrite ( VERDE,LOW); // eliminare
delay (1000);
digitalWrite (ROSSO, LOW ); // eliminare
digitalWrite ( GIALLO,LOW);
digitalWrite ( VERDE,HIGH );
delay (1000);
}

[v200]

Ed ti ringrazio per la tua interessante e dotta spiegazione.
Per ora mi sono limitato a seguire lo sketch di esempio che trovi sui manuali e in rete, non avevo la minima idea che si potesse abbreviare il percorso delle direttive.
Come hai ben fatto notare in programmazione conta molto negli sketch complessi ( lunghi ) risparmiare byte per non sovraccaricare la memoria flash.
Credo che per ora con gli sketch basici non occorra abbreviare ma da tenere in conto per i futuri lavori più complessi.
Continuo a studiare[:I]

[Edgardo_Rosatti]

Prego Roby.

Credo che per ora con gli sketch basici non occorra abbreviare ma da tenere in conto per i futuri lavori più complessi
Tienine conto.

[v200]

OK Ed,
per ora ho cercato i caratteri < > { } # che non trovavo[:I][:I]
Trovati poi su start_accessori windows-mappa caratteri

[v200]

Andando avanti con i vari sketch educativi ne ho trovato uno interessante per un plastico accendere lentamente i led, utile per i lampioni a neon dei piazzali di stazione.
In questo caso ho utilizzato le uscite<font color="green"> ANALOGICHE </font id="green"> contrassegnate dalla tilde ( lineetta ondulata) ~.
Mentre l'uscita digitale è on/off o I/O l'uscita analogica a valori crescenti/decrescenti da 0 a 255, utili per pilotare motori e led o altro utilizzatore analogico .
Ma passo allo sketch,

// accensione/spegnimento graduale led

int pinled = 6; // uscita analogica
void setup () {
pin Mode (pin Led,OUTPUT);
}
void Loop(){
for (int i = 0; i < 255; i ++){
analog Write ( pin Led,i);
delay ( 100 )
}

//volendo anche spegnere il led lentamente,
for (int i = 255; i>= 0; i --){
analog Write ( pin Led, i );
delay ( 100 ); }
}

[sal727]

In questo link
http://www.mauroalfieri.it/elettronica/ ... ketch.html
trovi uno sketch per simulare l'alba ed il tramonto in un presepe, si può volendo inserire in un plastico, io l'ho utilizzato per il mio mini presepe aggiungendo anche il simulatore di fuoco che ho postato tempo fa, questo funziona solo con pochi led che Arduino riesce a pilotare, è evidente che se si aumenta l'assorbimento inserendo più led, va applicato un modulino con Mosfet per ogni canale

[v200]

Grazie Sal,
leggendo qui e là ho notato che utilizzano il modulo per gestire i motori per le strip led con alimentazione esterna a 12 V. Devo provare

[ClaBos]

Buongiorno a tutti. Oggi mi sono preso pure io un kit arduino uno rev. 3.
Volevo chiedere se è possibile fare una cosa del genere:comandare un servo tramite due pulsanti però poter regolare, tramite 2 potenziometri, velocità di rotazione e angolo massimo.

Non conosco arduino, è la prima volta che inizio a metterci mano.. Ho visto le sue potenzialità su internet e mi interesserebbe molto poterlo utilizzare con dei servocomandi per muovere i deviatoi del mio plastico.

Grazie a tutti

[sal727]

Arduino è una scheda dalla quale si possono ricavare numerose applicazioni, gestire un servo è uno degli esempi iniziali, l'angolazione viene dichiarata nello sketch con la sua libreria servo.h e con i pulsanti si fa muovere, per fare quello che tu chiedi devi programmare la scheda in modo che memorizzi nella sua eprom l'angolazione che gli dai e successivamente con i pulsanti muoverla, qui si va in uno stadio avanzato della programmazione, io ti consiglierei di iniziare con dei semplici esempi per capire come gestire la scheda, poi per gradi successivamente cominciare a mettere insieme le varie nozioni acquisite e fare quello che desideri, ci sono molti libri che aiutano e numerosi tutorial in rete, magari con molta pazienza trovi anche quello che ti serve già fatto e fai il classico copia incolla che abbiamo fatto tutti.

[sal727]

Dimenticavo, se ti può interessare nel sito GasTTLAb trovi un esempio di come muovere dei deviatoi con anche relativo controllo dei led sul sinotico, sia utilizzando dei relè per i motori oppure con dei servo, di quest'ultimo c'è l'esempio di un solo servo, se ne possono aggiungere altri inserendo il codice più volte, modificando il nome delle costanti in base ai pin disponibili ed alla capacità massima di memoria della scheda, utilizzando una Arduino mega se ne possono inserire di più
http://gasttlab.altervista.org/gasttlab ... n-arduino/
qui non viene usato il potenziometro per programmare l'angolazione, ma un solo pulsante per muovere il deviatoio, l'angolazione è dichiarata nel codice in base alle prove che devi effettuare per calibrare il tipo di deviatoio usato.

[ClaBos]

Grazie Salvatore per i consigli,mooolto utili.

Ho guardato anche il sito GasTTLab e in realtà quello proposto è proprio quello che volevo realizzare però non comprendo una cosa:in questa figura è rappresentato un servo solo



Se volessi collegarne 4 o 6 quali uscite e quali ingressi devo utilizzare?

Assieme ad arduino ho preso anche il suo alimentatore a 12 volt con 2 ampere di corrente..può bastare per azionare 4 o 6 micro servi tipo questi?



https://hobbyking.com/it_it/hxt900-micr ... ec-9g.html

Li uso sui miei aeromodelli piccoli e ne ho un cassetto pieno...

[sal727]

Se sono pochi servo ed usati singolarmente l'alimenmtazione di arduino potrebbe essere sufficiente bisogna valutare l'assorbimento, per il numero dei servi in quello sketch sul GasTTLab ti ho detto nel precedente messaggio come fare, vedi come esempio quello dei relè.

[ClaBos]

In teoria avrei bisogno di almeno 10 servocomandi per poter muovere tutti i deviatoi del plastico.

A questo punto potrei valutare l'idea di prendere una seconda arduino uno e metterne 5 per scheda.

Quello che non capisco dallo schema è quali sono i pin liberi da utilizzare per gli altri servocomandi e quanti servocomandi posso collegarci.Noto che nell'esempio sono in coppia i pin 8 e 9..quindi deduco che per mettere un secondo servo,ad esempio, devo utilizzare i pin 6 e 7?

[sal727]

Ai servo serve un solo pin, due pin per i led, uno per il pulsante, in tutto occorrono 4 pin per ogni deviatoio, su arduino uno sono in totale 19 pin utilzzabili, usando anche quelli analogici che numerandoli da 14 a 19 diventano digitali

[ClaBos]

Avrei trovato anche questa soluzione..senza led ,però che mi permetterebbe di gestire più servo con Arduino

Codice: Seleziona tutto

#include <Servo.h> 
 const int servoPin = 8;  // Servo pin
 const int buttonPin = 9;  // Pushbutton pin
 int buttonState = 0; 
 int directionState = 0; 
 Servo myservo; 
 int pos = 0;
 
void setup() {
   myservo.attach(8);
   pinMode(buttonPin, INPUT);
 }

 void loop(){
   buttonState = digitalRead(buttonPin);
   if (directionState == 0){
     if (buttonState == HIGH) {
       directionState = 1;
       for(pos = 0; pos < 180; pos += 1)
       {
         myservo.write(pos);  
         delay(15);  // waits 15ms to reach the position 
       }
     }

   } else if (directionState == 1) {
     if (buttonState == HIGH) {
       directionState = 0;   
       
      for (pos = 180; pos>=1; pos -=1)
       {
         myservo.write(pos);
         delay(15);
       }
     }
   }
 }

[sal727]

Se non ti interessa avere sul sinottico l'indicazione della posizione del deviatoio, risparmi i pin dei led e puoi azionare più servo con una unica scheda,

[ClaBos]

Continuando a cercare info su internet ho trovato un altro esempio.

Codice: Seleziona tutto

//////////////////////////////////////////
//
// Small Layout turnout control
// Demonstration Sketch
//
//////////////////////////////////////////

#include <Servo.h> // include the Servo library

////////////////////////////////////////
//
// Definitions
//
////////////////////////////////////////

////////////////////////////////////////
// Basic parameters; adjust for your actual setup
#define NUMBER_OF_TURNOUTS 5
#define NUMBER_OF_SHIFT_REGISTERS 3
#define STEP_DELAY 70  // servo movement step delay, in milliseconds
///////////////////////////////////////

///////////////////////////////////////
// Data Structures
///////////////////////////////////////

//////////////////////////////////////
// TURNOUT_DEF holds all configuration
// information about turnouts and panel LEDS
//////////////////////////////////////
typedef struct TURNOUT_DEF {
  uint8_t button_pin; // Digital or analog pin for the button associated with this turnout
  uint8_t servo_pin; // Digital pin for the servo associated with this turnout
  int pos_main; // servo position for the MAIN leg, in degrees
  int pos_div; // servo position for the DIVERGENT leg, in degrees
  int panel_LED_main_green; // The position(s)of panel LEDS in the shift register chain
  int panel_LED_main_red; // Example assumes a bi-color (red/green) LED for each turnout leg
  int panel_LED_div_green; // modify these elements to reflect the actual LEDS you are using
  int panel_LED_div_red;
};

/////////////////////////////////////
// TURNOUT_DATA is wrapper structure holding
// both configuration and runtime data for turnout operation
/////////////////////////////////////
typedef struct TURNOUT_DATA {
  TURNOUT_DEF data; // configuration
  bool is_moving;
  byte alignment;
  int pos_now;
  int target_pos;
  unsigned long last_move;
};

// Alignment state values
#define ALIGN_NONE 0
#define ALIGN_MAIN  1
#define ALIGN_DIVERGENT 2


// pin ids for shift register chain controlling panel LEDS
#define LATCH_PIN 7
#define CLOCK_PIN 8
#define DATA_PIN 9

//////////////////////////////////////////
//
// Global variables
//
//////////////////////////////////////////

//////////////////////////////////////////
// TURNOUT_DATA Array
// * A0, A1, etc refer to analog pins which are used for buttons in this example
// * Replace pos_main (93) and pos_div (117) with real values for each turnout
// * LEDS are identified by their output position in the shift register chain;
// the identifier is a number between 0 and (NUMBER_OF_SHIFT_REGISTERS * 8) - 1. 
// Example assumes LEDS are connected to shift register outputs sequentially 
// from the first output of first register. You can connect LEDS to any output in
// any order; just set the identifiers accordingly.
//
// Only the TURNOUT_DEF part of the TURNOUT_DATA structure has to be initialized here; 
// The remaining elements are managed internally and are initialized automatically
//////////////////////////////////////////

TURNOUT_DATA turnouts[NUMBER_OF_TURNOUTS] = {
  {{A0, 2, 93, 117, 0, 1, 2, 3}},
  {{A1, 3, 93, 117, 4, 5, 6, 7}},
  {{A2, 4, 93, 117, 8, 9, 10, 11}},
  {{A3, 5, 93, 117, 12, 13, 14, 15}},
  {{A4, 6, 93, 117, 16, 17, 18, 19}}
};

// servo objects
Servo servos[NUMBER_OF_TURNOUTS];

// array to hold shift register state bytes
byte panel_LEDS[NUMBER_OF_SHIFT_REGISTERS];

void setup() 
{
  // Setup pins for shift register chain
  pinMode(LATCH_PIN, OUTPUT);
  pinMode(CLOCK_PIN, OUTPUT);
  pinMode(DATA_PIN, OUTPUT);
    
  // initialize each turnout 
  for(int i = 0; i < NUMBER_OF_TURNOUTS; i++){
    // attach the servo
    servos[i].attach(turnouts[i].data.servo_pin);
    // set the pin mode for the button pin
    pinMode(turnouts[i].data.button_pin, INPUT);
    // test and position the turnout by moving
    // to divergent then to main positions
    servos[i].write(turnouts[i].data.pos_div);
    turnouts[i].pos_now = turnouts[i].data.pos_div;
    setTurnout(i, ALIGN_MAIN);
    }
} // end of setup

void loop() 
{ 
  // get elapsed milliseconds at loop start
  unsigned long currentMillis = millis();

  // loop through the turnouts array
  for(int i = 0; i < NUMBER_OF_TURNOUTS; i++){
    if (turnouts[i].is_moving) {
      // if sufficient time has elapsed since the last move
      if ( (currentMillis - turnouts[i].last_move) >= STEP_DELAY ) {
        // move the turnout one degree
        turnouts[i].last_move = currentMillis;
        if (turnouts[i].pos_now < turnouts[i].target_pos) { // if the new angle is higher
          servos[i].write(++turnouts[i].pos_now);
        } else {  // otherwise the new angle is equal or lower
          if (turnouts[i].pos_now != turnouts[i].target_pos) { // not already at destination
            servos[i].write(--turnouts[i].pos_now);
          }
        }
      }
      // if target position reached, stop turnout motion
      if (turnouts[i].pos_now == turnouts[i].target_pos) {
        turnouts[i].is_moving = false;
        turnouts[i].last_move = 0;
        setIndicators(i);
      }
    } else {
      // if a turnout is NOT in motion, check to see if its button is pressed
      int button_state = digitalRead(turnouts[i].data.button_pin);
      if(button_state == HIGH){
        // toggle position
        if(turnouts[i].alignment == ALIGN_MAIN){
          setTurnout(i, ALIGN_DIVERGENT);
        } else {
          setTurnout(i, ALIGN_MAIN);
        }
      }
    }
  }
}// end of main loop

////////////////////////////////////////////////////////////////
// Supporting Functions
////////////////////////////////////////////////////////////////

void setTurnout(int id, int align){
    // Set indicators to show turnout in motion
    turnouts[id].alignment = ALIGN_NONE;
    setIndicators(id);
    // Set values to trigger motion on next loop iteration
    switch(align){
        case ALIGN_MAIN:
          turnouts[id].is_moving = true;
          turnouts[id].last_move = 0;
          turnouts[id].target_pos = turnouts[id].data.pos_main;
          turnouts[id].alignment = ALIGN_MAIN;
          break;
        case ALIGN_DIVERGENT:
          turnouts[id].is_moving = true;
          turnouts[id].last_move = 0;
          turnouts[id].target_pos = turnouts[id].data.pos_div;
          turnouts[id].alignment = ALIGN_DIVERGENT;
          break;
      }
}

void setIndicators(int id){
  switch(turnouts[id].alignment){
    case ALIGN_NONE: // means the turnout is in motion and not aligned
      panelWrite(turnouts[id].data.panel_LED_main_red, HIGH);
      panelWrite(turnouts[id].data.panel_LED_main_green, LOW);
      panelWrite(turnouts[id].data.panel_LED_div_red, HIGH);
      panelWrite(turnouts[id].data.panel_LED_div_green, LOW);
      break;
    case ALIGN_MAIN:
      panelWrite(turnouts[id].data.panel_LED_div_green, LOW);
      panelWrite(turnouts[id].data.panel_LED_div_red, HIGH);
      panelWrite(turnouts[id].data.panel_LED_main_green, HIGH);
      panelWrite(turnouts[id].data.panel_LED_main_red, LOW);
      break;
    case ALIGN_DIVERGENT:
      panelWrite(turnouts[id].data.panel_LED_div_green, HIGH);
      panelWrite(turnouts[id].data.panel_LED_div_red, LOW);
      panelWrite(turnouts[id].data.panel_LED_main_green, LOW);
      panelWrite(turnouts[id].data.panel_LED_main_red, HIGH);
      break;
  }
}
/////////////////////////////////////////////////
// Shift Register Functions
/////////////////////////////////////////////////
void panelWrite(int id, byte state) {
  int reg = floor(id / 8);
  int pos = id % 8;
  bitWrite(panel_LEDS[reg], pos, state);
  panelRefresh();
}

void panelRefresh(){
  // Prepare to shift by turning off the output
  digitalWrite(LATCH_PIN, LOW);
  // shift all bits out in MSB (most significant bit first) order
  for(int i = (NUMBER_OF_SHIFT_REGISTERS - 1); i>=0; i--) {
    // shift out the bits
    shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, panel_LEDS[i]);
  }
  // turn on the output to activate
  digitalWrite(LATCH_PIN, HIGH);
}

This circuit is intended to work with the above sketch, with the turnouts variable shortened to 3 elements instead of 5:

Codice: Seleziona tutto

TURNOUT_DATA turnouts[NUMBER_OF_TURNOUTS] = {
  {{A0, 2, 93, 117, 0, 1, 2, 3}},
  {{A1, 3, 93, 117, 4, 5, 6, 7}},
  {{A2, 4, 93, 117, 8, 9, 10, 11}}
};

E qui il sito da dove ho preso informazioni

http://thenscaler.com/?p=942

[ClaBos]

Se non ti interessa avere sul sinottico l'indicazione della posizione del deviatoio, risparmi i pin dei led e puoi azionare più servo con una unica scheda,

Ipotizzando di non voler utilizzare i led(sto valutando le varie opzioni) ma solo servocomandi,come posso creare un'alimentazione separata per alimentare solo questi ultimi?

Si potrebbe vedere uno schema di collegamento per farmi un'idea?

[sal727]

Puoi utilizzare un alimentatore da 5v tipo questo
https://www.electronic.it/Alimentatore-switching-5V-3A
poi alimenti sia Arduino che i servo che vanno a 5V, Arduino ha il suo connettore di alimentazione, i servo hanno tre fili , due per l'alimentazione + e - , uno che va collegato ad Arduino, sono di colore diversi dipende dal tipo di servo che prendi, qui alcune marche

cableado-de-servos.jpg (25.02 KiB) Visto 6509 volte

quando li compri informati sulla connessione.