Sveglia da comodino con luminosità display regolabile e allarme progressivo su buzzer

Progetto Arduino per sveglia da comodino con display 7 segmenti, luminosità regolabile e allarme progressivo su buzzer per un risveglio dolce.

Breve Introduzione

Sveglia da comodino con luminosità display regolabile e allarme progressivo su buzzer (arduino)
DESCRIZIONE:
Questo progetto realizza una sveglia digitale da comodino con display a 7 segmenti a 4 cifre, luminosità regolabile tramite potenziometro e allarme sonoro progressivo su buzzer piezo. L'ora viene impostata manualmente tramite due pulsanti (ore e minuti). L'allarme si attiva all'ora impostata, aumentando gradualmente il volume del buzzer per svegliare dolcemente.

NOTE AGGIUNTIVE:
Il codice gestisce la visualizzazione dell'ora, la regolazione della luminosità del display tramite potenziometro e l'allarme con buzzer che aumenta gradualmente il volume. I pulsanti permettono di impostare l'ora corrente e l'ora dell'allarme. Il timer interno di Arduino viene usato per il conteggio del tempo. Il progetto è adatto a chi ha una conoscenza base-intermedia di Arduino e vuole realizzare una sveglia semplice ma funzionale.

SPIEGAZIONI:
- La libreria TM1637 semplifica la gestione del display 7 segmenti a 4 cifre, permettendo di mostrare l'ora in formato HH:MM.
- Il potenziometro collegato ad A0 legge un valore analogico da 0 a 1023, che viene mappato per regolare la luminosità del display.
- I pulsanti sono collegati con resistenze pull-down per evitare falsi trigger. Premendo i pulsanti si incrementano ore e minuti dell'ora corrente.
- L'allarme si attiva quando l'ora corrente coincide con l'ora impostata per l'allarme. Il buzzer suona con un tono che aumenta gradualmente di frequenza e durata per simulare un volume crescente.
- Il codice utilizza millis() per gestire il tempo senza bloccare l'esecuzione, permettendo di aggiornare display, leggere input e gestire l'allarme in modo fluido.

Codice Esempio: arduino

// Sveglia da comodino con luminosità display regolabile e allarme progressivo su buzzer
// Hardware: Arduino Uno, display TM1637 4 cifre, buzzer piezo, potenziometro, 2 pulsanti

#include <Arduino.h>

// Libreria TM1637 per display 7 segmenti 4 cifre
// Implementazione minima per evitare dipendenze esterne
class TM1637 {
  private:
    uint8_t clkPin;
    uint8_t dioPin;
    uint8_t brightness;

    void start() {
      pinMode(dioPin, OUTPUT);
      digitalWrite(dioPin, HIGH);
      digitalWrite(clkPin, HIGH);
      digitalWrite(dioPin, LOW);
      digitalWrite(clkPin, LOW);
    }

    void stop() {
      pinMode(dioPin, OUTPUT);
      digitalWrite(clkPin, LOW);
      digitalWrite(dioPin, LOW);
      digitalWrite(clkPin, HIGH);
      digitalWrite(dioPin, HIGH);
    }

    bool writeByte(uint8_t b) {
      for (uint8_t i=0; i<8; i++) {
        digitalWrite(clkPin, LOW);
        if (b & 0x01) digitalWrite(dioPin, HIGH);
        else digitalWrite(dioPin, LOW);
        b >>= 1;
        digitalWrite(clkPin, HIGH);
      }
      // wait for ACK
      digitalWrite(clkPin, LOW);
      pinMode(dioPin, INPUT);
      digitalWrite(dioPin, HIGH);
      digitalWrite(clkPin, HIGH);
      bool ack = (digitalRead(dioPin) == 0);
      digitalWrite(clkPin, LOW);
      pinMode(dioPin, OUTPUT);
      return ack;
    }

  public:
    TM1637(uint8_t clk, uint8_t dio) {
      clkPin = clk;
      dioPin = dio;
      brightness = 7; // max brightness
    }

    void init() {
      pinMode(clkPin, OUTPUT);
      pinMode(dioPin, OUTPUT);
      clear();
    }

    void setBrightness(uint8_t b) {
      if (b > 7) b = 7;
      brightness = b;
      start();
      writeByte(0x88 | brightness); // command to set brightness
      stop();
    }

    void clear() {
      start();
      writeByte(0x40); // command to set auto increment mode
      stop();
      start();
      writeByte(0xC0); // command to set starting address
      for (uint8_t i=0; i<4; i++) {
        writeByte(0x00); // clear all digits
      }
      stop();
    }

    void displayDigits(uint8_t digits[4], bool colon) {
      static const uint8_t digitToSegment[] = {
        0x3F, // 0
        0x06, // 1
        0x5B, // 2
        0x4F, // 3
        0x66, // 4
        0x6D, // 5
        0x7D, // 6
        0x07, // 7
        0x7F, // 8
        0x6F  // 9
      };

      start();
      writeByte(0x40); // auto increment mode
      stop();

      start();
      writeByte(0xC0); // start address

      for (uint8_t i=0; i<4; i++) {
        uint8_t seg = 0x00;
        if (digits[i] <= 9) seg = digitToSegment[digits[i]];
        else seg = 0x00; // blank
        if (i == 1 && colon) seg |= 0x80; // punto decimale come due punti
        writeByte(seg);
      }

      stop();
      setBrightness(brightness);
    }
};

// Pin definizioni
const uint8_t PIN_CLK = 2;       // TM1637 CLK
const uint8_t PIN_DIO = 3;       // TM1637 DIO
const uint8_t PIN_BUZZER = 9;    // Buzzer piezo
const uint8_t PIN_POT = A0;      // Potenziometro per luminosità
const uint8_t PIN_BTN_HOUR = 4;  // Pulsante ore
const uint8_t PIN_BTN_MIN = 5;   // Pulsante minuti

// Variabili orologio
uint8_t hour = 12;
uint8_t minute = 0;

// Variabili allarme
uint8_t alarmHour = 6;
uint8_t alarmMinute = 30;
bool alarmActive = true;
bool alarmRinging = false;

// Pulsanti stato precedente per debounce
bool lastBtnHourState = LOW;
bool lastBtnMinState = LOW;
unsigned long lastDebounceTimeHour = 0;
unsigned long lastDebounceTimeMin = 0;
const unsigned long debounceDelay = 50;

// Timer per aggiornamento orario
unsigned long lastTimeUpdate = 0;
const unsigned long timeUpdateInterval = 60000; // 60 secondi

// Timer per suono buzzer
unsigned long alarmStartTime = 0;

TM1637 display(PIN_CLK, PIN_DIO);

void setup() {
  pinMode(PIN_BUZZER, OUTPUT);
  pinMode(PIN_BTN_HOUR, INPUT);
  pinMode(PIN_BTN_MIN, INPUT);

  display.init();
  display.setBrightness(7);

  // Inizializza seriale per debug
  Serial.begin(9600);
  Serial.println("Sveglia avviata");
}

// Funzione per leggere pulsante con debounce
bool readButton(uint8_t pin, bool &lastState, unsigned long &lastDebounce) {
  bool reading = digitalRead(pin);
  if (reading != lastState) {
    lastDebounce = millis();
  }
  if ((millis() - lastDebounce) > debounceDelay) {
    if (reading != lastState) {
      lastState = reading;
      if (reading == HIGH) {
        return true;
      }
    }
  }
  return false;
}

// Incrementa ora con rollover
void incrementHour() {
  hour++;
  if (hour >= 24) hour = 0;
}

// Incrementa minuti con rollover
void incrementMinute() {
  minute++;
  if (minute >= 60) {
    minute = 0;
    incrementHour();
  }
}

// Controlla se è ora di suonare l'allarme
bool checkAlarm() {
  return alarmActive && (hour == alarmHour) && (minute == alarmMinute);
}

// Funzione per suonare buzzer con volume progressivo
void alarmSound() {
  unsigned long elapsed = millis() - alarmStartTime;
  // Aumenta frequenza tono ogni 500ms fino a 2000ms
  uint16_t toneFreq = 1000 + (elapsed / 2); // da 1000Hz a ~2000Hz
  if (toneFreq > 2000) toneFreq = 2000;

  // Durata tono aumenta con il tempo (max 400ms)
  uint16_t toneDuration = 100 + (elapsed / 10);
  if (toneDuration > 400) toneDuration = 400;

  tone(PIN_BUZZER, toneFreq, toneDuration);
}

void loop() {
  // Leggi potenziometro e regola luminosità
  int potValue = analogRead(PIN_POT);
  uint8_t brightness = map(potValue, 0, 1023, 0, 7);
  display.setBrightness(brightness);

  // Gestione pulsanti per impostare ora
  if (readButton(PIN_BTN_HOUR, lastBtnHourState, lastDebounceTimeHour)) {
    incrementHour();
    Serial.print("Ora impostata: "); Serial.println(hour);
  }
  if (readButton(PIN_BTN_MIN, lastBtnMinState, lastDebounceTimeMin)) {
    incrementMinute();
    Serial.print("Minuto impostato: "); Serial.println(minute);
  }

  // Aggiorna orario ogni 60 secondi
  if (millis() - lastTimeUpdate >= timeUpdateInterval) {
    lastTimeUpdate = millis();
    incrementMinute();
  }

  // Controlla allarme
  if (checkAlarm()) {
    if (!alarmRinging) {
      alarmRinging = true;
      alarmStartTime = millis();
      Serial.println("Allarme attivato!");
    }
  } else {
    alarmRinging = false;
    noTone(PIN_BUZZER);
  }

  // Se allarme attivo, suona buzzer con volume progressivo
  if (alarmRinging) {
    alarmSound();
  }

  // Mostra ora sul display
  uint8_t digits[4];
  digits[0] = hour / 10;
  digits[1] = hour % 10;
  digits[2] = minute / 10;
  digits[3] = minute % 10;

  // Mostra due punti lampeggianti ogni secondo
  bool colon = (millis() / 500) % 2 == 0;
  display.displayDigits(digits, colon);

  delay(50); // piccolo ritardo per stabilità
}
×
×
×
Vuoi rigenerare la risposta?
×
Esporta chat
Scegli il formato di esportazione
Generazione PDF in corso…
Allegati
×
Stai per chiudere la chat e passare al generatore immagini, se non sei loggato perderai la nostra chat, confermi?
Stai visualizzando una chat condivisa in modalità temporanea. Non verrà salvata.
×
Prompt salvati
×
Nota privata
×
Etichetta
×
Cerca in tutte le chat
×
I tuoi insight
Analisi in corso…
×
Preferenze IA
Nome assistente 30
Lunghezza risposte
Modello IA
Risposte strutturate
Includi esempi
Usa emoji
Guidami, non risolvere Indizi e domande invece della soluzione pronta
Configura di più →
×
Condividi questa chat
Chi apre questo link potrà visualizzare la chat oppure aggiungerla al proprio profilo come chat personale.
Attenzione: verranno condivisi anche gli allegati della chat. Chi la aggiungerà riceverà una copia dei file nella propria cartella.
Chat condivisa
Qualcuno ha condiviso una chat con te. Vuoi solo visualizzarla o aggiungerla alle tue chat?
Attenzione: verranno condivisi anche gli allegati della chat. Chi la aggiungerà riceverà una copia dei file nella propria cartella.
×

Messaggi salvati

Caricamento in corso...

×

Cronologia Chat

programmi-esempio · CRONOLOGIA CHAT

Caricamento in corso...

Preferenze IA

×
  • BaseRisposte rapide ed essenziali per studio
  • MedioQualità superiore per studio e programmazione
  • AvanzatoRagionamento complesso e analisi dettagliate
Spiega Passaggi

Cosa serve?

Arduino Uno (o compatibile)

Display 7 segmenti a 4 cifre (modulo TM1637)

Modulo buzzer piezo attivo

Potenziometro 10k ohm (per regolare luminosità display)

2 Pulsanti push-button (per impostare ore e minuti)

Resistenze da 10k ohm per pull-down dei pulsanti

Cavi jumper

Breadboard

Collegamenti:
  • Display TM1637: CLK -> pin digitale 2, DIO -> pin digitale 3
  • Buzzer piezo: pin positivo -> pin digitale 9, negativo -> GND
  • Potenziometro: terminale centrale -> pin analogico A0, altri due terminali a 5V e GND
  • Pulsante ore: un terminale a 5V, l'altro a pin digitale 4 con resistenza pull-down a GND
  • Pulsante minuti: un terminale a 5V, l'altro a pin digitale 5 con resistenza pull-down a GND
Software:
  • Libreria TM1637 per controllo display (inclusa nel codice)
  • Nessuna altra dipendenza esterna

Argomenti Simili

LED che lampeggia con pulsante di stop
Programma Arduino per far lampeggiare un LED con pulsante di stop che interrompe il lampeggio e spegne il LED premendo il pulsante.
Semaforo pedonale con due LED e pulsante
Progetto Arduino di un semaforo pedonale con due LED e pulsante per gestire il passaggio in modo semplice e senza bloccare il loop principale.
Termometro base con sensore di temperatura e LED di avviso
Realizza un termometro base con Arduino e sensore LM35 che accende un LED di avviso superata la soglia di 3 gradi Celsius con monitor seriale.
Allarme porta aperta con sensore magnetico e buzzer
Progetto Arduino con sensore magnetico reed switch e buzzer per allarme porta aperta. Lettura stabile con resistenza pull-up esterna da 1k ohm.
Controllo di una ventola con sensore di temperatura on/off
Progetto Arduino per controllo ventola con sensore temperatura LM35 on off. Accensione automatica al superamento soglia temperatura impostata.
LED che si accende al buio con fotoresistenza
Progetto Arduino con fotoresistenza per accendere un LED al buio regolando la soglia di luminosità e monitorando i valori con comunicazione seriale.
Campanello di casa con pulsante e buzzer
Progetto Arduino per un campanello di casa con pulsante e buzzer attivo, utilizza INPUT_PULLUP e debounce software per un funzionamento semplice e affidabile.
Contatore di persone con pulsante e display a 7 segmenti
Progetto Arduino con contatore di persone che incrementa un display a 7 segmenti comune catodo tramite pulsante con debounce software e resistenze di protezione