Ceas cu afisaj 7 segmente varianta niq_ro

[daniels]

Am facut acest proiect, https://www-instructables-com.cdn.ampproject.org/v/s/www.instructables.com/4-digit-7-segment-Led-Clock-With-Manual-Adjust-Ala/?amp_gsa=1&amp_js_v=a9&amp_page=true&usqp=mq331AQIUAKwASCAAgM%3D#amp_tf=De la %1%24s&aoh=16876247897520&referrer=https%3A%2F%2Fwww.google.com&ampshare=https%3A%2F%2Fwww.instructables.com%2F4-digit-7-segment-Led-Clock-With-Manual-Adjust-Ala%2F

Am o problema cu modulul RTC DS1307 in sensul ca afiseaza o ora, dupa care nu se mai schimba nimic. Temperatura si umiditatea sunt afisate corect.

Schita folosita este

 /*
 base sketch: https://cdn.sparkfun.com/datasheets/Components/LED/_7Seg_Example.pde
  4 digit 7 segment display: http://www.sparkfun.com/products/9483 
 7 segments + 4 digits + 1 colon = 12 pins required for full control 
modified connexion by Nicu FLORICA (niq_ro) from http://nicuflorica.blogspot.com
http://arduinotehniq.blogspot.com
http://www.tehnic.go.ro
http://www.arduinotehniq.com/
ver.4.5 - change for manual adjust for hours and minutes, thermometer and higrometer: 11.08.2017, Craiova
ver.4.6 - show the alarm time when push + button
*/

int digit1 = 11; //PWM pin for control digit 1 (left side)
int digit2 = 10; //PWM pin for control digit 2
int digit3 = 9;  //PWM pin for control digit 3
int digit4 = 6;  //PWM pin for control digit 4 (right side)

int segA = 2; // pin for control "a" segment
int segB = 3; // pin for control "b" segment
int segC = 4; // pin for control "c" segment
int segD = 5; // pin for control "d" segment
int segE = 12; // pin for control e" segment
int segF = 7; // pin for control "f" segment
int segG = 8; // pin for control "g" segment
int segDP = 13; // pin for control decimal point

#include "EEPROM.h"// http://tronixstuff.com/2011/03/16/tutorial-your-arduinos-inbuilt-eeprom/

#include <Wire.h>
#include "RTClib.h"
RTC_DS1307 RTC;

// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
// original sketck from http://learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit/
// add part with SQW=1Hz from http://tronixstuff.wordpress.com/2010/10/20/tutorial-arduino-and-the-i2c-bus/
// add part with manual adjust http://www.bristolwatch.com/arduino/arduino_ds1307.htm
// original for common anode http://arduinotehniq.blogspot.ro/2014/09/manual-adjust-for-rtc-clock-with.html
// changed for common catode in 7.2.2017

#include "DHT.h"
#define DHTPIN A3     // pin for connect data's sensor
#define DHTTYPE DHT11   // DHT 11 
DHT dht(DHTPIN, DHTTYPE);

#define SW0 A0   // pin for MENU/change  (A0---SW0---GND)
#define SW1 1   // pin for increase value + (D1---SW1--GND)
#define sound A2 // pin for control alarma (+5V---BUZZER---GND)
#define LDR A1  // pin for photoresistor (+5V---LDR---A1--10k---GND)

/*
// use for hexa in zecimal conversion
int zh, uh, ore;
int zm, um, miniti;
*/

int DISPLAY_BRIGHTNESS = 5;
//Display brightness
//Each digit is on for a certain amount of microseconds
//Then it is off until we have reached a total of 20ms for the function call
//Let's assume each digit is on for 1000us
//Each digit is on for 1ms, there are 4 digits, so the display is off for 16ms.
//That's a ratio of 1ms to 16ms or 6.25% on time (PWM).
//Let's define a variable called brightness that varies from:
//5000 blindingly bright (15.7mA current draw per digit)
//2000 shockingly bright (11.4mA current draw per digit)
//1000 pretty bright (5.9mA)
//500 normal (3mA)
//200 dim but readable (1.4mA)
//50 dim but readable (0.56mA)
//5 dim but readable (0.31mA)
//1 dim but readable in dark (0.28mA)
/*
//for common catode
#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
#define SEGMENT_ON  LOW
#define SEGMENT_OFF HIGH
*/
// for common anode
#define DIGIT_ON  LOW
#define DIGIT_OFF  HIGH
#define SEGMENT_ON  HIGH
#define SEGMENT_OFF LOW

byte bucla = 30;
int t, h;
int timp; 
byte meniu = 0;   // 0 = usual state (clack, thetmometer & higrometer)
                  // 1 - adjust hour
                  // 2 - adjust minutes
                  // 3 - adjust year
                  // 4 - adjust month
                  // 5 - adjust day
                  // 6 - activate /deactivate alarm
                  // 7 - adjust hour for alarm
                  // 8 - adjust minutes for alarm
                  // 9 - store data
byte minutes = 0;
byte hours = 0;
int years = 0;
byte months = 0;
byte days = 0;
byte maxday = 0;

byte alarma = 0;
// use for hexa in zecimal conversion
int zha, uha, orea;
int zma, uma, minitia;
byte minutesa = 0;
byte hoursa = 0;
byte activarealarma = 0;
byte oprirealarma = 0;
unsigned long ultimaapasare = 0;

int maxbright = 1030; // 10230+7
int lene = 0;
int cicluri = 125; // if maxbright ~1000, cicluri = 125, if maxbright ~500 cicluri = 250;
byte arataalarma = 0;  // if is 1 show time alarm in normal mode
byte modificat = 0;  // if is 1 store new data 

void setup() {
  
 //  Serial.begin(57600);
  Wire.begin();
  RTC.begin();
// RTC.adjust(DateTime(__DATE__, __TIME__));
// if you need set clock... just remove // from line above this
// This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    // RTC.adjust(DateTime(2014, 1, 21, 3, 0, 0));


// part code for flashing LED
Wire.beginTransmission(0x68);
Wire.write(0x07); // move pointer to SQW address
// Wire.write(0x00); // turns the SQW pin off
 Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave at 1Hz
// Wire.write(0x13); // sends 0x13 (hex) 00010011 (binary) 32kHz

Wire.endTransmission();

  if (! RTC.isrunning()) {
    // following line sets the RTC to the date & time this sketch was compiled
    RTC.adjust(DateTime(__DATE__, __TIME__));
  }
  
 dht.begin();

  pinMode(segA, OUTPUT);
  pinMode(segB, OUTPUT);
  pinMode(segC, OUTPUT);
  pinMode(segD, OUTPUT);
  pinMode(segE, OUTPUT);
  pinMode(segF, OUTPUT);
  pinMode(segG, OUTPUT);
  pinMode(segDP, OUTPUT);

  pinMode(digit1, OUTPUT);
  pinMode(digit2, OUTPUT);
  pinMode(digit3, OUTPUT);
  pinMode(digit4, OUTPUT);

 Serial.begin(9600);
 Serial.println("test for niq_ro");

 pinMode(SW0, INPUT);  // for this use a slide switch
 pinMode(SW1, INPUT);  // N.O. push button switch
  digitalWrite(SW0, HIGH); // pull-ups on
  digitalWrite(SW1, HIGH);

pinMode(LDR, INPUT); // for photoresistor

pinMode(sound, OUTPUT); // control buzzer 
digitalWrite(sound, HIGH);
delay(200);
digitalWrite(sound, LOW);

alarma = EEPROM.read(100);
hoursa = EEPROM.read(101);
minutesa = EEPROM.read(102);

}

void loop() {

if (meniu == 0)
{  
digitalWrite(segDP, SEGMENT_OFF);
  DateTime now = RTC.now();
  //  timp = now.hour()*100+now.minute();
  hours = now.hour();
  minutes = now.minute();
  timp = hours*100+minutes;
  years = now.year();
  months = now.month();
  days = now.day();

if ((minutes == minutesa) && (hours == hoursa))
{
  activarealarma = 1;
}
else activarealarma = 0;

if ((millis() - ultimaapasare) > 65000) // reactivate alarm for next day
{
  oprirealarma = 0;
}

for (byte ceasu = 0; ceasu < 5; ceasu++)
{
DISPLAY_BRIGHTNESS = analogRead(LDR);
//  if ((activarealarma == 1) && (alarma%2 == 1))
if ((activarealarma == 1) && (alarma%2 == 1) && (oprirealarma == 0))
  {
  digitalWrite(sound, HIGH);  
  }
  else
  digitalWrite(sound, LOW);

DISPLAY_BRIGHTNESS = analogRead(LDR);
// display parts   
   for(int i = cicluri ; i >0  ; i--) {
     if (timp >= 1000) displayNumber01(timp); 
     else displayNumber02(timp); 
   } 
 if (!(digitalRead(SW0)))
  {
    meniu = 1; //go to menu for change hour
  }
  if (!(digitalRead(SW1)))
  {
    oprirealarma = 1; // mute the alarm
    ultimaapasare = millis();  // store push time for mute alarm
    arataalarma = 1;
  }   
  digitalWrite(sound, LOW);
   for(int i = cicluri ; i >0  ; i--) {
     if (timp >= 1000) displayNumber03(timp); 
     else displayNumber04(timp); 
   } 
  if (!(digitalRead(SW0)))
  {
    meniu = 1; //go to menu for change hour
  }
  if (!(digitalRead(SW1)))
  {
    oprirealarma = 1; // mute the alarm
    ultimaapasare = millis();  // store push time for mute alarm
    arataalarma = 1;
  }
}

// date (day and month)
for (byte ceasu = 0; ceasu < 2; ceasu++)
{ 
   DISPLAY_BRIGHTNESS = analogRead(LDR); 
//  if ((activarealarma == 1) && (alarma%2 == 1))
if ((activarealarma == 1) && (alarma%2 == 1) && (oprirealarma == 0))
  {
  digitalWrite(sound, HIGH);  
  }
  else
  digitalWrite(sound, LOW);
  
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber01(days*100+months); // this is number to diplay
   }
  digitalWrite(sound, LOW);
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber01(days*100+months); // this is number to diplay
   }

 if (!(digitalRead(SW0)))
  {
    meniu = 1; //go to menu for change hour
    delay(1000);
  }
  if (!(digitalRead(SW1)))
  {
    oprirealarma = 1; // mute the alarm
    ultimaapasare = millis();  // store push time for mute alarm
    arataalarma = 1;
  }
}  

// year
for (byte ceasu = 0; ceasu < 2; ceasu++)
{  
  DISPLAY_BRIGHTNESS = analogRead(LDR);
//  if ((activarealarma == 1) && (alarma%2 == 1))
if ((activarealarma == 1) && (alarma%2 == 1) && (oprirealarma == 0))
  {
  digitalWrite(sound, HIGH);  
  }
  else
  digitalWrite(sound, LOW);
  
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber03(years); // this is number to diplay
   }
  digitalWrite(sound, LOW);
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber03(years); // this is number to diplay
   }

 if (!(digitalRead(SW0)))
  {
    meniu = 1; //go to menu for change hour
    delay(1000);
  }
  if (!(digitalRead(SW1)))
  {
    oprirealarma = 1; // mute the alarm
    ultimaapasare = millis();  // store push time for mute alarm
    arataalarma = 1;
  }
}  


if (bucla > 20)
{
  h = dht.readHumidity();
  t = dht.readTemperature();
  bucla = 0;
}
for (byte ceasu = 0; ceasu < 2; ceasu++)
{
  DISPLAY_BRIGHTNESS = analogRead(LDR);
// if ((activarealarma == 1) && (alarma%2 == 1))
if ((activarealarma == 1) && (alarma%2 == 1) && (oprirealarma == 0))
  {
  digitalWrite(sound, HIGH);  
  }
  else
  digitalWrite(sound, LOW);
  
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber(t); // this is number to diplay
   }
   digitalWrite(sound, LOW);
  
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber(t); // this is number to diplay
   } 
  if (!(digitalRead(SW0)))
  {
    meniu = 1; //go to menu for change hour
  }
  if (!(digitalRead(SW1)))
  {
    oprirealarma = 1; // mute the alarm
    ultimaapasare = millis();  // store push time for mute alarm
    arataalarma = 1;
  }
}
for (byte ceasu = 0; ceasu < 2; ceasu++)
{  
  DISPLAY_BRIGHTNESS = analogRead(LDR);
//  if ((activarealarma == 1) && (alarma%2 == 1))
if ((activarealarma == 1) && (alarma%2 == 1) && (oprirealarma == 0))
  {
  digitalWrite(sound, HIGH);  
  }
  else
  digitalWrite(sound, LOW);
  
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber1(h); // this is number to diplay
   }
  digitalWrite(sound, LOW);
   for(int i = cicluri ; i >0  ; i--) {
     displayNumber1(h); // this is number to diplay
   }

 if (!(digitalRead(SW0)))
  {
    meniu = 1; //go to menu for change hour
    delay(1000);
  }
  if (!(digitalRead(SW1)))
  {
    oprirealarma = 1; // mute the alarm
    ultimaapasare = millis();  // store push time for mute alarm
    arataalarma = 1;
  }
}  

// show alarm time
if (arataalarma == 1)
{
 //  DISPLAY_BRIGHTNESS = analogRead(LDR); 
 //DISPLAY_BRIGHTNESS = maxbright; 
   for(int i = 6 ; i >0  ; i--) {
   for (byte b = 50; b > 0; b--)
   {
     displayNumber01(hoursa*100+minutesa); // this is number to diplay
   } 
     delay(150);
   }
  arataalarma = 0; 
}

bucla = bucla+1;
}  // end usual menu (display hour, temperature and humidity)

if (meniu == 1)
{
 if (!digitalRead(SW1)) // set hours ++
 { 
 hours++;   
  if (hours > 23) hours = 0;      
 delay(100);
 modificat = 1;
 }  
 
     for(int i = 20 ; i >0  ; i--) 
     {
  displayNumber20(hours); 
     }      
    delay(1);

 if (!(digitalRead(SW0)))
  {
    meniu = 2; //go to menu for change minute
    delay(1000);
  }
} // end menu for change hour

if (meniu == 2)
{
 if (!digitalRead(SW1)) // set minutes ++
 { 
 minutes++;      
 if (minutes > 59) minutes = 0;
 delay(100);
 modificat = 1;
 }  
     for(int i = 20 ; i >0  ; i--)
     {
    displayNumber21(minutes); 
     }      
    delay(1);

 if (!(digitalRead(SW0)))
  {
    meniu = 3; //go to menu for usual style
    delay(500);
  }
}  // end menu for change minutes


if (meniu == 3)
{
 if (!digitalRead(SW1)) // set years ++
 { 
 years++;      
 if (years > 2030) years = 2017;
 delay(100);
  modificat = 1;
 }  
     for(int i = 20 ; i >0  ; i--)
     {
    displayNumber41(years-2000); 
     }      
    delay(1);

 if (!(digitalRead(SW0)))
  {
    meniu = 4; //go to menu for usual style
    delay(500);
  }
}  // end menu for change years

if (meniu == 4)
{
 if (!digitalRead(SW1)) // set months ++
 { 
 months++;      
 if (months > 12) months = 1;
 delay(100);
 modificat = 1;
 }  
     for(int i = 20 ; i >0  ; i--)
     {
    displayNumber42(months); 
     }      
    delay(1);

 if (!(digitalRead(SW0)))
  {
    meniu = 5; //go to menu for usual style
    delay(500);
  }
}  // end menu for change months


if (meniu == 5)
{
 if (!digitalRead(SW1)) // set days ++
 { 
 days++;      
 if (months == 4 || months == 6 || months == 9 || months == 11) { //30 days hath September, April June and November
    maxday = 30;
  }
  else {
  maxday = 31; //... all the others have 31
  }
  if (months ==2 && years % 4 ==0) { //... Except February alone, and that has 28 days clear, and 29 in a leap year.
    maxday = 29;
  }
  if (months ==2 && years % 4 !=0) {
    maxday = 28;
  }
 if (days > maxday) days = 1; 
 delay(100);
 modificat = 1;
 }  
     for(int i = 20 ; i >0  ; i--)
     {
    displayNumber43(days); 
     }      
    delay(1);

 if (!(digitalRead(SW0)))
  {
    meniu = 6; //go to menu for usual style
    delay(500);
  }
}  // end menu for change days


if (meniu == 6)
{
 if (!digitalRead(SW1)) // set minutes ++
 { 
 alarma++;       
 delay(200);
 }  

    for(int i = 20 ; i >0  ; i--)
    {
    if (alarma%2 == 1) displayNumber32(); 
    else displayNumber33();
     }
          
    delay(1);

 if (!(digitalRead(SW0)))
  {
    if (alarma%2 == 1) meniu = 7; //go to menu for set alarm
    else meniu = 9;
    delay(500);
  }
}  // end menu for activate or deactivate alarm

if (meniu == 7)
{
 if (!digitalRead(SW1)) // set hours ++
 { 
 hoursa++;       
 if (hoursa > 23) hoursa = 0;   
 delay(100);
 }  
  
  for(int i = 20 ; i >0  ; i--)
  {
  displayNumber30(hoursa); 
  }      
    delay(1);

 if (!(digitalRead(SW0)))
  {
    meniu = 8; //go to menu for change minute
    delay(1000);
  }
} // end menu for change hour alarm

if (meniu == 8)
{
 if (!digitalRead(SW1)) // set minutes ++
 { 
 minutesa++;       
 if (minutesa > 59) minutesa = 0;
 delay(100);
 }  
    for(int i = 20 ; i >0  ; i--) 
    {
    displayNumber31(minutesa); 
     }      
    delay(1);

 if (!(digitalRead(SW0)))
  {
    meniu = 9; //go to menu for usual style
    delay(500);
  }
}  // end menu for change minutes alarm


if (meniu == 9)  // store data in RTC
{
 // date and hours
 if (modificat == 1)
 {
RTC.adjust(DateTime(years, months, days, hours, minutes, 0));  
 modificat = 0;
 }
 // alarm time and mode
EEPROM.write(100,alarma%2);  
EEPROM.write(101,hoursa);  
EEPROM.write(102,minutesa);  

 delay(500);
 meniu = 0; 
}


} // end main program


//Given a number, turns on those segments
//If number == 10, then turn off number
void lightNumber(int numberToDisplay) {
  switch (numberToDisplay){

  case 0:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_OFF);
    break;

  case 1:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_OFF);
    break;

  case 2:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 3:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 4:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 5:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 6:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 7:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_OFF);
    break;

  case 8:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  case 9:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  // all segment are ON
  case 10:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_OFF);
    break;

    // degree symbol made by niq_ro
  case 11:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  // C letter made by niq_ro
  case 12:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_OFF);
    break;
  
  // H letter made by niq_ro
  case 13:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;
 
  // L letter made by niq_ro
  case 14:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_OFF);
    break;

  // A letter made by niq_ro
  case 15:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;
  
    // F letter made by niq_ro
  case 16:
    digitalWrite(segA, SEGMENT_ON);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;
    
  // n letter made by niq_ro
  case 17:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;

    // o letter made by niq_ro
  case 18:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;
 
 // "Y" letter made by niq_ro
  case 19:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_OFF);
    digitalWrite(segF, SEGMENT_ON);
    digitalWrite(segG, SEGMENT_ON);
    break;

  // "r" letter made by niq_ro
  case 20:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_OFF);
    digitalWrite(segC, SEGMENT_OFF);
    digitalWrite(segD, SEGMENT_OFF);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;

  // "d" letter made by niq_ro
  case 21:
    digitalWrite(segA, SEGMENT_OFF);
    digitalWrite(segB, SEGMENT_ON);
    digitalWrite(segC, SEGMENT_ON);
    digitalWrite(segD, SEGMENT_ON);
    digitalWrite(segE, SEGMENT_ON);
    digitalWrite(segF, SEGMENT_OFF);
    digitalWrite(segG, SEGMENT_ON);
    break;
 }
}

// display clock with second on
void displayNumber01(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
     digitalWrite(digit1, DIGIT_ON);
     digitalWrite(segDP, SEGMENT_OFF);
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      digitalWrite(segDP, SEGMENT_ON);
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      digitalWrite(segDP, SEGMENT_OFF);    
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
       if (alarma%2 == 1) digitalWrite(segDP, SEGMENT_ON);
    else digitalWrite(segDP, SEGMENT_OFF);
      break;
    }
    lightNumber(toDisplay % 10);
    toDisplay /= 10;
    delayMicroseconds(DISPLAY_BRIGHTNESS); 

     //Turn off all segments
    lightNumber(10); 
    digitalWrite(segDP, SEGMENT_OFF);
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// dsplay clock wih small hour (8:31) with second on
void displayNumber02(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
     lightNumber(10); 
     digitalWrite(segDP, SEGMENT_OFF);
     break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      digitalWrite(segDP, SEGMENT_ON);
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      digitalWrite(segDP, SEGMENT_OFF);
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      if (alarma%2 == 1) digitalWrite(segDP, SEGMENT_ON);
    else digitalWrite(segDP, SEGMENT_OFF);
      break;
    }
    lightNumber(toDisplay % 10);
    toDisplay /= 10;
    delayMicroseconds(DISPLAY_BRIGHTNESS); 

     //Turn off all segments
    lightNumber(10); 
    digitalWrite(segDP, SEGMENT_OFF);
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// display clock with second off
void displayNumber03(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
     digitalWrite(digit1, DIGIT_ON);
        digitalWrite(segDP, SEGMENT_OFF);
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
    digitalWrite(segDP, SEGMENT_OFF);
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
   digitalWrite(segDP, SEGMENT_OFF);
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      if (alarma%2 == 1) digitalWrite(segDP, SEGMENT_ON);
    else digitalWrite(segDP, SEGMENT_OFF);
      break;
    }
    lightNumber(toDisplay % 10);
    toDisplay /= 10;
    delayMicroseconds(DISPLAY_BRIGHTNESS); 

     //Turn off all segments
    lightNumber(10); 
    digitalWrite(segDP, SEGMENT_OFF);
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// display clock for small hour (8:31) with second off
void displayNumber04(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
     lightNumber(10); 
     digitalWrite(segDP, SEGMENT_OFF);
     break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
    digitalWrite(segDP, SEGMENT_OFF);  
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
 digitalWrite(segDP, SEGMENT_OFF);
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      if (alarma%2 == 1) digitalWrite(segDP, SEGMENT_ON);
    else digitalWrite(segDP, SEGMENT_OFF);
      break;
    }
    lightNumber(toDisplay % 10);
    toDisplay /= 10;
    delayMicroseconds(DISPLAY_BRIGHTNESS); 
    digitalWrite(segDP, SEGMENT_OFF);

     //Turn off all segments
    lightNumber(10); 
    digitalWrite(segDP, SEGMENT_OFF);
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// display temperature
void displayNumber(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {
    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(11); // display degree symbol
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(12); // display C letter
      if (alarma%2 == 1) digitalWrite(segDP, SEGMENT_ON);
    else digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
    digitalWrite(segDP, SEGMENT_OFF);
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// display humidity
void displayNumber1(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(10); // display off
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(13); // display H letter
      if (alarma%2 == 1) digitalWrite(segDP, SEGMENT_ON);
      else digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
    digitalWrite(segDP, SEGMENT_OFF);
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// hour clock adjust
void displayNumber20(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(12);   // C letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(14);   // L letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 


// minute clock adjust
void displayNumber21(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(12);   // C letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(14);   // L letter 
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// hour alarm adjust
void displayNumber30(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(15);   // A letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(14);   // L letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 


// minute alarm adjust
void displayNumber31(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(15);   // A letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(14);   // L letter 
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// alarm on
void displayNumber32() {
  for(int digit = 4 ; digit > 0 ; digit--) {
    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(15);   // A letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(14);   // L letter 
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(18);   // o letter
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(17);   // n letter
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
    lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// alarm off
void displayNumber33() {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(15);   // A letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(14);   // L letter 
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(18);   // o letter
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(16);   // F letter
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// year adjust
void displayNumber41(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(19);   // Y letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(20);   // r letter 
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
     lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 

    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// month adjust
void displayNumber42(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(13);   // H letter (instead M)
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(18);   // o letter 
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
     //Turn off all segments
    lightNumber(10); 
    lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 
    
    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

// day adjust
void displayNumber43(int toDisplay) {
  for(int digit = 4 ; digit > 0 ; digit--) {

    //Turn on a digit for a short amount of time
    switch(digit) {
    case 1:
      digitalWrite(digit1, DIGIT_ON);
      lightNumber(21);   // d letter 
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
   case 2:
      digitalWrite(digit2, DIGIT_ON);
      lightNumber(19);   // Y letter 
      digitalWrite(segDP, SEGMENT_ON);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 3:
      digitalWrite(digit3, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    case 4:
      digitalWrite(digit4, DIGIT_ON);
      lightNumber(toDisplay % 10);
      toDisplay /= 10;
      digitalWrite(segDP, SEGMENT_OFF);
      delayMicroseconds(DISPLAY_BRIGHTNESS); 
      break;
    }
   
     //Turn off all segments
    lightNumber(10); 
    lene = maxbright - DISPLAY_BRIGHTNESS;
    delayMicroseconds(lene); 
    
    //Turn off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2, DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4, DIGIT_OFF);
    digitalWrite(segDP, SEGMENT_OFF);
}
} 

 

Am verificat modulu RTC si functioneaza. Schita folosita

#include "Arduino.h"
#include "uRTCLib.h"

// uRTCLib rtc;
uRTCLib rtc(0x68);

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup() {
  Serial.begin(9600);
  delay(3000); // wait for console opening

  URTCLIB_WIRE.begin();

  // Comment out below line once you set the date & time.
  // Following line sets the RTC with an explicit date & time
  // for example to set January 13 2022 at 12:56 you would call:
   rtc.set(0, 56, 12, 5, 13, 1, 22);
  // rtc.set(second, minute, hour, dayOfWeek, dayOfMonth, month, year)
  // set day of week (1=Sunday, 7=Saturday)
}

void loop() {
  rtc.refresh();

  Serial.print("Current Date & Time: ");
  Serial.print(rtc.year());
  Serial.print('/');
  Serial.print(rtc.month());
  Serial.print('/');
  Serial.print(rtc.day());

  Serial.print(" (");
  Serial.print(daysOfTheWeek[rtc.dayOfWeek()-1]);
   Serial.print(") ");

  Serial.print(rtc.hour());
  Serial.print(':');
  Serial.print(rtc.minute());
  Serial.print(':');
  Serial.println(rtc.second());
  
  delay(1000);
}

Se pare ca cele 2 schite nu folosec aceleasi biblioteci pt modulul RTC. Am incercat sa modific schita initiala dupa biblioteca din schita de test, dar au aparut erori de compilare.

Ce ar trebui sa modific?

[daniels]

Schema nu are led conectat la RTC

[ionutz2013]

Temperatura aia masurata e cea din camera? Pare cam ridicata 

[validae]

Dacă nu are casa sau apartamentul izolate, e o temperatură destul de normală când afară sunt 30-32* și soarele bate în geamuri și pereți....

[daniels]

Acum 6 ore, antemir a spus:

Incearca cu un test simplu cu libraria din primul code (RTClib).
RTC va porni mereu cu data/ora la care ai compilat. Dar trebuie sa afiseze incrementarea la secunda.
 

#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 RTC;

void setup() 
{
  Serial.begin(9600);
  
  Wire.begin();
  RTC.begin();
  
  RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
}

void loop() 
{
  DateTime now = RTC.now();
  Serial.print("Data: ");  
  Serial.print(now.day(), DEC);
  Serial.print('/');
  Serial.print(now.month(), DEC);
  Serial.print('/');
  Serial.print(now.year(), DEC);
  Serial.print("   Ora: ");
  Serial.print(now.hour(), DEC);
  Serial.print(':');
  Serial.print(now.minute(), DEC);
  Serial.print(':');
  Serial.print(now.second(), DEC);
  Serial.println();
  delay(1000); 
}

 

Am facut testul si merge, se sincronizeaza cu ora si data calculatorului

 

[ionutz2013]

Acum 17 minute, validae a spus:

Dacă nu are casa sau apartamentul izolate, e o temperatură destul de normală când afară sunt 30-32* și soarele bate în geamuri și pereți....

Interesant proiectul asta.  Displayul care il contruiesc eu are lipsa un segment. Cel de sus de la primul digit. Nu ar afisa bine ora 00:00. Doar daca afisaza 0:00 ar merge pe afisajul ala. Si bineinteles temperatura pana la 39° cea ce la mine nu ar exista niciodata. M-ar lua ameteala garantat la temperatura aia in casa.

[daniels]

Acum 8 minute, ionutz2013 a spus:

Doar daca afisaza 0:00

Asa afiseaza

[ionutz2013]

E bun atunci. Schema pt display common anode m-ar interesa. 

[daniels]

Cred ca merge asa cum e acuma, daca nu comentezi sau de-comentezi segventa asta de cod.

/*
//for common catode
#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
#define SEGMENT_ON  LOW
#define SEGMENT_OFF HIGH
*/
// for common anode
#define DIGIT_ON  LOW
#define DIGIT_OFF  HIGH
#define SEGMENT_ON  HIGH
#define SEGMENT_OFF LOW

la mine e cu anod comun si a trebuit sa de-comentez catod comun si sa comentez anod comun

[daniels]

Da, ai dreptate, nu se misca nimic. 

Nu cred ca functioneaza cu bibliotecile alea.

[daniels]

Am sa reiau testul,acuma nu mai sunt sigur de nimic.

[daniels]

Am refacut testul, se comporta la fel.

[ionutz2013]

Incearca cu asta:  sunt curios daca merge. Eu nu mai gasesc modulele RTC. am comandat altele si mai am de asteptat pana vin.

 

[daniels]

Nu pot face schema de mai sus pt ca afisajul e cu interfata seriala si nu am.

Module RTC se gasesc vin in cateva zile

https://ardushop.ro/ro/home/113-module-tiny-rtc-i2c-external-clock-ds1307.html

 

https://ardushop.ro/ro/electronica/231-modul-rtc-de-precizie-ds3231-i2c.html

[ionutz2013]

Mda... 40 lei total. Costa mai mult transportu decat acel modul. Pe aliexpress le-am cumparat cu 10 lei cu tot cu transport inclusiv acea interfata serial pt schema fe mai sus. Acum ramane de vazut daca o sa si functioneze. Sa inteleg ca ai facut ceva in genul la ce am experimentat eu in poza? Eu am folosit o schema fara RTC si ramanea in urma rau.

Editat Iunie 27, 2023 de ionutz2013