Arduino N° 65 - Rotore azimutale a controllo digitale diretto - da Radiorama

< Arduino N° 64

Achille De Santis

> Arduino N°  66

Fig. 1: Assemblaggio generale del circuito di prova del firmware.

Rotore azimutale a controllo digitale diretto.

Movimentazione di un motore "a passo" per applicazione come rotore azimutale a 360 gradi.
Un potenziometro lineare (meglio se multigiri) rileva la posizione da impostare.
Inserire un condensatore da 47uF/16VL elettrolitico ai capi del potenziometro (in parallelo sull'alimentazione).
Il funzionamento è molto preciso;  si potrebbe lasciare sempre inserito il comando di consenso ma questo non permetterebbe di leggere e predisporre con precisione l'angolo impostato.
Operando la selezione della posizione angolare viene visualizzato il valore di set-point.
Premendo, poi, il pulsante di consenso (start), fino all'accensione del LED, si avvia la movimentazione.
Il LED resta acceso per tutta la durata della movimentazione del motore ed indica la ricerca e l'assetto sulla posizione di set-point, precedentemente impostata.
Un display LCD 16X2 visualizza i valori impostati ed i relativi movimenti.
Con questi parametri si ottiene una rotazione completa in circa 90 secondi, valore ritenuto idoneo per la movimentazione assiale di antenne direttive.

In figura 1) viene mostrato lo schema generale del circuito, dove manca soltanto il motore passo-passo ed il modulo di potenza per il suo pilotaggio (L298).

Fig: 2: Control box all'accensione;

In fig. 2) è visibile il dispositivo completo e funzionante, ancora assemblato su breadboard.

Nella versione finale, il controllore programmabile è stato sostituito dal più semplice e meno costoso ATmega168, con le stesse caratteristiche di funzionamento.

Il display è il classico ed economico LCD 16X2 (2 righe x 16 colonne) nella versione senza I2C, compatibile con altri moduli gestiti da integrato Itachi HD44780; volendo, il display può essere sostituito con altro fornito di I2C, cablando opportunamente.

Fig. 3: sequenza delle fasi operative: preselezione dell'angolo,
consenso al movimento, visualizzazione del raggiunto set-point;

Il potenziometro a sinistra (v. fig. 2) regola la luminosità del display; l'altro, quello a destra in foto, regola la posizione angolare di azimuth prescelto, a sua volta segnalata sul display.
In questo modo è possibile operare una regolazione fine prima di attivare la movimentazione con il pulsante di consenso.

Il pulsante gestisce il consenso al movimento, che viene confermato sia dall'accensione del LED di segnalazione che dall'indicazione in testo, visibile sul display.

A fine movimento, sul display viene visualizzato il valore finale raggiunto.

Con i parametri inseriti, la rotazione completa viene effettuata in circa 90 secondi, valore ritenuto ottimale per movimentazione azimutale di antenne.
Nella foto animata di figura 3) viene visualizzata la sequenza delle operazioni e delle relative schermate sul display.


Per gli interessati, è disponibile il microcontrollore già programmato e facilmente integrabile in un sistema di gestione di un rotore azimutale con motore a passo.

by Achille De Santis - V4 del 20-06-2020 - tecnatronATgmail.com

https://www.air-radio.it/index.php/2020/08/02/radiorama-numero-106/?fbclid=IwAR3TD37HLZvQ0RkHYW6_tP7o2tZ32nV-f4rjLJlzBR1EcdgZFfdcenVgcAI

Simulazione: 


Argomenti correlati:

Arduino N° 14 - Control Box per Rotore azimutale

Arduino N° 46 - Control box per Rotore Azimutale Economico

Control box per rotore azimutale economico.

Arduino N°  59 - Pilotaggio Stepper Motor

> Arduino N°  66

Arduino N° 60 - Stepper Position

< Arduino N°  59

Achille De Santis

> Arduino N°  61

Questo programma di esempio ci permette di familiarizzarci  con l'uso di un motore stepper.
I motori stepper si possono recuperare agevolmente da una stampante fuori uso.



/*
 Stepper Motor Control -
 This program drives a unipolar or bipolar stepper motor.
 The motor is attached to digital pins 8,9,10,11 of the Arduino.
 The motor should revolve in one direction, then in the other direction.
 Modified 24-06-2020 by Achille De Santis
*/

#include <Stepper.h>

const int stepsPerRevolution = 200;      // number of steps per revolution for your motor

#define P1 8
#define P2 9
#define P3 10
#define P4 11

Stepper myStepper(stepsPerRevolution, P1, P2, P3, P4);    // initialize the stepper library on pins 8 through 11:

void avanti(int p) { myStepper.step(p); }       // step in one direction:
void indietro(int p) { myStepper.step(-p); }   // step in the other direction:

void setup()
  { 
    myStepper.setSpeed(60);    // set the speed at 60 rpm 
    Serial.begin(9600);             // initialize the serial port
  }

void loop()
  {
    Serial.println("clockwise");
    avanti(1);                           //  one step in one direction
    delay(500);

    Serial.println("counterclockwise");
    indietro(1);                       //  one step in the other direction
    delay(500);
  }



Simulazione: 


Argomenti correlati:  Arduino N° 59 - Pilotaggio Stepper Motor

> Arduino N°  61

Arduino N° 59 - Pilotaggio Stepper Motor

< Arduino N° 58

Achille De Santis

> Arduino N°  60

Pilotaggio di un motore "a passo" (detto anche "passo-passo" o "stepper motor") attraverso un sensore di posizione.

Un potenziometro, comandato esternamente, segnala la posizione del cursore ad un ingresso analogico. La scheda Arduino, comandata da questo sketch, fa tutto il resto.

Lo spostamento angolare del motore è relativo a quello operato sulla manopola del potenziometro.

Importante è la determinazione del valore iniziale di posizione del motore.

Per il pilotaggio del motore a passo occorre una interfaccia che nel nostro caso può essere rappresentata dal modulo di pilotaggio motori con L298. Il modulo in questione è in grado di pilotare due motori in continua o un motore passo-passo.   

Nel caso di alimentazione "esterna" del modulo L298 è necessario predisporre il relativo ponticello (jumper) in modo opportuno.

/* ------------------------------ Inizio programma ---------------------------------------------------
 * Stepper Motor Knob
 * A stepper motor follows the turns of a potentiometer
 * (or other sensor) on analog input 0.
 *
 * http://www.arduino.cc/en/Reference/Stepper 
 * This example code is in the public domain.
 * Modified by Achille De Santis - 13-06-2020
 */

#include <Stepper.h>
#define STEPS 200         // dai "dati di targa" del motore; in questo caso: 1.8 DEG/step.
// questo parametro determina la "precisione" della movimentazione, cioè l'angolo di un passo.
                          
// ---------- I/O ---------------------------------
#define P1    7     // abilitazione alla partenza
#define POT   0     // A0  ingresso analogico, collegato al potenziometro di posizione
#define A     8
#define B     9
#define C     10
#define D     11
// ------------------------------------------------

Stepper stepper(STEPS,A,B,C,D); // presenta una istanza della classe stepper, specificando  
                                // il numero di passi del motore ed i piedini ad esso collegati.

bool m;                 // variabile di stato, consenso alla partenza del motore (0)
const int vel=30;       // predispone la velocità del motore a 30 giri/min

int previous;           // valore precedente di lettura dall'ingresso analogico.
int val;                // valore analogico

void intestazione()
{ Serial.println(" ---------------------------------------------- ");
  Serial.println(" - Tecnatron - ing. Achille De Santis         - ");
  Serial.println(" - Stepper MotorKnob                          - "); 
  Serial.println(" -     V. 3.1 del 25-06-2020                  - "); 
  Serial.println(" ---------------------------------------------- ");
}


void setup() 
  {
    Serial.begin(9600);         // setto la velocità di comunicazione
    intestazione();             // intestazione, inviata alla seriale
    
    pinMode(P1, INPUT_PULLUP);
    stepper.setSpeed(vel);     // stabilisce la velocità del motore
    val = analogRead(POT);     // legge inizialmente il sensore
    previous = val;            // e stabilisce la posizione iniziale.
  }

void loop() 
  {
    val = analogRead(POT);          // legge il sensore 
    m = digitalRead(P1);            // legge il valore di abilitazione
    if (m==0)
    { 
      stepper.step(val - previous); // esegue i passi da fare, positivi o negativi. 
      previous = val;               // aggiorna il valore alla posizione attuale.
      Serial.print("valore attuale: ");   Serial.println(val); // stampa la posizione attuale
    }
  }
    // -------------------- Fine programma --------------------------------------------------------



Simulazione: 

Argomenti correlati:  Arduino N° 57 - Controllo Motore passo-passo - esempio

> Arduino N°  60

Arduino N° 57 - Controllo Motore passo-passo - esempio

< Arduino N° 56

Achille De Santis

> Arduino N° 58

Esempio di pilotaggio di un motore a passo.
Il motore effettua una rotazione completa avanti/indietro.
Nell'esempio viene ipotizzato un motore con 200 passi/giro.


// ----------------------- Inizio programma -----------------------------------------------------
/* Stepper Motor Control - one revolution
 * This program drives a unipolar or bipolar stepper motor. 
 * The motor is attached to digital pins 8,9,10,11 of the Arduino. 
 * The motor should revolve one revolution in one direction, 
 * then one revolution in the other  direction. 
 * Created 11 Mar. 2007 
 * Modified 30 Nov. 2009 by Tom Igoe 
 * Modified 1 june 2020 by Achille De Santis
*/

#include <Stepper.h>

const int stepsPerRevolution = 200;   // change this to fit the number of steps per revolution
                                      // for your motor
// -------- I/O ----------------------------------------
#define P1 8
#define P2 9
#define P3 10
#define P4 11
// ------------------------------------------------------
Stepper myStepper(stepsPerRevolution, P1, P2, P3, P4);  // initialize the stepper library on pins 8 through 11:

void avanti()    {  myStepper.step(stepsPerRevolution);  }  // step one revolution in one direction
void indietro()  {  myStepper.step(-stepsPerRevolution); }  // step one revolution in the other direction

void setup() 
  {    
    myStepper.setSpeed(60);   // set the speed at 60 rpm    
    Serial.begin(9600);       // initialize the serial port
  }

void loop() 
  {
    // step one revolution  in one direction:
    Serial.println("clockwise");
    avanti();
    delay(500);

    // step one revolution in the other direction:
    Serial.println("counterclockwise");
    indietro();
    delay(500);
  }
// --------------------- Fine programma ----------------------------------------------  


Simulazione: 

Argomenti correlati:

> Arduino N° 58

Arduino N° 53 - Modulo bluetooth 9 CH + 3 Servo

< Arduino N°  52

Achille De Santis

> Arduino N°  54

Foto 1: Il modulo bluetooth, su shield, e scheda Arduino;

Programma per la gestione con bluetooth di 9 canali digitali (ON/OFF) e di 3 canali per il comando di servomotori.

Le uscite digitali possono essere interfacciate con un modulo relais ad 8+1 canali, per il comando di altrettanti attuatori.

I tre canali "servo" possono comandare direttamente tre piccoli servomotori del tipo SG90 o similari, per un controllo a tre assi.

1. Per il funzionamento con telefono Android occorre predisporre un modulo bluetooth ricevitore (HC06 o HC05) ed una opportuna APP sul telefono.
2. Per il funzionamento con telefono IoS è consigliabile l'uso di un modulo bluetooth BLE 4.0 

Le uscite servo sono predisposte per effettuare una rotazione lenta di 90 gradi (in circa 10 secondi).

Foto 2: collaudo del comando servomotore;

In questo caso, dopo le prove operate su Arduino UNO, ho utilizzato una scheda Arduino Pro-Mini, sulla quale ho caricato lo sketch, una volta per tutte. 

Si tratta, quindi, di un modulo che può essere finalizzato ad applicazioni con un massimo di 9 canali di comando digitale e 3 canali di comando per servomotori. 

Le applicazioni possono essere numerose.

Per applicazioni a bassa potenza, sui canali "digitali" basta un semplice modulo relais.
Per i canali servo vale lo stesso principio ma con uscita "proporzionale", interfacciata con transistori.

Per applicazioni a tensioni diverse dai 5 volt della scheda Arduino, i "contatti puri" dei relais offrono la possibilità di separazione galvanica e di interfacciamento con tensioni continue o alternate, più o meno alte.

Al fine di soddisfare le richieste di alcuni lettori ho reso disponibile la scheda di controllo Pro-mini già programmata con firmware. Basta collegare la scheda, l'interfaccia bluetooth e l'interfaccia Relais per essere operativi. 

Naturalmente, per comandare da telefono occorre una opportuna APP, facilmente scaricabile.

Nota importante: 

In ogni caso, fino a 48 volt state lavorando con "tensioni di sicurezza". Oltre questo valore è necessario adottare tutte le ulteriori misure di sicurezza che le Norme richiedono.

---------------------------------------------------------------------------------------

Simulazione: 

Argomenti correlati:

Arduino N° 41 - Bluetooth BLE 4.0 per IPhone

Arduino N° 29 - Selettore bluetooth, 2 canali

Arduino N° 11 -  Movimento servomotore

Arduino N° 50 - Modulo di prova per 6 uscite digitali

tecnatronATgmail.com

> Arduino N°  54

Arduino N° 50 - Modulo di prova per 6 uscite digitali

< Segue da Arduino N°  49

prof. Achille De Santis

> Arduino N°  51

Fig. 1: il modulo, assemblato su  protoboard.

Questo modulo universale di prova vi permetterà di simulare e controllare rapidamente sei uscite digitali (da D8 a D13), senza dover ogni volta predisporvi dei LED.

L'assorbimento dei LED è di circa 7,4 mA l'uno, ampiamente al di sotto della corrente massima sia della singola uscita che della corrente totale.

Il collegamento a pettine consente una rapida inserzione sul connettore di Arduino relativo alle uscite D8-D13, massa compresa; sono previsti 8 contatti, per comodità di inserzione, ma ne vengono utilizzati soltanto sette; il primo contatto a destra (Vref) è, comunque, predisposto.

Come in figura 1, la piccola breadboard resta libera per gestire le altre parti circuitali.

L'assemblaggio dei componenti è stato eseguito sul lato rame, per un facile inserimento della striscia di contatti e una agevole visualizzazione dei LED.

Volendo, è anche possibile eseguire il lavoro per un montaggio in verticale, con un connettore a pettine, a 90°; in questo caso il montaggio dei componenti si eseguirà sulla faccia isolante.

 

Componenti:

6 x resistori 470 Ohm;

6 x diodi LED rosso, micro

basetta protoboard passo 2.54 mm

connettore a pettine, maschio, 8 contatti passo 2.54 mm.

Conservate i reofori: vi fanno comodo per creare le poche piste necessarie! 

Buon lavoro a tutti!

Argomenti correlati:

• Semaforo singolo a tre stati
• Semaforo doppio a tre stati

> Arduino N°  51

Arduino N° 46 - Control box per Rotore Azimutale Economico

< Segue da Arduino N° 45

Achille De Santis

> Arduino N° 47

Parte seconda

La versione V.9.2 del Firmware prevede l'inserimento di un semplice sensore a contatto reed sulla campana del rotore. In questo modo è possibile calibrare il rotore sempre nella posizione di riferimento, operando come segue.

Manuale d’uso

            Questo control-box è adatto a realizzare un piccolo rotore per antenne o a sostituire la parte di pilotaggio di alcuni rotori economici che, pur funzionando, non hanno quelle caratteristiche di stabilità e di precisione che si richiede ad un rotore di antenna, seppure piccolo e per antenne leggere.

Procedura di calibrazione

All’occorrenza, la calibrazione è molto semplice:

·         Si azzera il rotore sulla posizione di riferimento (nord);

·         Si controlla lo zero con l’accensione della spia;

·         La posizione del potenziometro ci suggerisce, nel caso, il disallineamento;

·        Si posiziona sullo zero il potenziometro di set-point (senza start!) e si resetta il control-box, in modo da far riconoscere al sistema la posizione di riferimento.

·         Fatto! Il rotore è allineato e calibrato.

            Ricordate! Una volta spento, il control box perde la memoria della posizione iniziale ma la riconosce all’accensione successiva quindi, assicuratevi che il potenziometro resti nella stessa posizione. Per sicurezza, spegnete sempre con il potenziometro nella posizione di zero centrale (riferimento sicuro); in questo modo avrete sempre un riferimento preciso per l’accensione e non vi saranno problemi di allineamento. Nel caso di piccoli ‘trimming’ che si dovessero rendere necessari dopo brevi movimentazioni ripetute, riferitevi alla procedura di calibrazione.

La stessa cosa potrebbe essere fatta nel caso aveste un segnale radio di riferimento, con azimuth noto.

Simulazione:


Argomenti correlati:

Control box per rotore azimutale economico.

Arduino N° 14 - Control Box per Rotore azimutale

> Arduino N° 47

Arduino N° 42 - Selettore ad infrarosso - 8 canali

< Segue da Arduino N°  41

Achille De Santis

> Arduino N° 43

Questo circuito realizza un Selettore ad 8 canali, comandabile con un piccolo telecomando ad infrarosso.

Il selettore commuta una uscita per volta, a livello alto. La selezione iniziale è sul canale 1 ma è possibile cambiarla da software. Ancora meglio, basta predisporre l'attuatore prioritario sul canale 1 di uscita, senza modifiche al firmware.

Andate alla simulazione per avere un'idea più precisa del suo funzionamento.

Gli otto LED di uscita (rossi) segnalano il canale prescelto.
Un altro LED (arancione), connesso ad una linea di servizio (DCD), segnala l'arrivo del comando dal trasmettitore ad infrarosso.


Nel caso fosse necessario cambiare i codici sul ricevitore, agire come segue;

Fig. 1: Telecomando e modulo Arduino Nano;

Procedura:

• si apre il monitor seriale su Arduino 
• da telecomando, si invia un comando per volta, premendo i tasti da 1 a 8;
•  si copia il codice ricevuto a monitor, 
• si ripete il comando, per conferma del codice inviato;
• si incolla il codice sulla riga corrispondente, nelle opzioni "case" del firmware.
• si ripete la procedura per gli 8 canali;
• si verifica che la procedura sia andata a buon fine: se tutto è a posto, ad ogni comando si accenderà un solo LED  per volta, spegnendo il precedente. 

Una tabella dei codici in uso su molti telecomandi è disponibile all'indirizzo:

Stazione Radio - Telecomandi ad infrarosso

buon lavoro!

Simulazione: 

Selettore ad infrarosso - 8 canali

Argomenti correlati:

Arduino N° 15 - Prova telecomandi ad infrarosso e rivelatore di codici
Ricevitore Infrarosso - 8 canali ON/OFF array
Telecomando ad Infrarosso_verifica codici
Stazione Radio - Telecomandi ad infrarosso
Arduino N° 15 - Prova telecomandi ad infrarosso e rivelatore di codici
Arduino N° 50 - Modulo di prova per 6 uscite digitali

> Arduino N° 43

Arduino N° 40 - Ricevitore ad Infrarosso per attuatore ad 8 canali ON/OFF

< Segue da Arduino N°  39

Achille De Santis

> Arduino N° 41

In questo numero vi presento un comodo ricevitore da abbinare ad un telecomando ad infrarosso per l'attivazione digitale, ON/OFF, di 8 uscite che possono, a loro volta, essere interfacciate con gli attuatori per mezzo di circuiti di pilotaggio a transistori o a relais, a seconda delle esigenze applicative.


La logica di comando è, per ora, collegata ad 8 diodi LED opportunamente polarizzati, per una facile dimostrazione del funzionamento. Una uscita aggiuntiva provvede a visualizzare un impulso di rivelazione, per confermare la ricezione della "trama" proveniente dal piccolo telecomando ad infrarossi.
Naturalmente, non tutti i pulsanti del telecomando sono stati utilizzati, quindi, accertatevi di aver premuto i soli pulsanti da 1 a 8; gli altri non avranno effetto, sebbene segnalati dalla spia di ricezione.


Se avete un telecomando diverso dovrete ricavarne inizialmente i codici dei pulsanti corrispondenti alle cifre, da 1 a 8, e poi inserirli al posto di quelli preesistenti nel codice da me fornito, senza cambiare altro.

Niente paura! Ho già pubblicato qualcosa al riguardo, all'indirizzo che trovate in fondo, negli argomenti correlati.
La simulazione da me preparata vi darà un'idea sul funzionamento del circuito.

Simulazione:

Ricevitore ad Infrarosso_8_canali ON/OFF
Ricevitore ad Infrarosso con driver a BJT

Argomenti correlati:

Arduino N° 15 - Prova telecomandi ad infrarosso e rivelatore di codici
Telecomandi ad infrarosso - Codici
Collegamento audio ad infrarossi
Arduino N° 50 - Modulo di prova per 6 uscite digitali


> Arduino N° 41

Control box per rotore azimutale economico.

L'idea di base era quella di ricostruire un control-box di un piccolo rotore per antenne leggere (VHF/UHF).
Ideato il programma, editato lo sketch, "limato" qualche bit, il dispositivo funzione bene.
A breve, aggiornamento sulla operatività.
Il rotore sarà anche economico ma funziona molto bene. Precisione di +- 1 grado.

E' stato aggiunto un pulsante di start, per effettuare la preselezione senza far partire immediatamente il motore. In questo modo si evitano incertezze dovute ad un trimming della posizione angolare.
Il pulsante si può escludere e così si abilita la partenza automatica.

Visto che per questi rotori non esiste il sensore di posizione ma tutto è demandato al 'sincronismo' proveniente dalla rete di alimentazione, ho escluso tutta la parte elettromeccanica ed ho sviluppato un SW per microcontrollore che potesse gestire la movimentazione con una "base tempi" corrispondente al periodo della rete elettrica.
Il FW, adattabile a molti motoriduttori, prevede l'immissione, una volta per tutte, del tempo necessario ad una corsa completa del motore, da 0 a 360 gradi di rotazione dell'asse.
 

Fig. 1: Schema di collegamento della scheda Arduino

Fig. 2: aggiunta del pulsante di "START", per abilitare il movimento dopo la preselezione.

Argomenti correlati: 

Arduino N° 14 - Control Box per Rotore azimutale 
Arduino N° 46 - Control Box per Rotore azimutale - parte seconda