Arduino N° 51 - Semaforo doppio a tre stati

< Segue da Arduino N°  50

Achille De Santis

> Arduino N° 52

prof. De Santis


Simulazione:  Semaforo doppio a tre stati, gestito con variabili multiple (vettori) e sottoprogrammi.


Semaforo doppio a tre stati

Semaforo singolo a tre stati


Argomenti correlati:

Arduino N° 35 - Semaforo singolo a tre stati

> Arduino N° 52

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° 49 - Gestione LED indirizzabili - II

< Segue da Arduino N°  48

Achille De Santis

> Arduino N°  50

parte II

/* ---------------------------- Inizio Programma ---------------------------------------------------------
 * Gestione di Tre LED indirizzabili
 * Semplice programma per familiarizzarsi con l'uso dei LED indirizzabili.
 * Come si vede, il piedino di comando è soltanto uno.
 * I colori possono essere accesi singolarmente (colori primari) o in gruppo (colori compositi)
 *
 */

#include <Adafruit_NeoPixel.h>
#define PIN 6                               // unico piedino di comando dei LED
// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)


Adafruit_NeoPixel strip = Adafruit_NeoPixel(60, PIN, NEO_GRB + NEO_KHZ800);

void setup()
  {
    strip.begin();                    // inizializza
    strip.show();                    //  Visualizza
  }
void loop()
{
  strip.setPixelColor(0, 255, 0, 0);        // (indirizzo, coefficienti tricromatici rosso, verde, blu)
 strip.setPixelColor(1, 0, 255, 0);        // (indirizzo, coefficienti tricromatici rosso, verde, blu)
 strip.setPixelColor(2, 0, 0, 255);        // (indirizzo, coefficienti tricromatici rosso, verde, blu)
  strip.show();                                       // visualizza

  delay(1000);
// ma potete anche fare:

  strip.setPixelColor(0, 255, 0, 0);     //
  strip.show();
  delay(500);

  strip.setPixelColor(1, 0, 255, 0);
  strip.show();
  delay(500);

  strip.setPixelColor(2, 0, 0, 255);
  strip.show();
  delay(500);                       

  delay(500);

  // Oppure

  for (int i=0; i<=2; i++)
  {
    strip.setPixelColor(i, 255, 0, 0);   //
    strip.show();                                 //
    delay(1000);
  }

  // oppure

  for (int i=0; i<=2; i++)
  {
    strip.setPixelColor(i, 128, 128, 128); //
    strip.show();                         //
    delay(1000);
  }
}

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



Argomenti correlati:

Gestione LED indirizzabili - parte I

> Arduino N°  50

Arduino N° 48 - Gestione LED indirizzabili - I

< Segue da Arduino N°  47

Achille De Santis

> Arduino N° 49

parte I

Un LED RGB standard (catodo o anodo comune), ha tre piedini che forniscono l'alimentazione agli elementi, più un piedino di ritorno comune:

• rosso,
• verde 
• blu 
• piedino di ritorno comune.

I reofori stessi sono spesso disposti nella configurazione rosso-comune-blu-verde ed è facile identificarli per ispezione visiva. 

Sono disponibili nei tipi ad "Anodo Comune" e "Catodo Comune", ognuno con esigenze e configurazioni leggermente diverse.

I LED INDIRIZZABILI, hanno la seguente configurazione dei piedini:

·         pin di ingresso dati,

·         pin di alimentazione,

·         pin comune (massa) 

·         pin di uscita dati.

Essi sono, quindi dotati di un piedino di indirizzo che ne permette il collegamento "a catena" e riduce il numero dei piedini di pilotaggio.

Inoltre, essi interpretano facilmente i codici di colore  Rosso - Verde - Blu.

La gestione è un po' più elaborata ma le possibili configurazioni sono molto più estese e l'impiego dei piedini di uscita è estremamente ridotto.

Quello che segue è un esempio su come si possa gestire un LED indirizzabile.

/* -------------------------- Inizio programma ------------------------------
 * Gestione di un LED RGB indirizzabile
 *
 */

#include <Adafruit_NeoPixel.h>            // Utilizza libreria Neopixel di Adafruit
#define PIN 6                                          // pin a cui è collegato il nostro led indirizzabile
#define LUN 1                                        // Lunghezza striscia led (In questo caso: 1 solo elemento)

// Creiamo l'oggetto Neopixel chiamato LED
Adafruit_NeoPixel led = Adafruit_NeoPixel(LUN, PIN, NEO_GRB + NEO_KHZ800);


void intestazione()

  { Serial.begin(9600);        // velocità seriale
    Serial.println(" ________ Tecnatron Creation _________________");
    Serial.println(" Gestione di LED indirizzabili                                --");
    Serial.println(" prof. Achille De Santis - 18-03-2020 -----------------");
  }

void setup()
{
  led.begin();                                           // Inizializza led; Prepara i dati da inviare al led
  led.show();                                           // Invia i dati al led (al momento, nulla).
}
void loop()
{
  led.setBrightness(255);                       // predispone la luminosità (massima)
  led.setPixelColor(0, 255, 255, 255);  // Imposta il colore al nostro led (led=0, R=255, G=255; B=255)
  led.show();                                        // avvia la visualizzazione
  delay(1000);
  led.setBrightness(0);                        // spegne
  led.show();                                       // attua il comando
  delay(1000);
}

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

Argomenti correlati:
gestione dei colori RGB
Gestione LED indirizzabili - parte II


> Arduino N° 49