Arduino N° 29 - Selettore bluetooth, 2 canali

< Arduino N° 28

Achille De Santis

> Arduino N° 30

Foto 1: a sinistra Arduino Pro-Mini,
a destra modulo bluetooth;

Selettore  bluetooth, 2 canali, 1 via / 2 posizioni; si può utilizzare in vari ambiti, dove necessiti un collegamento  senza fili a 1 via/2 posizioni, per comando di 2 canali indipendenti.

Può servire una interfaccia a 2 relé, reperibile tra quelle in uso con Arduino, oppure se ne può assemblare una "ad hoc". Il relé permette di disporre di un "contatto puro", in uscita, che può essere collegato in vario modo e con tensioni diverse sul carico.

Il comando può essere impartito attraverso idonea APP da installare su telefono(Android o IoS).

Per l'uso con telefoni Android è idoneo un modulo bluetooth HC05 o HC06 ("slave" o "master/slave").

Per il funzionamento con telefoni IoS consiglio di utilizzare un modulo bluetooth BLE 4.0.

In fig. 1 potete vedere il montaggio di prova, su breadboard, dei due moduli, sufficienti per un idoneo assemblaggio minimale. Dopo le valutazioni con una scheda Arduino UNO o Nano, per un montaggio definitivo ho preferito programmare un modulo Pro-mini (a sinistra sulla foto). 

Il modulo bluetooth in foto è un BLE 4.0 compatibile con IoS ma può essere sostituito con un HC05 o HC06 compatibile con Android; attenzione al verso della piedinatura.  

/* ----------------------------- Inizio Programma -----------------------------------
  Programma di Achille De Santis    22-03-2018 V.2.2
  Selettore "1 via 2 posizioni" a relé tramite collegamento Bluetooth
  Piedini usati per seriale bluetooth:  TX=>0 RX=>1
  Linee di uscita:         D2 = canale 1,    D3 = canale 2
  Commuta 2 canali di uscita, ognuno su due posizioni.

  Comandi:
    A = seleziona uscita A
    B = seleziona uscita B
    P = inserisce la linea A1
    p = inserisce la linea B1
    c = comandi
// -------------------------------------------------------------------------------------------
*/

#define i     2       // uscita comando relay
#define p3  3      //  uscita

char dato;

void setup()
{
     pinMode(i, OUTPUT);               // comando switch 1
     pinMode(p3, OUTPUT);            // comando switch 2
     Serial.begin(9600);             // velocità di comunicazione
     titolo();
     accendi(i);   delay(500);  spegni(i);  // controllo iniziale
     accendiPRE(p3);  delay(500);  spegniPRE(p3);
}

void titolo()
{
  Serial.println(" -          Tecnatron Creation                    - ");
  Serial.println(" -          tecnatron@gmail.com               - ");
  Serial.println(" - Selettore bluetooth 2 canali               - ");
 Serial.println(" -  1 via / 2 posizioni                               - ");
  Serial.println(" - posizione iniziale su A                       - ");
  Serial.println(" --------------------------------------------------- ");
}

void comandi()
{
   Serial.println(" -  Comandi:               - ");
   Serial.println(" -  A = uscita A           - ");
   Serial.println(" -  B = uscita B           - ");
   Serial.println(" -  P = uscita A1         - ");
   Serial.println(" -  p = uscita B1         - ");
   Serial.println(" -  c = comandi          - ");
   Serial.println("  ------------------------- ");
}

void accendi(int pin)
{
   digitalWrite(pin, HIGH); // eccito il relè collegato al pin
   scrivi(pin);    Serial.println(" ON");
}

void spegni(int pin)
{
    digitalWrite(pin, LOW); // rilascio il relè collegato al pin
    scrivi(pin-1);    delay(10);    Serial.println(" ON");
}

void scrivi(int pin)
{
   Serial.print("Uscita ");   Serial.print(pin);
}

void accendiPRE(int pin)
{
   digitalWrite(pin, HIGH); // eccito il relè collegato al pin
   Serial.print("AUX  :  ON \n");
   // Serial.println(' ');
}

void spegniPRE(int pin)
{
   digitalWrite(pin, LOW); // rilascio il relè collegato al pin 
   Serial.print("AUX :  OFF \n");
   // Serial.println(' ');
}

void loop()
  {   while (Serial.available())
   {   dato= Serial.read(); // carattere che viene ricevuto dalla seriale
       Serial.print(dato); Serial.print(' ');
       switch(dato)
       { case 'A':  { spegni(i);      break;}       // Se ricevo "A"
         case 'B':  { accendi(i);     break;}       // Se ricevo "B"
         case 'P':  { accendiPRE(p3); break;} // Se ricevo "P"
         case 'p':  { spegniPRE(p3);  break;}  // Se ricevo "p"
         case 'c':  { comandi();      break;}      // Se ricevo "c"
         default: comandi();       
       }     
   }
  }

// ------------------------- Fine Programma ---------------------------------------------

Argomenti correlati: 

Arduino N° 6 - Comando Bluetooth 2 canali 3 effetti

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

RadioRama n°91 pag 40

Selettore di antenna 2 posizioni_PRE _parte_seconda_Firmware RadioRama n°91 pag 40

> Arduino N° 30

Arduino N° 28 - Azionamento relay per motoriduttori avanti / indietro

< Arduino N° 27

Achille De Santis

> Arduino N° 29

Routine da utilizzare nel corpo del programma.
Nel programma vanno definiti i parametri di ingresso alla routine:   R1, L1, R2,
Rele1  è il comando per il primo relé;
Rele2  è il comando per il secondo relé;
LED1  è una 'spia di equilibrio'.


 /* -------------- Inizio Programma -----------------------------------------------------------------
 *  Azionamento relay per motoriduttori avanti / indietro
 *  Un potenziometro stabilisce la posizione angolare del motoriduttore;
 *  un sensore di posizione (a  potenziometro),  collegato "a ponte" con il primo, rivela il
 *  raggiunto equilibrio.
 */
// ------- I/O ---------------------------------------
#define rele1       11
#define rele2       12
#define Ledpin3  13
// ---------------------------------------------------

void titolo()
{
  Serial.println(" -          Tecnatron Creation                    - ");
  Serial.println(" -          tecnatron@gmail.com               - ");
  Serial.println(" - Azionamento relay per motoriduttori   ");
  Serial.println(" -  Avanti / Indietro                                 - ");
  Serial.println(" ----------------------------------------------- ");
}

void azionamento(bool R1, bool L1, bool R2) // routine ausiliaria non richiamata direttamente.
     {
       digitalWrite(rele1, R1);
       digitalWrite(Ledpin3, L1);         // Led equilibrio
       digitalWrite(rele2, R2);
     }     
 void fermo()       { azionamento (HIGH, HIGH, HIGH); }
 void sinistra()    { azionamento (HIGH, LOW, LOW);   }
 void destra()      { azionamento (LOW, LOW, HIGH);   }

void setup()
{
  Serial.begin(9600);             // velocità di comunicazione
  titolo();
  pinMode (rele1, OUTPUT);
  pinMode (rele2, OUTPUT);
  pinMode (Ledpin3, OUTPUT);
}

void loop()
{
               // inserire qui il programma
}

// ------------------ Fine Programma --------------------------------------------


Nota:
Se non volete caricare troppo l'uscita di Arduino o del microcontrollore potete inserire uno stadio buffer a BJT sul piedino di uscita del canale di comando.

Simulazione: 

Azionamento relay per motoriduttori avanti / indietro

Argomenti correlati: 

Driver a transistore

Arduino N° 27 - Pilotaggio di 2 motori con ponte H

Arduino - Modulo driver motori con ponte ad “H”

> Arduino N° 29

Arduino N° 27 - Pilotaggio di 2 motori con ponte ad H

< Arduino N° 26

Achille De Santis

> Arduino N° 28

Utili sottoprogrammi per la gestione ed il controllo di motori in continua da utilizzare per la movimentazione  di robot, veicoli ecc...


/* ---------------------------- Inizio Programma -----------------------------
 *  Achille De Santis
 * Pilotaggio di 2 motori con ponte H
 * V5 del 09-07-2019
 * In questo modo è facile pilotare anche tre o più motori.
 * Base di lavoro per la gestione di ROBOT, veicoli telecomandati ed altro.
*/

// ---------- pin dell'asse X dei motori --------------
#define MOTOR_XA      13  // motore polo XA
#define MOTOR_XB      12  // motore polo XB
// ---------- pin dell'asse Y dei motori --------------
#define MOTOR_YA      11  // motore polo YA
#define MOTOR_YB      10  // motore polo YB
// --------------------------------------------------------

void motore(int MA,bool A, int MB, bool B)       // motore generico
{
  digitalWrite(MA, A);  // motore, pin A
  digitalWrite(MB, B);  // motore, pin B
}

// --------------------------------------------------------------------------
void avantiSX()   {motore(MOTOR_XA, 1, MOTOR_XB, 0);}
void avantiDX()   {motore(MOTOR_YA, 1, MOTOR_YB, 0);}
void avanti()     {avantiSX(); avantiDX();}
// --------------------------------------------------------------------------
void indietroSX() {motore(MOTOR_XA, 0, MOTOR_XB, 1);}
void indietroDX() {motore(MOTOR_YA, 0, MOTOR_YB, 1);}
void indietro()   {indietroSX(); indietroDX();}
// --------------------------------------------------------------------------
void fermoSX()    {motore(MOTOR_XA,0,MOTOR_XB,0); }
void fermoDX()    {motore(MOTOR_YA,0,MOTOR_YB,0); }
void fermo()      {fermoSX(); fermoDX();  }
// -----------------------------------------------------------------------------
void DXavanti() { fermoDX(); avantiSX(); delay(300); avanti(); }
void SXavanti() { fermoSX(); avantiDX(); delay(300); avanti();  }
// -----------------------------------------------------------------------------
void DXindietro() { fermo(); indietroSX(); delay(300); fermo(); }
void SXindietro() { fermo(); indietroDX(); delay(300); fermo(); }
// ----------------------------------------------------------------------------- 

void setup()
{
  pinMode (MOTOR_XA, OUTPUT);
  pinMode (MOTOR_XB, OUTPUT);
  pinMode (MOTOR_YA, OUTPUT);
  pinMode (MOTOR_YB, OUTPUT);
}

void loop()
{
    // inserire qui il programma
}

// --------------------------- Fine programma ---------------------------

Argomenti correlati: Arduino - Modulo driver motori con ponte ad “H”

> Arduino N° 28

Arduino N° 26 - Tachimetro ad infrarosso

< Arduino N°  25

Achille De Santis

> Arduino N° 27

Tachimetro ad infrarosso, per misure di velocità angolare.

/* ---------------- Inizo Programma --------------------
 * Tachimetro
 * Modificato da Achille De Santis
 * V4 del 08-07-2019
 */
// ------------ I/O --------------------------------------
#define I    A0
#define U   13
// -------------------------------------------------------

int sensorvalue;               // variabile di ingresso
bool state1 = HIGH;
bool state2;
float rps;                        // velocità in giri/secondo
float rpm;                      // velocità in giri/minuto
long prevMillis = 0;
long interval = 200;
long currentTime;
long prevTime = 1;
long diffTime;
const int sensorthreshold = 30;   // indica la soglia "buio/luce" e "luce/buio"; provato; si può cambiare // in relazione alla distanza fisica dei led.
// per vedere quale valore sia adatto, prova il valore di "sensorvalue"
// come stampato da "serial monitor"

unsigned long currentMillis;

void test()                          //only for testing to determine the sensorthreshold value
                 {     delay(500);   Serial.println(sensorvalue);    }

void setup()
{
  Serial.begin(9600);
  pinMode(U, OUTPUT);      // assign pin "U" led as indicator because we cannot see the IR light
}

void loop()
{
  sensorvalue = analogRead(I);            // read from pin "I" (A0)
  if(sensorvalue < sensorthreshold)
    state1 = HIGH;
   else
    state1 = LOW;
   digitalWrite(U, state1);             // as iR light is invisible for us, the led on pin 13
                                                     // indicate the state of the circuit.
   if(state2!=state1)
   {                             // rileva quando lo stato cambia, "buio/luce" o
                                  // "luce/buio", ricorda che la luce IR è NON visibile all'occhio umano.
     if (state2>state1)
     {
       currentTime = micros();                      // Get the arduino time in microseconds
       diffTime = currentTime - prevTime;  // calculate the time diff from the last meet-up
       rps = 1000000/diffTime;                    // calculate how many rev per second, good to know
       rpm = 60000000/diffTime;                // calculate how many rev per minute
       currentMillis=millis();   
                                         // print to serial at every interval - defined at the variables declaration
       if(currentMillis-prevMillis>interval)
        {                              // see if now already an interval long
          prevMillis = currentMillis;     
          Serial.print(rps); Serial.print(" rps  "); Serial.print(rpm); Serial.println(" rpm");
        }     
       prevTime = currentTime;
     }
     state2 = state1;
   }
   // test();                        //prova per determinare il valore di soglia
}

// --------------------- Fine programma -----------------------------------------



Argomenti correlati:

> Arduino N° 27