Cassaforte con Arduino

Samueleex · 10 mar 2024

Oggi vedremo come creare una cassaforte sfruttando il nostro Arduino e il Keypad!
La cassaforte appena accesa mostra il display LCD con un messaggio di benvenuto e chiede all'utente di inserire un nuovo codice di sicurezza.
L'utente inserisce il codice segreto utilizzando il tastierino. Dopo aver inserito il nuovo codice la cassaforte si blocca. "A" per inserire un nuovo pin e "#" per bloccare la cassaforte.

Materiali necessari:

Arduino UNO
Keypad
LCD 16x2
Resistenza da 220 ohm
Servo motore
Vari cavi
Breadboard

Vediamo i vari collegamenti! Per quanto riguarda il Display LCD: RS (Register Select) deve essere collegato al pin 13, RS seleziona tra l'invio di comandi e i dati all'LCD.
E (Enable) al pin 12, abilita la ricezione dei comandi o dei dati inviati al display.
D4-D7 (dati) ai pin 11, 10, 9 e 8, trasmettono i dati al display per visualizzare caratteri, numeri e simboli.
VCC (Alimentazione) ai +5V e GND a terra.
Il tastierino ha in tutto 8 pin: 4 righe (Row Pins) ai pin digitali 5, 4, 3 e 2, vengono utilizzati per leggere le righe. Le 4 colonne (Col Pins) ai pin analogici A0, A1, A2 e A3, utilizzati per leggere le colonne.
Per il servo motore le prime due uscite vanno rispettivamente a GND e a +5V mentre l'uscita del segnale al pin 7.

Scriviamo il codice! Iniziamo con la funzione setup(), inizializziamo l'LCD e del servo, il servo motore viene collegato al pin 7. Viene letto lo stato della memoria EEPROM, se lo stato è "bloccato" il servo motore viene posizionato in modo che sia chiuso altrimenti viene posizionato sullo stato aperto. Sempre nel setup viene scritto il messaggio di benvenuto.
Nel loop() si verifica sempre se la cassaforte è sullo stato bloccato o sbloccato. Se lo stato è sulla logica del blocco, viene mostrato un messaggio sull'LCD indicando che la cassaforte è sbloccata, si verifica che il pin segreto è corretto ed è già presente nella memoria EEPROM. In caso affermativo viene data la possibilità di impostare un nuovo pin. Se l'utente vuole impostare un nuovo pin, inizialmente si richiede il precedente e se è presente in EEPROM verrà autorizzato altrimenti verrà visualizzato un messaggio di errore.
La funzione blocca() ha il compito di posizionare il servo motore in modo che la cassaforte sia in blocco e aggiorna lo stato della sicurezza, simile a sblocca().
inserisciPin() gestisce l'inserimento e restituisce il codice inserito come stringa.
disp_wait restituisce a schermo l'attesa sul display LCD con una barra di caricamento.
new_Pin() gestisce l'impostazione di un eventuale nuovo pin di sicurezza.

Simulazione Wokwi qui!

#include <LiquidCrystal.h>
#include <Keypad.h>
#include <Servo.h>
#include <Arduino.h>
#include <EEPROM.h>

/* meccanismo di blocco */
#define PIN_SERVO 7
#define POS_BLOCCATO 20
#define POS_SBLOCCATO 90
Servo servo;

/* Display */
LiquidCrystal lcd(13, 12, 11, 10, 9, 8);

/* tastierino */
const byte RIGHE_TASTIERA = 4;
const byte COLONNE_TASTIERA = 4;
byte pinRighe[RIGHE_TASTIERA] = {5, 4, 3, 2};
byte pinColonne[COLONNE_TASTIERA] = {A3, A2, A1, A0};
char tasti[RIGHE_TASTIERA][COLONNE_TASTIERA] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
Keypad tastiera = Keypad(makeKeymap(tasti), pinRighe, pinColonne, RIGHE_TASTIERA, COLONNE_TASTIERA);

#define I_B 0
#define I_L_C 1
#define I_C 2
#define V_VUOTO 0xff

#define S_APERTO (char)0
#define S_CHIUSO (char)1

class safe {
private:
  bool bloccoAttivo;

public:
  safe() {
    this->bloccoAttivo = EEPROM.read(I_B) == S_CHIUSO;
  }

  void blocca() {
    this->impostaBlocco(true);
  }

  bool statoBlocco() {
    return this->bloccoAttivo;
  }

  bool PinPresente() {
    auto lunghezzaPin = EEPROM.read(I_L_C);
    return lunghezzaPin != V_VUOTO;
  }

  void impostaPin(String nuovoPin) {
    EEPROM.write(I_L_C, nuovoPin.length());
    for (byte i = 0; i < nuovoPin.length(); i++) {
      EEPROM.write(I_C + i, nuovoPin[i]);
    }
  }

  bool sblocca(String Pin) {
    auto lunghezzaPin = EEPROM.read(I_L_C);
    if (lunghezzaPin == V_VUOTO) {
      // Non c'era alcun Pin, quindi lo sblocco avviene sempre
      this->impostaBlocco(false);
      return true;
    }
    if (Pin.length() != lunghezzaPin) {
      return false;
    }
    for (byte i = 0; i < Pin.length(); i++) {
      auto cifra = EEPROM.read(I_C + i);
      if (cifra != Pin[i]) {
        return false;
      }
    }
    this->impostaBlocco(false);
    return true;
  }

  void impostaBlocco(bool attivo) {
    this->bloccoAttivo = attivo;
    EEPROM.write(I_B, attivo ? S_CHIUSO : S_APERTO);
  }
};

safe safe;

void blocca() {
  servo.write(POS_BLOCCATO);
  safe.blocca();
}

void sblocca() {
  servo.write(POS_SBLOCCATO);
}

void restart_lobby() {
  lcd.setCursor(4, 0);
  lcd.print("Benvenuto!");
  delay(1000);

  lcd.setCursor(0, 2);
  String messaggio = "Cassaforte EHF";
  for (byte i = 0; i < messaggio.length(); i++) {
    lcd.print(messaggio[i]);
    delay(100);
  }
  delay(500);
}

String inserisciPin() {
  lcd.setCursor(5, 1);
  lcd.print("[____]");
  lcd.setCursor(6, 1);
  String risultato = "";
  while (risultato.length() < 4) {
    char tasto = tastiera.getKey();
    if (tasto >= '0' && tasto <= '9') {
      lcd.print('*');
      risultato += tasto;
    }
  }
  return risultato;
}

void disp_wait(int delayMillis) {
  lcd.setCursor(2, 1);
  lcd.print("[..........]");
  lcd.setCursor(3, 1);
  for (byte i = 0; i < 10; i++) {
    delay(delayMillis);
    lcd.print("=");
  }
}

bool new_Pin() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print(" New pin: ");
  String nuovoPin = inserisciPin();

  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Conferma");
  String confermaPin = inserisciPin();

  if (nuovoPin.equals(confermaPin)) {
    safe.impostaPin(nuovoPin);
    return true;
  } else {
    lcd.clear();
    lcd.setCursor(1, 0);
    lcd.print("Errore!");
    lcd.setCursor(0, 1);
    lcd.print("Sblocco");
    delay(2000);
    return false;
  }
}

void unlock_text() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Sbloccato!");
  delay(1000);
}

void unlock_safe() {
  lcd.clear();

  lcd.setCursor(0, 0);
  lcd.print("Sbloccato!");

  bool nuovoPinNecessario = true;

  if (safe.PinPresente()) {
    lcd.setCursor(0, 1);
    lcd.print("New code");
    nuovoPinNecessario = false;
  }

  auto tasto = tastiera.getKey();
  while (tasto != 'A' && tasto != '#') {
    tasto = tastiera.getKey();
  }

  bool ready_lock = true;
  if (tasto == 'A' || nuovoPinNecessario) {
    ready_lock = new_Pin();
  }

  if (ready_lock) {
    lcd.clear();
    lcd.setCursor(5, 0);
    lcd.print("Bloccato!");
    safe.blocca();
    blocca();
    disp_wait(100);
  }
}

void logic_safelock() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Bloccato!");

  String PinUtente = inserisciPin();
  bool sbloccatoConSuccesso = safe.sblocca(PinUtente);
  disp_wait(200);

  if (sbloccatoConSuccesso) {
    unlock_text();
    sblocca();
  } else {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Errore");
    disp_wait(1000);
  }
}

void setup() {
  lcd.begin(16, 2);

  servo.attach(PIN_SERVO);

  /* verifica EEPROM */
  Serial.begin(115200);
  if (safe.statoBlocco()) {
    blocca();
  } else {
    sblocca();
  }

  restart_lobby();
}

void loop() {
  if (safe.statoBlocco()) {
    logic_safelock();
  } else {
    unlock_safe();
  }
}

Video funzionamento:

Samueleex · 9 giu 2024

Versione aggiornata della cassaforte con aggiunta del modulo ds1307 (per la gestione del tempo) e l'aggiunta del relay.

Codice:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <Keypad.h>
#include <RTClib.h>
#include <Adafruit_NeoPixel.h>
#include <EEPROM.h>

#define PIN_RING 11
#define NUM_PIXELS 16

int state = 0;
int menuState = 0;
int limit = 5;
int limitSave = limit;

LiquidCrystal_I2C lcd(0x27, 16, 2);

const byte ROWS = 4;
const byte COLS = 4;
char keys[ROWS][COLS] = {
  {'1', '2',  '3', 'A'},
  {'4', '5',  '6', 'B'},
  {'7', '8',  '9', 'C'},
  {'*', '0',  '#', 'D'}
};
byte rowPins[ROWS] = {2, 3, 4, 5};
byte colPins[COLS] = {6, 7, 8, 9};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);
String inputPIN = "";
#define DEFAULT_PIN "1234"
String storedPIN = DEFAULT_PIN;

int menuIndex = 0;
int menuText = 1;

String newPIN = "";
bool confirmPIN = false;
const int EEPROM_ADDRESS = 0;

unsigned long previousMillisLimit = 0;
const long intervalLimit = 1000;

bool US = true;
bool MP = true;
bool MI = true;
bool LTDP = true;
bool CLTD = true;
bool fLockedt = true;
bool openedState = true;
bool ST = true;

bool move = false;

RTC_DS1307 rtc;

Adafruit_NeoPixel ring = Adafruit_NeoPixel(NUM_PIXELS, PIN_RING, NEO_GRB + NEO_KHZ800);

#define PIR 13

#define BUZZER A3

#define RELAY 12

#define RED A0
#define GREEN A1
#define BLUE A2

void setup() {
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);

  Serial.begin(9600);

  if (!rtc.begin()) {
    lcd.setCursor(0, 1);
    lcd.print("RTC non trovato");
    while (1);
  }
  if (!rtc.isrunning()) {
    rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
  }

  ring.begin();
  ring.show();

  pinMode(PIR, INPUT);

  pinMode(BUZZER, OUTPUT);

  pinMode(RED, OUTPUT);
  pinMode(GREEN, OUTPUT);
  pinMode(BLUE, OUTPUT);

  digitalWrite(RED, HIGH);

  intro();
  homeLock();
  state = 1;
}

void loop() {
  switch (state) {
    case 1:
      lockState();
      break;
    case 2:
      unlockState();
      break;
    case 3:
      menuPIN();
      break;
    case 4:
      menuOptions();
      break;
    case 5:
      openState();
      break;
    case 6:
      secureState();
      break;
  }
}

void lockState() {
  char key = keypad.getKey();
  if (key) {
    if (key == '#') {
      if (storedPIN == inputPIN) {
        lcd.setCursor(5, 1);
        tone(BUZZER, 1000, 500);
        state = 2;
        US = true;
        unlockState();
      } else {
        lcd.setCursor(5, 1);
        lcd.print("PIN errato");
        delay(1000);
        inputPIN = "";
        lcd.setCursor(4, 1);
        lcd.print("          ");
        lcd.setCursor(5, 1);
      }
      inputPIN = "";
    } else if (key == '*') {
      inputPIN = "";
      lcd.setCursor(4, 1);
      lcd.print("        ");
    } else {
      inputPIN += key;
      lcd.setCursor(5 + inputPIN.length() - 1, 1);
      lcd.print('*');
      tone(BUZZER, 500, 100);
      Serial.println(inputPIN);
    }
  }
}

void unlockState() {
  digitalWrite(RED, LOW);
  digitalWrite(GREEN, HIGH);
  if (US == true) {
    lcd.clear();
    US = false;
  }
  lcd.noBlink();
  lcd.noCursor();
  showTime();
  showDate(3);

  char key = keypad.getKey();
  if (key) {
    if (key == 'D') {
      state = 3;
    } else if (key == '*') {
      openState();
      state = 5;
    }
  }
}

void intro() {
  Serial.print("1");
  lcd.setCursor(3, 0);
  lcd.print("CodeLock");
  lcd.setCursor(0, 1);
  for (int i = 0; i < 16; i++) {
    lcd.print("*");
    delay(80);
  }
}

void homeLock() {
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print("--SECURED--");
  lcd.setCursor(0, 1);
  lcd.print("PIN: ");
  lcd.cursor();
  lcd.blink();
  state = 1;
}

void showDate(int timeCursor) {
  DateTime now = rtc.now();
  lcd.setCursor(timeCursor, 1);
  lcd.print(now.year());
  lcd.print('/');
  if (now.month() < 10) lcd.print('0');
  lcd.print(now.month());
  lcd.print('/');
  if (now.day() < 10) lcd.print('0');
  lcd.print(now.day());
}

void showTime() {
  DateTime now = rtc.now();
  lcd.setCursor(4, 0);
  if (now.hour() < 10) lcd.print('0');
  lcd.print(now.hour());
  lcd.print(':');
  if (now.minute() < 10) lcd.print('0');
  lcd.print(now.minute());
  lcd.print(':');
  if (now.second() < 10) lcd.print('0');
  lcd.print(now.second());
}

void menuPIN() {
  if (MP == true) {
    digitalWrite(RED, HIGH);
    digitalWrite(GREEN, LOW);
    MP = false;
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Menu LOCKED!");
    lcd.setCursor(0, 1);
    lcd.print("PIN: ");
  }
  char key = keypad.getKey();
  if (key) {
    if (key == '#') {
      if (storedPIN == inputPIN) {
        lcd.setCursor(5, 1);
        tone(BUZZER, 1000, 500);
        state = 4;
        MP = true;
        menuOptions();
      } else {
        lcd.setCursor(5, 1);
        lcd.print("PIN errato");
        delay(1000);
        inputPIN = "";
        lcd.setCursor(4, 1);
        lcd.print("          ");
        lcd.setCursor(5, 1);
      }
      inputPIN = "";
    } else if (key == '*') {
      inputPIN = "";
      lcd.setCursor(4, 1);
      lcd.print("        ");
    } else {
      inputPIN += key;
      lcd.setCursor(5 + inputPIN.length() - 1, 1);
      lcd.print('*');
      tone(BUZZER, 500, 100);
      Serial.println(inputPIN);
    }
  }
}

void menuOptions() {
  char key = keypad.getKey();

  digitalWrite(RED, LOW);
  digitalWrite(GREEN, HIGH);

  if (key) {
    if (key == '#') {
      menuIndex = menuText;
    }
  }
  switch (menuIndex) {
    case 1:
      changeLimit();
      break;
    case 2:
      changePIN();
      break;
    case 3:
      changeDate();
      break;
    case 4:
      changeTime();
      break;
  }

  if (menuText == 1) {
    if (MI == true) {
      MI = false;
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Cambia limite");
    }
    if (key) {
      if (key == 'A') {
        menuText = 4;
        MI = true;
      } else if (key == 'B') {
        menuText = 2;
        MI = true;
      } else if (key == '#') {
        menuIndex = 1;
        CLTD = true;
      }
    }
  } else if (menuText == 2) {
    if (MI == true) {
      MI = false;
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Cambia PIN");
    }
    if (key) {
      if (key == 'A') {
        menuText = 1;
        MI = true;
      } else if (key == 'B') {
        menuText = 3;
        MI = true;
      } else if (key == '#') {
        CLTD = true;
        menuIndex = 2;
      }
    }
  } else if (menuText == 3) {
    if (MI == true) {
      MI = false;
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Cambia data");
    }
    if (key) {
      if (key == 'A') {
        menuText = 2;
        MI = true;
      } else if (key == 'B') {
        menuText = 4;
        MI = true;
      } else if (key == '#') {
        CLTD = true;
        menuIndex = 3;
      }
    }
  } else if (menuText == 4) {
    if (MI == true) {
      MI = false;
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Cambia ora");
    }
    if (key) {
      if (key == 'A') {
        menuText = 3;
        MI = true;
      } else if (key == 'B') {
        menuText = 1;
        MI = true;
      } else if (key == '#') {
        CLTD = true;
        menuIndex = 4;
      }
    }
  }
}

void changeLimit() {
  if (CLTD == true) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Vecchio Limite:");
    lcd.setCursor(5, 1);
    lcd.print(limit);
    delay(1000);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Nuovo limite:");
    CLTD = false;
  }
  char key = keypad.getKey();
  if (key) {
    if (key == '*') {
      limitSave = limit;
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Salvato");
      delay(500);
      EEPROM.put(EEPROM_ADDRESS, limitSave);
      lcd.clear();
      menuIndex = 0;
    } else if (key == '#') {
      limit = 0;
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Annullato");
      delay(500);
      lcd.clear();
      menuIndex = 0;
    } else {
      limit = limit * 10 + (key - '0');
      lcd.setCursor(5, 1);
      lcd.print(limit);
    }
  }
}

void changePIN() {
  if (CLTD == true) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Nuovo PIN:");
    CLTD = false;
  }
  char key = keypad.getKey();
  if (key) {
    if (key == '*') {
      if (confirmPIN) {
        storedPIN = newPIN;
        newPIN = "";
        confirmPIN = false;
        lcd.clear();
        lcd.setCursor(0, 1);
        lcd.print("PIN Salvato");
        delay(500);
        lcd.clear();
        menuIndex = 0;
      } else {
        newPIN = "";
        confirmPIN = true;
        lcd.setCursor(0, 1);
        lcd.print("Conferma PIN:");
      }
    } else if (key == '#') {
      newPIN = "";
      confirmPIN = false;
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Annullato");
      delay(500);
      lcd.clear();
      menuIndex = 0;
    } else {
      newPIN += key;
      lcd.setCursor(newPIN.length() - 1, 1);
      lcd.print('*');
    }
  }
}

void changeDate() {
  DateTime now = rtc.now();
  if (CLTD == true) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Vecchia Data:");
    showDate(5);
    delay(2000);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Nuova Data:");
    CLTD = false;
  }
  static int datePart = 0;
  static int year = now.year();
  static int month = now.month();
  static int day = now.day();
  char key = keypad.getKey();
  if (key) {
    if (key == '*') {
      if (datePart == 2) {
        rtc.adjust(DateTime(year, month, day, now.hour(), now.minute(), now.second()));
        lcd.setCursor(0, 1);
        lcd.print("Data Salvata");
        delay(500);
        lcd.clear();
        menuIndex = 0;
        datePart = 0;
      } else {
        datePart++;
      }
    } else if (key == '#') {
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Annullato");
      delay(500);
      lcd.clear();
      menuIndex = 0;
      datePart = 0;
    } else {
      int num = key - '0';
      if (datePart == 0) {
        year = year * 10 + num;
        lcd.setCursor(5 + (year > 1000 ? 4 : year > 100 ? 3 : year > 10 ? 2 : 1), 1);
        lcd.print(year);
      } else if (datePart == 1) {
        month = month * 10 + num;
        lcd.setCursor(7, 1);
        lcd.print('/');
        lcd.print(month);
      } else if (datePart == 2) {
        day = day * 10 + num;
        lcd.setCursor(10, 1);
        lcd.print('/');
        lcd.print(day);
      }
    }
  }
}

void changeTime() {
  DateTime now = rtc.now();
  if (CLTD == true) {
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Vecchia Ora:");
    showTime();
    delay(2000);
    lcd.clear();
    lcd.setCursor(0, 0);
    lcd.print("Nuova Ora:");
    CLTD = false;
  }
  static int timePart = 0;
  static int hour = now.hour();
  static int minute = now.minute();
  static int second = now.second();
  char key = keypad.getKey();
  if (key) {
    if (key == '*') {
      if (timePart == 2) {
        rtc.adjust(DateTime(now.year(), now.month(), now.day(), hour, minute, second));
        lcd.setCursor(0, 1);
        lcd.print("Ora Salvata");
        delay(500);
        lcd.clear();
        menuIndex = 0;
        timePart = 0;
      } else {
        timePart++;
      }
    } else if (key == '#') {
      lcd.clear();
      lcd.setCursor(0, 1);
      lcd.print("Annullato");
      delay(500);
      lcd.clear();
      menuIndex = 0;
      timePart = 0;
    } else {
      int num = key - '0';
      if (timePart == 0) {
        hour = hour * 10 + num;
        lcd.setCursor(5, 1);
        lcd.print(hour);
      } else if (timePart == 1) {
        minute = minute * 10 + num;
        lcd.setCursor(7, 1);
        lcd.print(':');
        lcd.print(minute);
      } else if (timePart == 2) {
        second = second * 10 + num;
        lcd.setCursor(10, 1);
        lcd.print(':');
        lcd.print(second);
      }
    }
  }
}

void openState() {
  if (openedState == true) {
    openedState = false;
    digitalWrite(RELAY, HIGH);
    lcd.clear();
    lcd.setCursor(3, 0);
    lcd.print("--APERTA--");
    lcd.setCursor(0, 1);
    lcd.print("Aperto da");
    showDate(9);
    delay(2000);
  }
  unsigned long currentMillisLimit = millis();
  if (currentMillisLimit - previousMillisLimit >= intervalLimit) {
    previousMillisLimit = currentMillisLimit;
    limit--;
    lcd.setCursor(12, 1);
    lcd.print(limit);
    if (limit <= 0) {
      limit = limitSave;
      previousMillisLimit = 0;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("--CHIUSA--");
      delay(1000);
      digitalWrite(RELAY, LOW);
      homeLock();
      openedState = true;
      state = 1;
    }
  }
  char key = keypad.getKey();
  if (key) {
    if (key == '*') {
      limit = limitSave;
      previousMillisLimit = 0;
      lcd.clear();
      lcd.setCursor(0, 0);
      lcd.print("--CHIUSA--");
      delay(1000);
      digitalWrite(RELAY, LOW);
      homeLock();
      openedState = true;
      state = 1;
    }
  }
}

void secureState() {
  digitalWrite(RED, HIGH);
  digitalWrite(GREEN, LOW);
  lcd.clear();
  lcd.setCursor(2, 0);
  lcd.print("--CHIUSA--");
  lcd.setCursor(0, 1);
  lcd.print("PIN: ");
  lcd.cursor();
  lcd.blink();
  state = 1;
}

Fondatori