[Progetto] Palloncini con led

Vi presento il progetto che ho realizzato per il Matrimonio di un mio carissimo amico di cui sono stato anche Testimone.
L’idea l’ho avuta anni fa ma prevedeva un solo palloncino con un solo led. Qui ho invece realizzato un supporto con 7 palloncini con led integrati.
Questo è il risultato finale. (la torta e il porta torta non sono miei)

Andiamo per ordine.
Ho acquistato in negozio i palloncini a forma di cuore e le asticelle, mentre sulla grande rete ho trovato un sistema a led che permetteva di inserirli nella base.
http://www.newballoonstore.com/ecommerce-id-4316.html
Purtroppo non mi andava bene perché non permetteva di comandare i led, ho quindi sostituito i led con dei led rossi, smontato le capsule, di cui ho usato solo la parte trasparente, e montato tutto sull’asticella, siliconando per bene per evitare che uscisse l’aria. (le capsule non sono stagne)

Sulla capsula ho fissato il palloncino

ed ho ripetuto il tutto per 7 volte.

Ho quindi creato una scheda driver per i led usando un ULN2803.

I pin dell’ULN sono collegati ai pin PWM della Leonardo (che ne ha 7) più il pin 2 di riserva e un pulsante al pin 4.
L’alimentazione + dei led è presa dal pin Vin dove arriva l’alimentazione esterna data da una batteria al piombo da 12V 7200mAh (sulla Leonardo il diodo di protezione e in parallelo e non in serie)
Le resistenza sono da 680ohm e mi garantivano una corrente di 15mA sui led.

Ogni led era collegato ad un diverso morsetto mentre le alimentazioni erano in comune.

Come microcontrollore ho usato un’Arduino Leonardo

Questo è l’assemblaggio prima della messa in opera

Questo il brutto codice di controllo:

const byte maxCase = 10;
const byte buttonPin = 4;
const byte LED[] = {
  2, 3, 5, 6, 9, 10, 11, 13};
boolean LEDState[] = {
  LOW, LOW, LOW, LOW, LOW, LOW, LOW, LOW};

byte buttonPushCounter = 1;
boolean buttonState = HIGH;
boolean lastButtonState = HIGH;
boolean ledState = LOW;

unsigned long previousMillis = 0;
unsigned long currentMillis = 0;

unsigned long pTime = 0;
unsigned long cTime = 0;
const unsigned long iTime = 120000UL;

int fadeValue = 0;
boolean fadeUp;
const int fadeStep = 8;
const unsigned long fadeTime = 40;

boolean Double;

boolean Change;
byte oldled = 0;
byte numled= 0;

void setup() {
  //  Serial.begin(9600);
  pinMode(buttonPin, INPUT_PULLUP);
  for (byte i = 0; i < 8; i++) pinMode(LED[i], OUTPUT);
  initialize();
}


void loop() {
  currentMillis = millis();
  cTime = currentMillis;
  buttonState = digitalRead(buttonPin);
  //Serial.print("cTime: ");
  //Serial.print(cTime);
  //Serial.print(" pTime: ");
  //Serial.println(pTime);
  //delay(500);
  if (cTime - pTime >= iTime) {
    pTime = cTime;
    // Serial.print("Time: ");
    buttonPushCounter = random(1, maxCase + 1);
    // Serial.println(buttonPushCounter);
    initialize();
  }

  if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == LOW) {
      // if the current state is HIGH then the button
      // wend from off to on:
      buttonPushCounter++;
      if (buttonPushCounter > maxCase) buttonPushCounter = 1;
      //      Serial.print("Counter: ");
      //      Serial.println(buttonPushCounter);
      initialize();
    }
    delay(25);
  }
  lastButtonState = buttonState;



  switch (buttonPushCounter)
  {
  case 1:
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], LOW);
    break;

  case 2:
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], HIGH);
    break;

  case 3:
    PulseLed(400);
    break;

  case 4:
    FadingLed();
    break;

  case 5:
    PulseLed(800);
    break;

  case 6:
    DoublePulse(1350, 150, 60);
    break;

  case 7:
    RandomLed(800);
    break;

  case 8:
    RandomLedPulse(1250, 150, 60);
    break;

  case 9:
    RandomFadingLed();
    break;

  case 10:
    RandomFadingLed2();
    break;

  default:
    break;
  }
}// End Loop


void initialize(void)
{
  for (byte i = 0; i < 8; i++) LEDState[i] = LOW;
  fadeValue = 0;
  fadeUp = true;
  Change = true;
  Double = false;
  previousMillis = currentMillis;
  pTime = cTime;
  for (byte i = 0; i < 8; i++) digitalWrite(LED[i], LOW);
}


void PulseLed(unsigned long interval) {
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;

    ledState = !ledState;
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], ledState);
  }
}


void FadingLed(void) {
  digitalWrite(LED[0], LOW);
  if (currentMillis - previousMillis >= fadeTime) {
    previousMillis = currentMillis;
    if (fadeUp == true)
      fadeValue += fadeStep;
    else
      fadeValue -= fadeStep;
    if (fadeValue >= 255 || fadeValue <= 0) fadeUp = !fadeUp;
    fadeValue = constrain(fadeValue, 0, 255);
    for (byte i = 1; i < 8; i++) analogWrite(LED[i], fadeValue);
  }
}


void DoublePulse(unsigned long pulseone, unsigned long pulsetwo, unsigned long duration) {
  if (currentMillis - previousMillis >= pulseone) {
    previousMillis = currentMillis;
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], HIGH);
    delay(duration);
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], LOW);
    delay(pulsetwo);
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], HIGH);
    delay(duration);
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], LOW);
  }
}


void RandomLed(unsigned long interval) {
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    for (byte i = 1; i < 8; i++) digitalWrite(LED[i], LOW);
    int numled = random(1, 8);
    digitalWrite(LED[numled], HIGH);
  }
}


void RandomLedPulse(unsigned long pulseone, unsigned long pulsetwo, unsigned long duration) {
  if (currentMillis - previousMillis >= pulseone) {
    previousMillis = currentMillis;
    int numled = random(1, 8);
    digitalWrite(LED[numled], HIGH);
    delay(duration);
    digitalWrite(LED[numled], LOW);
    delay(pulsetwo);
    digitalWrite(LED[numled], HIGH);
    delay(duration);
    digitalWrite(LED[numled], LOW);
  }
}

void RandomFadingLed(void) {
  int numled = oldled;
  if (Change == true) numled = random(1, 8);
  digitalWrite(LED[0], LOW);
  if (currentMillis - previousMillis >= fadeTime) {
    previousMillis = currentMillis;
    if (fadeUp == true)
      fadeValue += fadeStep;
    else
      fadeValue -= fadeStep;
    if (fadeValue >= 255 || fadeValue <= 0)
    {
      if (fadeUp == true)
        Change == false;
      else
        Change == true;
      fadeUp = !fadeUp;
    }
    constrain(fadeValue, 0, 255);
    analogWrite(LED[numled], fadeValue);
  }
}

void RandomFadingLed2(void) {
  // numled = oldled;
  if (fadeValue <= 0) numled = random(1, 8);
  digitalWrite(LED[0], LOW);

  if (currentMillis - previousMillis >= fadeTime) {
    previousMillis = currentMillis;
    if (fadeUp == true)
      fadeValue += fadeStep;
    else
      fadeValue -= fadeStep;
    if (fadeValue >= 255 || fadeValue <= 0)
    {
      fadeUp = !fadeUp;
    }
    fadeValue = constrain(fadeValue, 0, 255);
    analogWrite(LED[numled], fadeValue);
    // Serial.println(fadeValue);
  }
}

Il codice prevede diverse sequenze richiamabili tramite pulsante oppure con rotazione casuale ogni 2 minuti se non viene premuto il pulsante.

PaoloP.

Ammappete che idea! :D

Bell'idea cavolo, bravo Paolo !

Complimenti. Bella idea.

Ma nella prima foto, i led sono spenti, vero? Non hai una foto di quando sono accesi ?

Si, sono spenti. :sweat_smile: Non ho foto coi led accesi.

Sarebbe stato bello un video per gustarsi il funzionamento. Ti ruberò magari l'idea per qualche malsana idea da inserire a casa (al posto dei palloncini posso utilizzare delle sfere di vetro, o vasi...) Complimenti!

Veramente interessante!

PaoloP: Si, sono spenti. :sweat_smile: Non ho foto coi led accesi.

Frust frust... ]:D