API tools faq
paste
Advertisement
Guest User

relogio com botao para mudar horario

a guest
Oct 28th, 2016
121
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 13.19 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  4 digit 7 segment display: http://www.sparkfun.com/products/9483
  3.  Datasheet: http://www.sparkfun.com/datasheets/Components/LED/7-Segment/YSD-439AR6B-35.pdf
  4.  7 segments + 4 digits + 1 colon = 12 pins required for full control
  5.  */
  6. // modified connexion by niq_ro from http://nicuflorica.blogspot.com
  7. // for my Luckylight KW4-563ASA
  8. // dataseet: http://www.tme.eu/ro/Document/dfc2efde2e22005fd28615e298ea2655/KW4-563XSA.pdf
  9.  
  10. int digit1 = 11; //PWM Display pin 12 (digit1 is common anonds A1 from right side)
  11. int digit2 = 10; //PWM Display pin 9 (digit2 is  common A2)
  12. int digit3 = 9; //PWM Display pin 8 (digit3 is common anods A3)
  13. int digit4 = 6; //PWM Display pin 6 (digit4 is common anods, from left side)
  14.  
  15. //Pin mapping from Arduino to the ATmega DIP28 if you need it
  16. //http://www.arduino.cc/en/Hacking/PinMapping
  17. int segA = 2; //Display pin 11
  18. int segB = 3; //Display pin 7
  19. int segC = 4; //Display pin 4
  20. int segD = 5; //Display pin 2
  21. int segE = 12; //Display pin 1
  22. int segF = 7; //Display pin 10
  23. int segG = 8; //Display pin 5
  24. int segDP = 13; // Display pin 3
  25.  
  26. #include <Wire.h>
  27. #include "RTClib.h"
  28. RTC_DS1307 RTC;
  29.  
  30. // Date and time functions using a DS1307 RTC connected via I2C and Wire lib
  31. // original sketck from http://learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit/
  32. // add part with SQW=1Hz from http://tronixstuff.wordpress.com/2010/10/20/tutorial-arduino-and-the-i2c-bus/
  33. // add part with manual adjust http://www.bristolwatch.com/arduino/arduino_ds1307.htm
  34.  
  35.  
  36.  
  37.  
  38.  
  39. byte SW0 = A0;
  40. byte SW1 = A1;
  41. byte SW2 = A2;
  42.  
  43. // use for hexa in zecimal conversion
  44. int zh, uh, ore;
  45. int zm, um, miniti;
  46.  
  47. void setup() {
  48.  
  49.  //  Serial.begin(57600);
  50.   Wire.begin();
  51.   RTC.begin();
  52. // RTC.adjust(DateTime(__DATE__, __TIME__));
  53. // if you need set clock... just remove // from line above this
  54.  
  55. // part code for flashing LED
  56. Wire.beginTransmission(0x68);
  57. Wire.write(0x07); // move pointer to SQW address
  58. // Wire.write(0x00); // turns the SQW pin off
  59.  Wire.write(0x10); // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave at 1Hz
  60. // Wire.write(0x13); // sends 0x13 (hex) 00010011 (binary) 32kHz
  61.  
  62. Wire.endTransmission();
  63.  
  64.   if (! RTC.isrunning()) {
  65.     Serial.println("RTC is NOT running!");
  66.     // following line sets the RTC to the date & time this sketch was compiled
  67.     RTC.adjust(DateTime(__DATE__, __TIME__));
  68.   }
  69.  
  70.  
  71. // dht.begin();
  72.  
  73.   pinMode(segA, OUTPUT);
  74.   pinMode(segB, OUTPUT);
  75.   pinMode(segC, OUTPUT);
  76.   pinMode(segD, OUTPUT);
  77.   pinMode(segE, OUTPUT);
  78.   pinMode(segF, OUTPUT);
  79.   pinMode(segG, OUTPUT);
  80.   pinMode(segDP, OUTPUT);
  81.  
  82.   pinMode(digit1, OUTPUT);
  83.   pinMode(digit2, OUTPUT);
  84.   pinMode(digit3, OUTPUT);
  85.   pinMode(digit4, OUTPUT);
  86.  
  87. //  pinMode(13, OUTPUT);
  88.  
  89.  Serial.begin(9600);
  90.  Serial.println("test for niq_ro");
  91.  
  92.  pinMode(SW0, INPUT);  // for this use a slide switch
  93.   pinMode(SW1, INPUT);  // N.O. push button switch
  94.   pinMode(SW2, INPUT);  // N.O. push button switch
  95.  
  96.   digitalWrite(SW0, HIGH); // pull-ups on
  97.   digitalWrite(SW1, HIGH);
  98.   digitalWrite(SW2, HIGH);
  99.  
  100.  
  101.  
  102. }
  103.  
  104. void loop() {
  105. digitalWrite(segDP, HIGH);
  106.   DateTime now = RTC.now();
  107.   int timp = now.hour()*100+now.minute();
  108. //   int timp = (now.minute(), DEC);
  109. //   displayNumber(12); // this is number to diplay
  110. //   int timp = 1234;
  111.   Serial.print(now.hour(), DEC);
  112.   Serial.print(":");
  113.   Serial.print(now.minute(), DEC);
  114.   Serial.print(" -> ");
  115.   Serial.print(timp);
  116.   Serial.println(" !");
  117.  
  118. // display parts  
  119.    for(int i = 250 ; i >0  ; i--) {
  120.      if (timp >= 1000) displayNumber01(timp);
  121.      else displayNumber02(timp);
  122.    }
  123.  
  124.    for(int i = 250 ; i >0  ; i--) {
  125.      if (timp >= 1000) displayNumber03(timp);
  126.      else displayNumber04(timp);
  127.    }
  128.  
  129.   if (!(digitalRead(SW0))) set_time(); // hold the switch to set time
  130. }
  131.  
  132.  
  133. void set_time()   {
  134.   byte minutes1 = 0;
  135.   byte hours1 = 0;
  136.   byte minutes = 0;
  137.   byte hours = 0;
  138.  
  139.   while (!digitalRead(SW0))  // set time switch must be released to exit
  140.   {
  141.     minutes1=minutes;
  142.     hours1=hours;
  143.    
  144.      
  145.     while (!digitalRead(SW1)) // set minutes
  146.     {
  147.      minutes++;  
  148.    // converting hexa in zecimal:
  149.     zh = hours / 16;
  150.     uh = hours - 16 * zh ;
  151.     ore = 10 * zh + uh;
  152.     zm = minutes / 16;
  153.     um = minutes - 16 * zm ;
  154.     miniti = 10 * zm + um;
  155.    
  156.      for(int i = 20 ; i >0  ; i--) {
  157.      displayNumber01(ore*100+miniti);
  158.      }
  159.  
  160.      
  161.       if ((minutes & 0x0f) > 9) minutes = minutes + 6;
  162.       if (minutes > 0x59) minutes = 0;
  163.       Serial.print("Minutes = ");
  164.       if (minutes >= 9) Serial.print("0");
  165.       Serial.println(minutes, HEX);
  166.     delay(150);    
  167.     }
  168.  
  169.     while (!digitalRead(SW2)) // set hours
  170.     {
  171.      hours++;          
  172.      
  173.    // converting hexa in zecimal:
  174.     zh = hours / 16;
  175.     uh = hours - 16 * zh ;
  176.     ore = 10 * zh + uh;
  177.     zm = minutes / 16;
  178.     um = minutes - 16 * zm ;
  179.     miniti = 10 * zm + um;
  180.    
  181.      for(int i = 20 ; i >0  ; i--) {
  182.      displayNumber01(ore*100+miniti);
  183.      }
  184.    
  185.      
  186.       if ((hours & 0x0f) > 9) hours =  hours + 6;
  187.       if (hours > 0x23) hours = 0;
  188.       Serial.print("Hours = ");
  189.       if (hours <= 9) Serial.print("0");
  190.       Serial.println(hours, HEX);
  191.     delay(150);
  192.     }
  193.  
  194.     Wire.beginTransmission(0x68); // activate DS1307
  195.     Wire.write(0); // where to begin
  196.     Wire.write(0x00);          //seconds
  197.     Wire.write(minutes);          //minutes
  198.     Wire.write(0x80 | hours);    //hours (24hr time)
  199.     Wire.write(0x06);  // Day 01-07
  200.     Wire.write(0x01);  // Date 0-31
  201.     Wire.write(0x05);  // month 0-12
  202.     Wire.write(0x09);  // Year 00-99
  203.     Wire.write(0x10); // Control 0x10 produces a 1 HZ square wave on pin 7.
  204.     Wire.endTransmission();
  205.  
  206.     // converting hexa in zecimal:
  207.     zh = hours / 16;
  208.     uh = hours - 16 * zh ;
  209.     ore = 10 * zh + uh;
  210.     zm = minutes / 16;
  211.     um = minutes - 16 * zm ;
  212.     miniti = 10 * zm + um;
  213.    
  214.      for(int i = 20 ; i >0  ; i--) {
  215.      displayNumber01(ore*100+miniti);
  216.      }
  217.  //  delay(150);
  218.    
  219.   }
  220.  
  221. }
  222.  
  223.  
  224.  
  225. void displayNumber01(int toDisplay) {
  226. #define DISPLAY_BRIGHTNESS  500
  227.  
  228. #define DIGIT_ON  HIGH
  229. #define DIGIT_OFF  LOW
  230.  
  231.   for(int digit = 4 ; digit > 0 ; digit--) {
  232.  
  233.     //Turn on a digit for a short amount of time
  234.     switch(digit) {
  235.     case 1:
  236.      digitalWrite(digit1, DIGIT_ON);
  237.      digitalWrite(segDP, HIGH);
  238.       break;
  239.    case 2:
  240.       digitalWrite(digit2, DIGIT_ON);
  241.       digitalWrite(segDP, LOW);
  242.       break;
  243.     case 3:
  244.       digitalWrite(digit3, DIGIT_ON);
  245.       digitalWrite(segDP, HIGH);
  246.       break;
  247.     case 4:
  248.       digitalWrite(digit4, DIGIT_ON);
  249.       digitalWrite(segDP, HIGH);
  250.       break;
  251.     }
  252.     lightNumber(toDisplay % 10);
  253.     toDisplay /= 10;
  254.     delayMicroseconds(DISPLAY_BRIGHTNESS);
  255.  
  256.      //Turn off all segments
  257.     lightNumber(10);
  258.  
  259.     //Turn off all digits
  260.     digitalWrite(digit1, DIGIT_OFF);
  261.     digitalWrite(digit2, DIGIT_OFF);
  262.     digitalWrite(digit3, DIGIT_OFF);
  263.     digitalWrite(digit4, DIGIT_OFF);
  264. }
  265. }
  266.  
  267. void displayNumber02(int toDisplay) {
  268. #define DISPLAY_BRIGHTNESS  500
  269.  
  270. #define DIGIT_ON  HIGH
  271. #define DIGIT_OFF  LOW
  272.  
  273.   for(int digit = 4 ; digit > 0 ; digit--) {
  274.  
  275.     //Turn on a digit for a short amount of time
  276.     switch(digit) {
  277.     case 1:
  278.      lightNumber(10);
  279.      digitalWrite(segDP, HIGH);
  280.      break;
  281.    case 2:
  282.       digitalWrite(digit2, DIGIT_ON);
  283.       digitalWrite(segDP, LOW);
  284.       break;
  285.     case 3:
  286.       digitalWrite(digit3, DIGIT_ON);
  287.       digitalWrite(segDP, HIGH);
  288.       break;
  289.     case 4:
  290.       digitalWrite(digit4, DIGIT_ON);
  291.       digitalWrite(segDP, HIGH);
  292.       break;
  293.     }
  294.     lightNumber(toDisplay % 10);
  295.     toDisplay /= 10;
  296.     delayMicroseconds(DISPLAY_BRIGHTNESS);
  297.  
  298.      //Turn off all segments
  299.     lightNumber(10);
  300.  
  301.     //Turn off all digits
  302.     digitalWrite(digit1, DIGIT_OFF);
  303.     digitalWrite(digit2, DIGIT_OFF);
  304.     digitalWrite(digit3, DIGIT_OFF);
  305.     digitalWrite(digit4, DIGIT_OFF);
  306. }
  307. }
  308.  
  309. void displayNumber03(int toDisplay) {
  310. #define DISPLAY_BRIGHTNESS  500
  311.  
  312. #define DIGIT_ON  HIGH
  313. #define DIGIT_OFF  LOW
  314.  
  315.   for(int digit = 4 ; digit > 0 ; digit--) {
  316.  
  317.     //Turn on a digit for a short amount of time
  318.     switch(digit) {
  319.     case 1:
  320.      digitalWrite(digit1, DIGIT_ON);
  321.      digitalWrite(segDP, HIGH);
  322.       break;
  323.    case 2:
  324.       digitalWrite(digit2, DIGIT_ON);
  325.       digitalWrite(segDP, HIGH);
  326.       break;
  327.     case 3:
  328.       digitalWrite(digit3, DIGIT_ON);
  329.       digitalWrite(segDP, HIGH);
  330.       break;
  331.     case 4:
  332.       digitalWrite(digit4, DIGIT_ON);
  333.       digitalWrite(segDP, HIGH);
  334.       break;
  335.     }
  336.     lightNumber(toDisplay % 10);
  337.     toDisplay /= 10;
  338.     delayMicroseconds(DISPLAY_BRIGHTNESS);
  339.  
  340.      //Turn off all segments
  341.     lightNumber(10);
  342.  
  343.     //Turn off all digits
  344.     digitalWrite(digit1, DIGIT_OFF);
  345.     digitalWrite(digit2, DIGIT_OFF);
  346.     digitalWrite(digit3, DIGIT_OFF);
  347.     digitalWrite(digit4, DIGIT_OFF);
  348. }
  349. }
  350.  
  351. void displayNumber04(int toDisplay) {
  352. #define DISPLAY_BRIGHTNESS  500
  353.  
  354. #define DIGIT_ON  HIGH
  355. #define DIGIT_OFF  LOW
  356.  
  357.   for(int digit = 4 ; digit > 0 ; digit--) {
  358.  
  359.     //Turn on a digit for a short amount of time
  360.     switch(digit) {
  361.     case 1:
  362.      lightNumber(10);
  363.      digitalWrite(segDP, HIGH);
  364.      break;
  365.    case 2:
  366.       digitalWrite(digit2, DIGIT_ON);
  367.       digitalWrite(segDP, HIGH);
  368.       break;
  369.     case 3:
  370.       digitalWrite(digit3, DIGIT_ON);
  371.       digitalWrite(segDP, HIGH);
  372.       break;
  373.     case 4:
  374.       digitalWrite(digit4, DIGIT_ON);
  375.       digitalWrite(segDP, HIGH);
  376.       break;
  377.     }
  378.     lightNumber(toDisplay % 10);
  379.     toDisplay /= 10;
  380.     delayMicroseconds(DISPLAY_BRIGHTNESS);
  381.  
  382.      //Turn off all segments
  383.     lightNumber(10);
  384.  
  385.     //Turn off all digits
  386.     digitalWrite(digit1, DIGIT_OFF);
  387.     digitalWrite(digit2, DIGIT_OFF);
  388.     digitalWrite(digit3, DIGIT_OFF);
  389.     digitalWrite(digit4, DIGIT_OFF);
  390. }
  391. }
  392.  
  393.  
  394. //Given a number, turns on those segments
  395. //If number == 10, then turn off number
  396. void lightNumber(int numberToDisplay) {
  397.  
  398. #define SEGMENT_ON  LOW
  399. #define SEGMENT_OFF HIGH
  400.  
  401.   switch (numberToDisplay){
  402.  
  403.   case 0:
  404.     digitalWrite(segA, SEGMENT_ON);
  405.     digitalWrite(segB, SEGMENT_ON);
  406.     digitalWrite(segC, SEGMENT_ON);
  407.     digitalWrite(segD, SEGMENT_ON);
  408.     digitalWrite(segE, SEGMENT_ON);
  409.     digitalWrite(segF, SEGMENT_ON);
  410.     digitalWrite(segG, SEGMENT_OFF);
  411.     break;
  412.  
  413.   case 1:
  414.     digitalWrite(segA, SEGMENT_OFF);
  415.     digitalWrite(segB, SEGMENT_ON);
  416.     digitalWrite(segC, SEGMENT_ON);
  417.     digitalWrite(segD, SEGMENT_OFF);
  418.     digitalWrite(segE, SEGMENT_OFF);
  419.     digitalWrite(segF, SEGMENT_OFF);
  420.     digitalWrite(segG, SEGMENT_OFF);
  421.     break;
  422.  
  423.   case 2:
  424.     digitalWrite(segA, SEGMENT_ON);
  425.     digitalWrite(segB, SEGMENT_ON);
  426.     digitalWrite(segC, SEGMENT_OFF);
  427.     digitalWrite(segD, SEGMENT_ON);
  428.     digitalWrite(segE, SEGMENT_ON);
  429.     digitalWrite(segF, SEGMENT_OFF);
  430.     digitalWrite(segG, SEGMENT_ON);
  431.     break;
  432.  
  433.   case 3:
  434.     digitalWrite(segA, SEGMENT_ON);
  435.     digitalWrite(segB, SEGMENT_ON);
  436.     digitalWrite(segC, SEGMENT_ON);
  437.     digitalWrite(segD, SEGMENT_ON);
  438.     digitalWrite(segE, SEGMENT_OFF);
  439.     digitalWrite(segF, SEGMENT_OFF);
  440.     digitalWrite(segG, SEGMENT_ON);
  441.     break;
  442.  
  443.   case 4:
  444.     digitalWrite(segA, SEGMENT_OFF);
  445.     digitalWrite(segB, SEGMENT_ON);
  446.     digitalWrite(segC, SEGMENT_ON);
  447.     digitalWrite(segD, SEGMENT_OFF);
  448.     digitalWrite(segE, SEGMENT_OFF);
  449.     digitalWrite(segF, SEGMENT_ON);
  450.     digitalWrite(segG, SEGMENT_ON);
  451.     break;
  452.  
  453.   case 5:
  454.     digitalWrite(segA, SEGMENT_ON);
  455.     digitalWrite(segB, SEGMENT_OFF);
  456.     digitalWrite(segC, SEGMENT_ON);
  457.     digitalWrite(segD, SEGMENT_ON);
  458.     digitalWrite(segE, SEGMENT_OFF);
  459.     digitalWrite(segF, SEGMENT_ON);
  460.     digitalWrite(segG, SEGMENT_ON);
  461.     break;
  462.  
  463.   case 6:
  464.     digitalWrite(segA, SEGMENT_ON);
  465.     digitalWrite(segB, SEGMENT_OFF);
  466.     digitalWrite(segC, SEGMENT_ON);
  467.     digitalWrite(segD, SEGMENT_ON);
  468.     digitalWrite(segE, SEGMENT_ON);
  469.     digitalWrite(segF, SEGMENT_ON);
  470.     digitalWrite(segG, SEGMENT_ON);
  471.     break;
  472.  
  473.   case 7:
  474.     digitalWrite(segA, SEGMENT_ON);
  475.     digitalWrite(segB, SEGMENT_ON);
  476.     digitalWrite(segC, SEGMENT_ON);
  477.     digitalWrite(segD, SEGMENT_OFF);
  478.     digitalWrite(segE, SEGMENT_OFF);
  479.     digitalWrite(segF, SEGMENT_OFF);
  480.     digitalWrite(segG, SEGMENT_OFF);
  481.     break;
  482.  
  483.   case 8:
  484.     digitalWrite(segA, SEGMENT_ON);
  485.     digitalWrite(segB, SEGMENT_ON);
  486.     digitalWrite(segC, SEGMENT_ON);
  487.     digitalWrite(segD, SEGMENT_ON);
  488.     digitalWrite(segE, SEGMENT_ON);
  489.     digitalWrite(segF, SEGMENT_ON);
  490.     digitalWrite(segG, SEGMENT_ON);
  491.     break;
  492.  
  493.   case 9:
  494.     digitalWrite(segA, SEGMENT_ON);
  495.     digitalWrite(segB, SEGMENT_ON);
  496.     digitalWrite(segC, SEGMENT_ON);
  497.     digitalWrite(segD, SEGMENT_ON);
  498.     digitalWrite(segE, SEGMENT_OFF);
  499.     digitalWrite(segF, SEGMENT_ON);
  500.     digitalWrite(segG, SEGMENT_ON);
  501.     break;
  502.  
  503.   // all segment are ON
  504.   case 10:
  505.     digitalWrite(segA, SEGMENT_OFF);
  506.     digitalWrite(segB, SEGMENT_OFF);
  507.     digitalWrite(segC, SEGMENT_OFF);
  508.     digitalWrite(segD, SEGMENT_OFF);
  509.     digitalWrite(segE, SEGMENT_OFF);
  510.     digitalWrite(segF, SEGMENT_OFF);
  511.     digitalWrite(segG, SEGMENT_OFF);
  512.     break;
  513.  
  514.   }
  515. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!