commit ffb1770e2804a9696dda5310fdd8acd693daf578 Author: Paul van Tilburg Date: Sun Oct 30 22:27:58 2011 +0100 Imported initial code by Doug Jackson (slightly modified by Admar). diff --git a/libraries/ds1302/DS1302.cpp b/libraries/ds1302/DS1302.cpp new file mode 100644 index 0000000..9dde412 --- /dev/null +++ b/libraries/ds1302/DS1302.cpp @@ -0,0 +1,273 @@ +#include "WProgram.h" +#include "DS1302.h" + + +/*** Time definitions ***/ + +Time::Time(uint16_t yr, uint8_t mon, uint8_t date, + uint8_t hr, uint8_t min, uint8_t sec, + uint8_t day) +{ + this->yr = yr; + this->mon = mon; + this->date = date; + this->hr = hr; + this->min = min; + this->sec = sec; + this->day = day; +} + + +Time::Time() +{ + Time(2000, 1, 1, 0, 0, 0, 7); +} + + +/*** DS1302 definitions ***/ + +DS1302::DS1302(uint8_t ce_pin, uint8_t io_pin, uint8_t sclk_pin) +{ + _ce_pin = ce_pin; + _io_pin = io_pin; + _sclk_pin = sclk_pin; + + pinMode(ce_pin, OUTPUT); + pinMode(sclk_pin, OUTPUT); +} + + +void DS1302::_write_out(uint8_t value) +{ + pinMode(_io_pin, OUTPUT); + shiftOut(_io_pin, _sclk_pin, LSBFIRST, value); +} + + +uint8_t DS1302::_read_in() +{ + uint8_t input_value = 0; + uint8_t bit = 0; + pinMode(_io_pin, INPUT); + + for (int i = 0; i < 8; ++i) { + bit = digitalRead(_io_pin); + input_value |= (bit << i); + + digitalWrite(_sclk_pin, HIGH); + delayMicroseconds(1); + digitalWrite(_sclk_pin, LOW); + } + + return input_value; +} + + +uint8_t DS1302::_register_bcd_to_dec(reg_t reg, uint8_t high_bit) +{ + uint8_t val = read_register(reg); + uint8_t mask = (1 << (high_bit + 1)) - 1; + val &= mask; + val = (val & 15) + 10 * ((val & (15 << 4)) >> 4); + return val; +} + + +uint8_t DS1302::_register_bcd_to_dec(reg_t reg) +{ + return _register_bcd_to_dec(reg, 7); +} + + +void DS1302::_register_dec_to_bcd(reg_t reg, uint8_t value, uint8_t high_bit) +{ + uint8_t regv = read_register(reg); + uint8_t mask = (1 << (high_bit + 1)) - 1; + + /* convert value to bcd in place */ + uint8_t tvalue = value / 10; + value = value % 10; + value |= (tvalue << 4); + + /* replace high bits of value if needed */ + value &= mask; + value |= (regv &= ~mask); + + write_register(reg, value); +} + + +void DS1302::_register_dec_to_bcd(reg_t reg, uint8_t value) +{ + _register_dec_to_bcd(reg, value, 7); +} + + +uint8_t DS1302::read_register(reg_t reg) +{ + uint8_t cmd_byte = 129; /* 1000 0001 */ + uint8_t reg_value; + cmd_byte |= (reg << 1); + + digitalWrite(_sclk_pin, LOW); + digitalWrite(_ce_pin, HIGH); + + _write_out(cmd_byte); + reg_value = _read_in(); + + digitalWrite(_ce_pin, LOW); + + return reg_value; +} + + +void DS1302::write_register(reg_t reg, uint8_t value) +{ + uint8_t cmd_byte = (128 | (reg << 1)); + + digitalWrite(_sclk_pin, LOW); + digitalWrite(_ce_pin, HIGH); + + _write_out(cmd_byte); + _write_out(value); + + digitalWrite(_ce_pin, LOW); +} + + +void DS1302::write_protect(bool enable) +{ + write_register(WP_REG, (enable << 7)); +} + + +void DS1302::halt(bool enable) +{ + uint8_t sec = read_register(SEC_REG); + sec &= ~(1 << 7); + sec |= (enable << 7); + write_register(SEC_REG, sec); +} + + +/*** Get time ***/ + +uint8_t DS1302::seconds() +{ + return _register_bcd_to_dec(SEC_REG, 6); +} + + +uint8_t DS1302::minutes() +{ + return _register_bcd_to_dec(MIN_REG); +} + + +uint8_t DS1302::hour() +{ + uint8_t hr = read_register(HR_REG); + uint8_t adj; + if (hr & 128) /* 12-hour mode */ + adj = 12 * ((hr & 32) >> 5); + else /* 24-hour mode */ + adj = 10 * ((hr & (32 + 16)) >> 4); + hr = (hr & 15) + adj; + return hr; +} + + +uint8_t DS1302::date() +{ + return _register_bcd_to_dec(DATE_REG, 5); +} + + +uint8_t DS1302::month() +{ + return _register_bcd_to_dec(MON_REG, 4); +} + + +uint8_t DS1302::day() +{ + return _register_bcd_to_dec(DAY_REG, 2); +} + + +uint16_t DS1302::year() +{ + return 2000 + _register_bcd_to_dec(YR_REG); +} + + +Time DS1302::time() +{ + Time t; + t.sec = seconds(); + t.min = minutes(); + t.hr = hour(); + t.date = date(); + t.mon = month(); + t.day = day(); + t.yr = year(); + return t; +} + + +/*** Set time ***/ + +void DS1302::seconds(uint8_t sec) +{ + _register_dec_to_bcd(SEC_REG, sec, 6); +} + + +void DS1302::minutes(uint8_t min) +{ + _register_dec_to_bcd(MIN_REG, min, 6); +} + + +void DS1302::hour(uint8_t hr) +{ + write_register(HR_REG, 0); /* set 24-hour mode */ + _register_dec_to_bcd(HR_REG, hr, 5); +} + + +void DS1302::date(uint8_t date) +{ + _register_dec_to_bcd(DATE_REG, date, 5); +} + + +void DS1302::month(uint8_t mon) +{ + _register_dec_to_bcd(MON_REG, mon, 4); +} + + +void DS1302::day(uint8_t day) +{ + _register_dec_to_bcd(DAY_REG, day, 2); +} + + +void DS1302::year(uint16_t yr) +{ + yr -= 2000; + _register_dec_to_bcd(YR_REG, yr); +} + + +void DS1302::time(Time t) +{ + seconds(t.sec); + minutes(t.min); + hour(t.hr); + date(t.date); + month(t.mon); + day(t.day); + year(t.yr); +} diff --git a/libraries/ds1302/DS1302.h b/libraries/ds1302/DS1302.h new file mode 100644 index 0000000..0f98a7f --- /dev/null +++ b/libraries/ds1302/DS1302.h @@ -0,0 +1,233 @@ +/* +Copyright (c) 2009, Matt Sparks +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in + the documentation and/or other materials provided with the + distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED +AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. +*/ +#ifndef DS1302_h +#define DS1302_h + +#include "WProgram.h" + +/** + * Convenience register constants + */ +#define SEC_REG 0 +#define MIN_REG 1 +#define HR_REG 2 +#define DATE_REG 3 +#define MON_REG 4 +#define DAY_REG 5 +#define YR_REG 6 +#define WP_REG 7 + +/** + * Type for a register number + */ +typedef uint8_t reg_t; + + +/** + * Class representing a particular time and date. + */ +class Time +{ +public: + uint8_t sec; + uint8_t min; + uint8_t hr; + uint8_t date; + uint8_t mon; + uint8_t day; + uint16_t yr; + + /** + * Default constructor. + * + * Creates a time object dated to Saturday Jan 1, 2000 at 00:00:00. + * The date and time can be changed by editing the instance variables. + */ + Time(); + + /** + * Create a Time object with a given time. + * + * Args: + * yr: year. Range: {2000, ..., 2099}. + * mon: month. Range: {1, ..., 12}. + * date: date (of the month). Range: {1, ..., 31}. + * hr: hour. Range: {0, ..., 23}. + * min: minutes. Range: {0, ..., 59}. + * sec: seconds. Range: {0, ..., 59}. + * day: day of the week. Sunday is 1. Range: {1, ..., 7}. + */ + Time(uint16_t yr, uint8_t mon, uint8_t date, + uint8_t hr, uint8_t min, uint8_t sec, + uint8_t day); +}; + + +/** + * Talk to a Dallas Semiconductor DS1302 Real Time Clock (RTC) chip. + */ +class DS1302 +{ +public: + /** + * Constructor. + * + * Args: + * ce_pin: CE pin number + * io_pin: IO pin number + * sclk_pin: SCLK pin number + */ + DS1302(uint8_t ce_pin, uint8_t io_pin, uint8_t sclk_pin); + + /** + * Read register byte value. + * + * Args: + * reg: register number + * + * Returns: + * register value + */ + uint8_t read_register(reg_t reg); + + /** + * Write byte into register. + * + * Args: + * reg: register number + * value: byte to write + */ + void write_register(reg_t reg, uint8_t value); + + /** + * Enable or disable write protection on chip. + * + * Args: + * enable: true to enable, false to disable. + */ + void write_protect(bool enable); + + /** + * Set or clear clock halt flag. + * + * Args: + * value: true to set halt flag, false to clear. + */ + void halt(bool value); + + /** + * Get individual pieces of the time and date. + */ + uint8_t seconds(); + uint8_t minutes(); + uint8_t hour(); + uint8_t date(); + uint8_t month(); + uint8_t day(); + uint16_t year(); + + /** + * Get the current time and date in a Time object. + * + * Returns: + * Time object. + */ + Time time(); + + /** + * Individually set pieces of the date and time. + * + * The arguments here follow the rules specified above in Time::Time(...). + */ + void seconds(uint8_t sec); + void minutes(uint8_t min); + void hour(uint8_t hr); + void date(uint8_t date); + void month(uint8_t mon); + void day(uint8_t day); + void year(uint16_t yr); + + /** + * Set the time and date to the instant specified in a given Time object. + * + * Args: + * t: Time object to use + */ + void time(Time t); + +private: + uint8_t _ce_pin; + uint8_t _io_pin; + uint8_t _sclk_pin; + + /** + * Shift out a value to the IO pin. + * + * Side effects: sets _io_pin as OUTPUT. + * + * Args: + * value: byte to shift out + */ + void _write_out(uint8_t value); + + /** + * Read in a byte from the IO pin. + * + * Side effects: sets _io_pin to INPUT. + * + * Returns: + * byte read in + */ + uint8_t _read_in(); + + /** + * Get a binary-coded decimal register and return it in decimal. + * + * Args: + * reg: register number + * high_bit: number of the bit containing the last BCD value ({0, ..., 7}) + * + * Returns: + * decimal value + */ + uint8_t _register_bcd_to_dec(reg_t reg, uint8_t high_bit); + uint8_t _register_bcd_to_dec(reg_t reg); + + /** + * Set a register with binary-coded decimal converted from a given value. + * + * Args: + * reg: register number + * value: decimal value to convert to BCD + * high_bit: highest bit in the register allowed to contain BCD value + */ + void _register_dec_to_bcd(reg_t reg, uint8_t value, uint8_t high_bit); + void _register_dec_to_bcd(reg_t reg, uint8_t value); +}; + +#endif diff --git a/libraries/ds1302/examples/set_clock/set_clock.pde b/libraries/ds1302/examples/set_clock/set_clock.pde new file mode 100644 index 0000000..51b68e9 --- /dev/null +++ b/libraries/ds1302/examples/set_clock/set_clock.pde @@ -0,0 +1,92 @@ +/* +Example sketch for interfacing with the DS1302 timekeeping chip. + +Copyright (c) 2009, Matt Sparks +All rights reserved. + +http://quadpoint.org/projects/arduino-ds1302 +*/ +#include +#include +#include + +/* Set the appropriate digital I/O pin connections */ +uint8_t CE_PIN = 5; +uint8_t IO_PIN = 6; +uint8_t SCLK_PIN = 7; + +/* Create buffers */ +char buf[50]; +char day[10]; + +/* Create a DS1302 object */ +DS1302 rtc(CE_PIN, IO_PIN, SCLK_PIN); + + +void print_time() +{ + /* Get the current time and date from the chip */ + Time t = rtc.time(); + + /* Name the day of the week */ + memset(day, 0, sizeof(day)); /* clear day buffer */ + switch (t.day) { + case 1: + strcpy(day, "Sunday"); + break; + case 2: + strcpy(day, "Monday"); + break; + case 3: + strcpy(day, "Tuesday"); + break; + case 4: + strcpy(day, "Wednesday"); + break; + case 5: + strcpy(day, "Thursday"); + break; + case 6: + strcpy(day, "Friday"); + break; + case 7: + strcpy(day, "Saturday"); + break; + } + + /* Format the time and date and insert into the temporary buffer */ + snprintf(buf, sizeof(buf), "%s %04d-%02d-%02d %02d:%02d:%02d", + day, + t.yr, t.mon, t.date, + t.hr, t.min, t.sec); + + /* Print the formatted string to serial so we can see the time */ + Serial.println(buf); +} + + +void setup() +{ + Serial.begin(9600); + + /* Initialize a new chip by turning off write protection and clearing the + clock halt flag. These methods needn't always be called. See the DS1302 + datasheet for details. */ + rtc.write_protect(false); + rtc.halt(false); + + /* Make a new time object to set the date and time */ + /* Tuesday, May 19, 2009 at 21:16:37. */ + Time t(2009, 5, 19, 21, 16, 37, 3); + + /* Set the time and date on the chip */ + rtc.time(t); +} + + +/* Loop and print the time every second */ +void loop() +{ + print_time(); + delay(1000); +} diff --git a/wordclock/Dutch.h b/wordclock/Dutch.h new file mode 100644 index 0000000..610037e --- /dev/null +++ b/wordclock/Dutch.h @@ -0,0 +1,244 @@ +/************************************************************************** + * * + * W O R D C L O C K - A clock that tells the time using words. * + * * + * DUTCH Language Support Functions * + * * + * Copyright (C) 2009,2010,2011 Doug Jackson (doug@doughq.com) * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * + * MA 02111-1307 USA * + * * + *************************************************************************** + * + * Revision History + * 20110315 DRJ Split off from Wordclock.pde to simplify modifying + * code for multiple languages + */ + + + +// Display output pin assignments +#define MTEN Display1=Display1 | (1<<1); Serial.print("tien "); +#define HALF Display1=Display1 | (1<<2); Serial.print("half "); +#define PAST Display1=Display1 | (1<<3); Serial.print("over "); +#define THREE Display1=Display1 | (1<<4); Serial.print("drie "); +#define ITIS Display1=Display1 | (1<<5); Serial.print("het is ") +#define TO Display1=Display1 | (1<<7); Serial.print("voor "); + +#define TWO Display2=Display2 | (1<<0); Serial.print("twee "); +#define SIX Display2=Display2 | (1<<1); Serial.print("zes "); +#define TWELVE Display2=Display2 | (1<<2); Serial.print("twaalf "); +#define HFIVE Display2=Display2 | (1<<3); Serial.print("vijf "); +#define SEVEN Display2=Display2 | (1<<4); Serial.print("zeven "); +#define HOUR Display2=Display2 | (1<<5); Serial.print("uur "); +#define ONE Display2=Display2 | (1<<6); Serial.print("een "); +#define QUARTER Display2=Display2 | (1<<7); Serial.print("kwart "); + +#define EIGHT Display3=Display3 | (1<<0); Serial.print("acht "); +#define MFIVE Display3=Display3 | (1<<1); Serial.print("vijf "); +#define ELEVEN Display3=Display3 | (1<<3); Serial.print("elf "); +#define HTEN Display3=Display3 | (1<<4); Serial.print("tien "); +#define NINE Display3=Display3 | (1<<5); Serial.print("negen "); +#define FOUR Display3=Display3 | (1<<6); Serial.print("vier "); + +#define LED1 Led1=1; Serial.print("MINLED 1 ") +#define LED2 Led2=1; Serial.print("2 ") +#define LED3 Led3=1; Serial.print("3 ") +#define LED4 Led4=1; Serial.print("4 ") + +/*#define LED1 digitalWrite(LED1PIN,HIGH) +#define LED2 digitalWrite(LED2PIN,HIGH) +#define LED3 digitalWrite(LED3PIN,HIGH) +#define LED4 digitalWrite(LED4PIN,HIGH)*/ + + + + +void selftest(void){ + Serial.print("Selftest started"); + // start by clearing the display to a known state + ledsoff(); ITIS; delay(500); + ledsoff(); MFIVE; delay(500); + ledsoff(); MTEN; delay(500); + ledsoff(); QUARTER; delay(500); + ledsoff(); PAST; delay(500); + ledsoff(); TO; delay(500); + ledsoff(); HALF; delay(500); + ledsoff(); ONE; delay(500); + ledsoff(); TWO; delay(500); + ledsoff(); THREE; delay(500); + ledsoff(); FOUR; delay(500); + ledsoff(); HFIVE; delay(500); + ledsoff(); SIX; delay(500); + ledsoff(); SEVEN; delay(500); + ledsoff(); EIGHT; delay(500); + ledsoff(); NINE; delay(500); + ledsoff(); HTEN; delay(500); + ledsoff(); ELEVEN; ; delay(500); + ledsoff(); TWELVE; delay(500); + ledsoff(); HOUR; delay(500); + ledsoff(); LED1; delay(500); + ledsoff(); LED2; delay(500); + ledsoff(); LED3; delay(500); + ledsoff(); LED4; delay(500); + Serial.println(" .. ok"); + + for(int i=0; i<5; i++) + { + Display1=255; Display2=255; Display3=255; LED1; LED2; LED3; LED4; delay(500); + ledsoff(); delay(500); + } + +} + + + + +void displaytime(void){ + + // start by clearing the display to a known state + ledsoff(); + + // Now, turn on the "It is" leds + ITIS; + + + // now we display the appropriate minute counter + if ((minute>4) && (minute<10)) { MFIVE; PAST; } + if ((minute>9) && (minute<15)) { MTEN; PAST; } + if ((minute>14) && (minute<20)) { QUARTER; PAST; } + if ((minute>19) && (minute<25)) { MTEN; TO; HALF; } + if ((minute>24) && (minute<30)) { MFIVE; TO; HALF; } + if ((minute>29) && (minute<35)) { HALF; } + if ((minute>34) && (minute<40)) { MFIVE; PAST; HALF; } + if ((minute>39) && (minute<45)) { MTEN; PAST; HALF; } + if ((minute>44) && (minute<50)) { QUARTER; TO; } + if ((minute>49) && (minute<55)) { MTEN; TO; } + if (minute>54) { MFIVE; TO; } + + + + if ((minute <5)) + { + switch (hour) { + case 1: + case 13: ONE; break; + case 2: + case 14: TWO; break; + case 3: + case 15: THREE; break; + case 4: + case 16: FOUR; break; + case 5: + case 17: HFIVE; break; + case 6: + case 18: SIX; break; + case 7: + case 19: SEVEN; break; + case 8: + case 20: EIGHT; break; + case 9: + case 21: NINE; break; + case 10: + case 22: HTEN; break; + case 11: + case 23: ELEVEN; break; + case 0: + case 12: + case 24: TWELVE; break; + } + HOUR; + } + else + if ((minute < 20) && (minute >4)) + { + switch (hour) { + case 1: + case 13: ONE; break; + case 2: + case 14: TWO; break; + case 3: + case 15: THREE; break; + case 4: + case 16: FOUR; break; + case 5: + case 17: HFIVE; break; + case 6: + case 18: SIX; break; + case 7: + case 19: SEVEN; break; + case 8: + case 20: EIGHT; break; + case 9: + case 21: NINE; break; + case 10: + case 22: HTEN; break; + case 11: + case 23: ELEVEN; break; + case 0: + case 12: + case 24: TWELVE; break; + } + } + else + { + // if we are greater than 34 minutes past the hour then display + // the next hour + + switch (hour) { + case 1: + case 13: TWO; break; + case 14: + case 2: THREE; break; + case 15: + case 3: FOUR; break; + case 4: + case 16: HFIVE; break; + case 5: + case 17: SIX; break; + case 6: + case 18: SEVEN; break; + case 7: + case 19: EIGHT; break; + case 8: + case 20: NINE; break; + case 9: + case 21: HTEN; break; + case 10: + case 22: ELEVEN; break; + case 11: + case 23: TWELVE; break; + case 0: + case 12: + case 24: ONE; break; + } + } + + + + // now we can illuminate the extra minute LEDs + + if ((minute-(minute/5)*5)==1) { LED1; } + if ((minute-(minute/5)*5)==2) { LED1; LED2; } + if ((minute-(minute/5)*5)==3) { LED1; LED2; LED3; } + if ((minute-(minute/5)*5)==4) { LED1; LED2; LED3; LED4; } + +// WriteLEDs(); + +} + diff --git a/wordclock/English.h b/wordclock/English.h new file mode 100644 index 0000000..4ee0ef4 --- /dev/null +++ b/wordclock/English.h @@ -0,0 +1,277 @@ + +/************************************************************************** + * * + * W O R D C L O C K - A clock that tells the time using words. * + * * + * ELGLISH LANGUAGE SUPPORT FILE * + * * + * Hardware: Arduino Dumelove with a set of individual LEDs under a word * + * stencil. * + * * + * Copyright (C) 2009 Doug Jackson (doug@doughq.com) * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * + * MA 02111-1307 USA * + * * + *************************************************************************** + * + * Revision History + * + * Date By What + */ + + +// Display output pin assignments +#define MINUTES Display1=Display1 | (1<<0); Serial.print("Minutes "); +#define MTEN Display1=Display1 | (1<<1); Serial.print("ten "); +#define HALF Display1=Display1 | (1<<2); Serial.print("half "); +#define PAST Display1=Display1 | (1<<3); Serial.print("past "); +#define THREE Display1=Display1 | (1<<4); Serial.print("three "); +#define ITIS Display1=Display1 | (1<<5); Serial.print("It is "); +#define TWENTY Display1=Display1 | (1<<6); Serial.print("twenty "); +#define TO Display1=Display1 | (1<<7); Serial.print("to "); + +#define TWO Display2=Display2 | (1<<0); Serial.print("two "); +#define SIX Display2=Display2 | (1<<1); Serial.print("six "); +#define TWELVE Display2=Display2 | (1<<2); Serial.print("twelve "); +#define HFIVE Display2=Display2 | (1<<3); Serial.print("five "); +#define SEVEN Display2=Display2 | (1<<4); Serial.print("seven "); +#define OCLOCK Display2=Display2 | (1<<5); Serial.print("oclock "); +#define ONE Display2=Display2 | (1<<6); Serial.print("one "); +#define QUARTER Display2=Display2 | (1<<7); Serial.print("quarter "); + +#define EIGHT Display3=Display3 | (1<<0); Serial.print("eight "); +#define MFIVE Display3=Display3 | (1<<1); Serial.print("five "); +#define ELEVEN Display3=Display3 | (1<<3); Serial.print("eleven "); +#define HTEN Display3=Display3 | (1<<4); Serial.print("ten "); +#define NINE Display3=Display3 | (1<<5); Serial.print("nine "); +#define FOUR Display3=Display3 | (1<<6); Serial.print("four "); + +#define WORD1 Display3=Display3 | (1<<7); Serial.print("word1 "); +#define WORD2 Display3=Display3 | (1<<2); Serial.print("word2 "); +#define WORD1OFF Display3=Display3 & ~(1<<7); +#define WORD2OFF Display3=Display3 & ~(1<<2); + + +#define LED1 Led1=1; Serial.print("MINLED 1 ") +#define LED2 Led2=1; Serial.print("2 ") +#define LED3 Led3=1; Serial.print("3 ") +#define LED4 Led4=1; Serial.print("4 ") + + +void selftest(void){ + // start by clearing the display to a known state + ledsoff(); ITIS; delay(500); + ledsoff(); HALF; delay(500); + ledsoff(); MTEN; delay(500); + ledsoff(); QUARTER; delay(500); + ledsoff(); TWENTY; delay(500); + ledsoff(); MFIVE; delay(500); + ledsoff(); MINUTES; delay(500); + ledsoff(); TO; delay(500); + ledsoff(); PAST; delay(500); + ledsoff(); ONE; delay(500); + ledsoff(); THREE; delay(500); + ledsoff(); TWO; delay(500); + + ledsoff(); FOUR; delay(500); + ledsoff(); HFIVE; delay(500); + ledsoff(); SIX; delay(500); + ledsoff(); SEVEN; delay(500); + ledsoff(); EIGHT; delay(500); + ledsoff(); NINE; delay(500); + ledsoff(); HTEN; delay(500); + ledsoff(); ELEVEN; delay(500); + ledsoff(); TWELVE; delay(500); + ledsoff(); OCLOCK; delay(500); + ledsoff(); WORD1; delay(500); + ledsoff(); WORD2; delay(500); + ledsoff(); LED1; delay(500); + ledsoff(); LED2; delay(500); + ledsoff(); LED3; delay(500); + ledsoff(); LED4; delay(500); + + for(int i=0; i<5; i++) + { + Display1=255; Display2=255; Display3=255; delay(500); + ledsoff(); delay(500); + } + +} + + +void displaytime(void){ + + // start by clearing the display to a known state + ledsoff(); + + // Now, turn on the "It is" leds + ITIS; + + // now we display the appropriate minute counter + if ((minute>4) && (minute<10)) { MFIVE; MINUTES; } + if ((minute>9) && (minute<15)) { MTEN; MINUTES; } + if ((minute>14) && (minute<20)) { QUARTER; } + if ((minute>19) && (minute<25)) { TWENTY; MINUTES; } + if ((minute>24) && (minute<30)) { TWENTY; MFIVE; MINUTES; } + if ((minute>29) && (minute<35)) { HALF; } + if ((minute>34) && (minute<40)) { TWENTY; MFIVE; MINUTES; } + if ((minute>39) && (minute<45)) { TWENTY; MINUTES; } + if ((minute>44) && (minute<50)) { QUARTER; } + if ((minute>49) && (minute<55)) { MTEN; MINUTES; } + if (minute>54) { MFIVE; MINUTES; } + + + + if ((minute <5)) + { + switch (hour) { + case 1: + case 13: ONE; break; + case 2: + case 14: TWO; break; + case 3: + case 15: THREE; break; + case 4: + case 16: FOUR; break; + case 5: + case 17: HFIVE; break; + case 6: + case 18: SIX; break; + case 7: + case 19: SEVEN; break; + case 8: + case 20: EIGHT; break; + case 9: + case 21: NINE; break; + case 10: + case 22: HTEN; break; + case 11: + case 23: ELEVEN; break; + case 0: + case 12: TWELVE; break; + } + OCLOCK; + } + else + if ((minute < 35) && (minute >4)) + { + PAST; + switch (hour) { + case 1: + case 13: ONE; break; + case 2: + case 14: TWO; break; + case 3: + case 15: THREE; break; + case 4: + case 16: FOUR; break; + case 5: + case 17: HFIVE; break; + case 6: + case 18: SIX; break; + case 7: + case 19: SEVEN; break; + case 8: + case 20: EIGHT; break; + case 9: + case 21: NINE; break; + case 10: + case 22: HTEN; break; + case 11: + case 23: ELEVEN; break; + case 0: + case 12: TWELVE; break; + } + } + else + { + // if we are greater than 34 minutes past the hour then display + // the next hour, as we will be displaying a 'to' sign + TO; + switch (hour) { + case 1: + case 13: TWO; break; + case 2: + case 14: THREE; break; + case 3: + case 15: FOUR; break; + case 4: + case 16: HFIVE; break; + case 5: + case 17: SIX; break; + case 6: + case 18: SEVEN; break; + case 7: + case 19: EIGHT; break; + case 8: + case 20: NINE; break; + case 9: + case 21: HTEN; break; + case 10: + case 22: ELEVEN; break; + case 11: + case 23: TWELVE; break; + case 0: + case 12: ONE; break; + + } + } + + + + // now we can illuminate the extra minute LEDs + + if ((minute-(minute/5)*5)==1) { LED1; } + if ((minute-(minute/5)*5)==2) { LED1; LED2; } + if ((minute-(minute/5)*5)==3) { LED1; LED2; LED3; } + if ((minute-(minute/5)*5)==4) { LED1; LED2; LED3; LED4; } + + + if (( minute==0) && (second==0)) + { + Serial.println("ALARM!!"); + WORD1; delay(500); + WORD1OFF; delay(500); + WORD2; delay(500); + WORD2OFF; delay(500); + WORD1; delay(300); + WORD1OFF; delay(300); + WORD2; delay(300); + WORD2OFF; delay(300); + WORD1; delay(200); + WORD1OFF; delay(200); + WORD2; delay(200); + WORD2OFF; delay(200); + WORD1; delay(500); + WORD1OFF; delay(500); + WORD2; delay(500); + WORD2OFF; delay(500); + WORD1; delay(300); + WORD1OFF; delay(300); + WORD2; delay(300); + WORD2OFF; delay(300); + WORD1; delay(200); + WORD1OFF; delay(200); + WORD2; delay(200); + WORD2OFF; delay(200); + } + + +} + + diff --git a/wordclock/French.h b/wordclock/French.h new file mode 100644 index 0000000..e530b95 --- /dev/null +++ b/wordclock/French.h @@ -0,0 +1,269 @@ +/************************************************************************** + * * + * W O R D C L O C K - A clock that tells the time using words. * + * * + * FRENCH VERSION - thanks to Lionel Martin for testing * + * * + * * + * Hardware: Arduino Dumelove with a set of individual LEDs under a word * + * stencil. * + * Copyright (C) 2009,2010,2011 Doug Jackson (doug@doughq.com) * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * + * MA 02111-1307 USA * + * * + *************************************************************************** + * + * Revision History + * + * Date By What + + * 20110310 DRJ Modified to French Language + */ + + +// Display output pin assignments +#define UNE Display1=Display1 | (1<<0); Serial.print("une "); +#define DEUX Display1=Display1 | (1<<1); Serial.print("duex "); +#define TROIS Display1=Display1 | (1<<2); Serial.print("trois "); +#define QUATRE Display1=Display1 | (1<<3); Serial.print("quatre "); +#define MCINQ Display1=Display1 | (1<<4); Serial.print("mcinq "); +#define SIX Display1=Display1 | (1<<5); Serial.print("six "); +#define SEPT Display1=Display1 | (1<<6); Serial.print("sept "); +#define HUIT Display1=Display1 | (1<<7); Serial.print("huit "); + +#define NEUF Display2=Display2 | (1<<0); Serial.print("neuf "); +#define HDIX Display2=Display2 | (1<<1); Serial.print("hdix "); +#define MINUIT Display2=Display2 | (1<<2); Serial.print("minuit "); +#define MIDI Display2=Display2 | (1<<3); Serial.print("midi "); +#define ONZE Display2=Display2 | (1<<4); Serial.print("onze "); +#define HEURE Display2=Display2 | (1<<5); Serial.print("heure "); +#define S Display2=Display2 | (1<<6); Serial.print("s "); +#define MOINS Display2=Display2 | (1<<7); Serial.print("moins "); + +#define LE Display3=Display3 | (1<<0); Serial.print("le "); +#define MDIX Display3=Display3 | (1<<1); Serial.print("mdix "); +#define ET Display3=Display3 | (1<<2); Serial.print("et "); +#define QUART Display3=Display3 | (1<<3); Serial.print("quart "); +#define VINGT Display3=Display3 | (1<<4); Serial.print("vingt "); +#define DASH Display3=Display3 | (1<<5); Serial.print("- "); +#define HCINQ Display3=Display3 | (1<<6); Serial.print("hcinq "); +#define DEMIE Display3=Display3 | (1<<7); Serial.print("demie "); + +#define LED1 Led1=1; Serial.print("MINLED1 ") +#define LED2 Led2=1; Serial.print("2 ") +#define LED3 Led3=1; Serial.print("3 ") +#define LED4 Led4=1; Serial.print("4 ") + + + +void selftest(void){ + // start by clearing the display to a known state + ledsoff(); + Serial.println("Start Self Test "); + UNE; delay(500); ledsoff(); + DEUX; delay(500); ledsoff(); + TROIS; delay(500); ledsoff(); + QUATRE; delay(500); ledsoff(); + MCINQ; delay(500); ledsoff(); + SIX; delay(500); ledsoff(); + SEPT; delay(500); ledsoff(); + HUIT; delay(500); ledsoff(); + NEUF; delay(500); ledsoff(); + MDIX; delay(500); ledsoff(); + MINUIT; delay(500); ledsoff(); + MIDI; delay(500); ledsoff(); + ONZE; delay(500); ledsoff(); + HEURE; delay(500); ledsoff(); + S; delay(500); ledsoff(); + MOINS; delay(500); ledsoff(); + LE; delay(500); ledsoff(); + HDIX; delay(500); ledsoff(); + ET; delay(500); ledsoff(); + QUART; delay(500); ledsoff(); + VINGT; delay(500); ledsoff(); + DASH; delay(500); ledsoff(); + HCINQ; delay(500); ledsoff(); + DEMIE; delay(500); ledsoff(); + LED1; delay(500); ledsoff(); + LED2; delay(500); ledsoff(); + LED3; delay(500); ledsoff(); + LED4; delay(500); + Serial.println(" "); + + for(int i=0; i<5; i++) + { + Display1=255; + Display2=255; + Display3=255; + delay(500); + ledsoff(); + delay(500); + } + Serial.println("End Self Test"); + +} + + +void displaytime(void){ + + + /************************************************************************** + +Display is performed using word strings such as: + IL EST UNE HEURE - It is One O'clock + IL EST UNE HEURE ET DEMI - It is One thirty + IL EST TROIS HEURES - It is Three Thirty + IL EST QUATRE HEURES VINGT - It is Twenty minutes past Four + IL EST QUATRE HEURES MOINS VINGT - It is Twenty Minutes to Four + + +Display Logic: + HEURE is displayed when hours is Singular + S (After HEURE) is displayed when hours is plural - and not midday or midnight + MOINS is displayed between xx:35 and xx:59 + CINQ is displayed at xx:05, xx:25, xx:35 and xx:55 + - is displayed at xx:25 and xx:35 + ET (before QUART) is displayed at xx:15 + LE is displayed at xx:45 + + + UNE is displayed between 01:00-01:59 and 13:00-13:59 + DEUX is displayed between 02:00-02:59 and 14:00-14:59 + TROIS is displayed between 03:00-03:59 and 15:00-15:59 + QUATRE is displayed between 04:00-04:59 and 16:00-16:59 + CINQ is displayed between 05:00-05:59 and 17:00-17:59 + SIX is displayed between 06:00-06:59 and 18:00-18:59 + SEPT is displayed between 07:00-09:59 and 19:00-19:59 + HEUT is displayed between 08:00-09:59 and 20:00-20:59 + NEUF is displayed between 09:00-09:59 and 21:00-21:59 + DIX is displayed between 10:00-10:59 and 22:00-22:59 + ONZE is displayed between 11:00-11:59 and 23:00-23:59 + MIDI is displayed between 12:00-12:59 + MINUIT is displayed between 00:00-00:59 + + + DIX is displayed between xx:10-xx:14 and 0x:50-0x:54 + QUART is displayed between xx:15-xx:19 and xx:45-xx:49 + VINGT is displayed between xx:20-xx:29 and xx:35-xx:44 + ET-DEMI is displayed between xx:30 and xx:34 +*/ + + // start by clearing the display to a known state + ledsoff(); + + // IL-EST is hard wired to stay on as we only have 24 outputs + + Serial.print("Il est "); + + + + if ((minute>=0) && (minute<35)) switch (hour) { + case 1: UNE; HEURE; break; + case 2: DEUX; HEURE; S; break; + case 3: TROIS; HEURE; S; break; + case 4: QUATRE; HEURE; S; break; + case 5: HCINQ; HEURE; S; break; + case 6: SIX; HEURE; S; break; + case 7: SEPT; HEURE; S; break; + case 8: HUIT; HEURE; S; break; + case 9: NEUF; HEURE; S; break; + case 10: HDIX; HEURE; S; break; + case 11: ONZE; HEURE; S; break; + case 12: MIDI; break; + case 13: UNE; HEURE; break; + case 14: DEUX; HEURE; S; break; + case 15: TROIS; HEURE; S; break; + case 16: QUATRE; HEURE; S; break; + case 17: HCINQ; HEURE; S; break; + case 18: SIX; HEURE; S; break; + case 19: SEPT; HEURE; S; break; + case 20: HUIT; HEURE; S; break; + case 21: NEUF; HEURE; S; break; + case 22: HDIX; HEURE; S; break; + case 23: ONZE; HEURE; S; break; + case 00: MINUIT; break; + case 24: MINUIT; break; + } + + else switch (hour) { + case 0: UNE; HEURE; break; + case 1: DEUX; HEURE; S; break; + case 2: TROIS; HEURE; S; break; + case 3: QUATRE; HEURE; S; break; + case 4: HCINQ; HEURE; S; break; + case 5: SIX; HEURE; S; break; + case 6: SEPT; HEURE; S; break; + case 7: HUIT; HEURE; S; break; + case 8: NEUF; HEURE; S; break; + case 9: HDIX; HEURE; S; break; + case 10: ONZE; HEURE; S; break; + case 11: MIDI; break; + case 12: UNE; HEURE; break; + case 13: DEUX; HEURE; S; break; + case 14: TROIS; HEURE; S; break; + case 15: QUATRE; HEURE; S; break; + case 16: HCINQ; HEURE; S; break; + case 17: SIX; HEURE; S; break; + case 18: SEPT; HEURE; S; break; + case 19: HUIT; HEURE; S; break; + case 20: NEUF; HEURE; S; break; + case 21: HDIX; HEURE; S; break; + case 22: ONZE; HEURE; S; break; + case 23: MINUIT; break; + } + + + + // now we display the appropriate minute counter + if ((minute>4) && (minute<10)) { MCINQ; } + if ((minute>9) && (minute<15)) { MDIX; } + if ((minute>14) && (minute<20)) { ET; QUART; } + if ((minute>19) && (minute<25)) { VINGT; } + if ((minute>24) && (minute<30)) { VINGT; DASH; MCINQ; } + if ((minute>29) && (minute<35)) { ET; DEMIE; } + if ((minute>34) && (minute<40)) { MOINS; VINGT; DASH; MCINQ; } + if ((minute>39) && (minute<45)) { MOINS; VINGT; } + if ((minute>44) && (minute<50)) { MOINS; LE; QUART; } + if ((minute>49) && (minute<55)) { MOINS; MDIX; } + if ((minute>54) && (minute<60)) { MOINS; MCINQ; } + + Serial.print(" "); + + // now we can illuminate the extra minute LEDs + + if ((minute-(minute/5)*5)==1) { + LED1; + } + if ((minute-(minute/5)*5)==2) { + LED1; + LED2; + } + if ((minute-(minute/5)*5)==3) { + LED1; + LED2; + LED3; + } + if ((minute-(minute/5)*5)==4) { + LED1; + LED2; + LED3; + LED4; + } + + +} diff --git a/wordclock/German.h b/wordclock/German.h new file mode 100644 index 0000000..6b14a2f --- /dev/null +++ b/wordclock/German.h @@ -0,0 +1,242 @@ +/************************************************************************** + * * + * W O R D C L O C K - A clock that tells the time using words. * + * * + * GERMAN Language Support Functions * + * * + * Copyright (C) 2009,2010,2011 Doug Jackson (doug@doughq.com) * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * + * MA 02111-1307 USA * + * * + *************************************************************************** + * + * Revision History + * 20110315 DRJ Split off from Wordclock.pde to simplify modifying + * code for multiple languages + */ + + + +// Display output pin assignments +#define ZENH Display1=Display1 | (1<<1); Serial.print("zenh "); +#define HALB Display1=Display1 | (1<<2); Serial.print("halb "); +#define NACH Display1=Display1 | (1<<3); Serial.print("nach "); +#define DREI Display1=Display1 | (1<<4); Serial.print("drei "); +#define ESIST Display1=Display1 | (1<<5); Serial.print("Es ist "); +#define ZWANZIG Display1=Display1 | (1<<6); Serial.print("zwanzig "); +#define VOR Display1=Display1 | (1<<7); Serial.print("vor "); + +#define ZWEI Display2=Display2 | (1<<0); Serial.print("zwei "); +#define SECHS Display2=Display2 | (1<<1); Serial.print("sechs "); +#define ZWOLF Display2=Display2 | (1<<2); Serial.print("zwolf "); +#define HFUNF Display2=Display2 | (1<<3); Serial.print("funf "); +#define SIEBEN Display2=Display2 | (1<<4); Serial.print("sieben "); +#define UHR Display2=Display2 | (1<<5); Serial.print("uhr "); +#define ONE Display2=Display2 | (1<<6); Serial.print("ein "); +#define VIERTEL Display2=Display2 | (1<<7); Serial.print("viertel "); + +#define ACHT Display3=Display3 | (1<<0); Serial.print("acht "); +#define MFUNF Display3=Display3 | (1<<1); Serial.print("funf "); +#define ELEVEN Display3=Display3 | (1<<3); Serial.print("elf "); +#define HZENH Display3=Display3 | (1<<4); Serial.print("zenh "); +#define NEUN Display3=Display3 | (1<<5); Serial.print("neun "); +#define VIER Display3=Display3 | (1<<6); Serial.print("vier "); + +#define LED1 Led1=1; Serial.print("MINLED 1 ") +#define LED2 Led2=1; Serial.print("2 ") +#define LED3 Led3=1; Serial.print("3 ") +#define LED4 Led4=1; Serial.print("4 ") + + + + + +void selftest(void){ + Serial.print("Selftest started "); + // start by clearing the display to a known state + ledsoff(); ESIST; delay(500); + ledsoff(); MFUNF; delay(500); + ledsoff(); ZENH; delay(500); + ledsoff(); VIERTEL; delay(500); + ledsoff(); ZWANZIG; delay(500); + ledsoff(); NACH; delay(500); + ledsoff(); VOR; delay(500); + ledsoff(); HALB; delay(500); + ledsoff(); ELEVEN; ; delay(500); + ledsoff(); HFUNF; delay(500); + ledsoff(); ZWEI; delay(500); + ledsoff(); ONE; delay(500); + ledsoff(); VIER; delay(500); + ledsoff(); HZENH; delay(500); + ledsoff(); ZWOLF; delay(500); + ledsoff(); DREI; delay(500); + ledsoff(); NEUN; delay(500); + ledsoff(); ACHT; delay(500); + ledsoff(); SECHS; delay(500); + ledsoff(); SIEBEN; delay(500); + ledsoff(); UHR; delay(500); + ledsoff(); LED1; delay(500); + ledsoff(); LED2; delay(500); + ledsoff(); LED3; delay(500); + ledsoff(); LED4; delay(500); + Serial.println(" .. ok"); + + for(int i=0; i<5; i++) + { + Display1=255; Display2=255; Display3=255; delay(500); + ledsoff(); delay(500); + } + +} + + + + +void displaytime(void){ + + // start by clearing the display to a known state + ledsoff(); + + // Now, turn on the "It is" leds + ESIST; + + + // now we display the appropriate minute counter + if ((minute>4) && (minute<10)) { MFUNF; NACH; } + if ((minute>9) && (minute<15)) { ZENH; NACH; } + if ((minute>14) && (minute<20)) { VIERTEL; NACH; } + if ((minute>19) && (minute<25)) { ZWANZIG; NACH; } + if ((minute>24) && (minute<30)) { MFUNF; VOR; HALB; } + if ((minute>29) && (minute<35)) { HALB;} + if ((minute>34) && (minute<40)) { MFUNF; NACH; HALB; } + if ((minute>39) && (minute<45)) { ZWANZIG; VOR; } + if ((minute>44) && (minute<50)) { VIERTEL; VOR; } + if ((minute>49) && (minute<55)) { ZENH; VOR; } + if (minute>54) { MFUNF; VOR; } + + + + if ((minute <5)) + { + switch (hour) { + case 1: + case 13: ONE; break; + case 2: + case 14: ZWEI; break; + case 3: + case 15: DREI; break; + case 4: + case 16: VIER; break; + case 5: + case 17: HFUNF; break; + case 6: + case 18: SECHS; break; + case 7: + case 19: SIEBEN; break; + case 8: + case 20: ACHT; break; + case 9: + case 21: NEUN; break; + case 10: + case 22: HZENH; break; + case 11: + case 23: ELEVEN; break; + case 0: + case 12: + case 24: ZWOLF; break; + } + UHR; + } + else + if ((minute < 25) && (minute >4)) + { + switch (hour) { + case 1: + case 13: ONE; break; + case 2: + case 14: ZWEI; break; + case 3: + case 15: DREI; break; + case 4: + case 16: VIER; break; + case 5: + case 17: HFUNF; break; + case 6: + case 18: SECHS; break; + case 7: + case 19: SIEBEN; break; + case 8: + case 20: ACHT; break; + case 9: + case 21: NEUN; break; + case 10: + case 22: HZENH; break; + case 11: + case 23: ELEVEN; break; + case 0: + case 12: + case 24: ZWOLF; break; + } + } + else + { + // if we are greater than 34 minutes NACH the hour then display + // the next hour + + switch (hour) { + case 1: + case 13: ZWEI; break; + case 14: + case 2: DREI; break; + case 15: + case 3: VIER; break; + case 4: + case 16: HFUNF; break; + case 5: + case 17: SECHS; break; + case 6: + case 18: SIEBEN; break; + case 7: + case 19: ACHT; break; + case 8: + case 20: NEUN; break; + case 9: + case 21: HZENH; break; + case 10: + case 22: ELEVEN; break; + case 11: + case 23: ZWOLF; break; + case 0: + case 12: + case 24: ONE; break; + } + } + + + + // now we can illuminate the extra minute LEDs + + if ((minute-(minute/5)*5)==1) { LED1; } + if ((minute-(minute/5)*5)==2) { LED1; LED2; } + if ((minute-(minute/5)*5)==3) { LED1; LED2; LED3; } + if ((minute-(minute/5)*5)==4) { LED1; LED2; LED3; LED4; } + +// WriteLEDs(); + +} + diff --git a/wordclock/wordclock.pde b/wordclock/wordclock.pde new file mode 100644 index 0000000..3ed7a49 --- /dev/null +++ b/wordclock/wordclock.pde @@ -0,0 +1,486 @@ +#include +#include +#include // I use the library that Matt Sparks created +#include +#include + +// uncomment the following to speed up the timer for testing +//#define TESTMODE + + + +// specify the language - defines the header to be included +// available choices - English, Danish, French, German +//#define LANGUAGE "English.h" +#define LANGUAGE "Dutch.h" + + +/************************************************************************** + * * + * W O R D C L O C K - A clock that tells the time using words. * + * * + * Hardware: Arduino Dumelove with a set of individual LEDs under a word * + * stencil. * + * * + * Copyright (C) 2009 Doug Jackson (doug@doughq.com) * + * * + *************************************************************************** + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + * * + * This program is distributed in the hope that it will be useful, * + * but WITHOUT ANY WARRANTY; without even the implied warranty of * + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * + * GNU General Public License for more details. * + * * + * You should have received a copy of the GNU General Public License * + * along with this program; if not, write to the Free Software * + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, * + * MA 02111-1307 USA * + * * + *************************************************************************** + * + * Revision History + * + * Date By What + * 20010205 DRJ Initial Creation of Arduino Version + * - based on Wordclock.c - from PIC version + * 20100428 DRJ Added support for DS1302 RTC Chip - Code verifies + * device is present - and if so, uses it for timekeeping + * 20100511 DRJ Added ability to detect old vs new Arduino boards + * New board uses diferent time button sense. + * 20100511 DRJ Minute LED support on Analog5-1 pins. + * 20100927 DRJ Added brightness support by enabling interrupts and + * using an ISR to control the display + */ + + + +// DAY Brightness setting 0 = off 20 = full +#define DAYBRIGHTNESS 20 +// NIGHT Brightness setting 0 = off 20 = full +#define NIGHTBRIGHTNESS 20 + + + +//#define LED1 Led1=1 +//#define LED2 Led2=1 +//#define LED3 Led3=1 +//#define LED4 Led4=1 + + + +#define INIT_TIMER_COUNT 6 +#define RESET_TIMER2 TCNT2 = INIT_TIMER_COUNT + + + + +int hour=12, minute=0, second=00; +static unsigned long msTick =0; // the number of Millisecond Ticks since we last +// incremented the second counter +int count; +int selftestmode; // 1 = in self test - flash display +int DS1302Present=0; // flag to indicate that the 1302 is there.. 1 = present +char Display1=0, Display2=0, Display3=0, Led1=0, Led2=0, Led3=0, Led4=0; +int OldHardware = 0; // 1 = we are running on old hardwrae +int BTNActive = 1; // the sense of the button inputs (Changes based on hardware type) +int timercount=10; // used for interrupt counting to determine the brightnes of the display + +// hardware constants +int LEDClockPin=5; // Arduino Pin#11 - 4094 Pin 3 clock +int LEDDataPin=3; // Arduino Pin#5 - 4094 pin 2 Data +int LEDStrobePin=4; // Arduino Pin#6 - 4094 pin 1 Strobe + +// buttons +int FWDButtonPin=6; +int REVButtonPin=7; + +// 1302 RTC Constants +int DS1302IOPin=10; +int DS1302CEPin=8; +int DS1302CLKPin=9; + +// Minute LED Pins +int LED1PIN=19; // Arduino analog 5 +int LED2PIN=18; // Arduino analog 4 +int LED3PIN=17; // Arduino analog 3 +int LED4PIN=16; // Arduino analog 2 + +int current_brightnes=0; + + +// define the language to be used for this project: +#include LANGUAGE // The language pack + + + +/* Create buffers */ +char buf[50]; // time output string for debugging + + +// create an object that talks to the RTC +DS1302 rtc(DS1302CEPin, DS1302IOPin, DS1302CLKPin); + +void print_DS1302time() +{ + /* Get the current time and date from the chip */ + Time t = rtc.time(); + + /* Format the time and date and insert into the temporary buffer */ + snprintf(buf, sizeof(buf), "DS1302 time: %02d:%02d:%02d", + t.hr, t.min, t.sec); + + /* Print the formatted string to serial so we can see the time */ + Serial.println(buf); + +} + + + +void setup() +{ + // initialise the hardware + // initialize the appropriate pins as outputs: + pinMode(LEDClockPin, OUTPUT); + pinMode(LEDDataPin, OUTPUT); + pinMode(LEDStrobePin, OUTPUT); + pinMode(FWDButtonPin, INPUT); + pinMode(REVButtonPin, INPUT); + + // setup 1302 + pinMode(DS1302IOPin, OUTPUT); + pinMode(DS1302CEPin, OUTPUT); + pinMode(DS1302CLKPin, OUTPUT); + + // Minute LEDS + pinMode(LED1PIN, OUTPUT); + pinMode(LED2PIN, OUTPUT); + pinMode(LED3PIN, OUTPUT); + pinMode(LED4PIN, OUTPUT); + + current_brightnes=DAYBRIGHTNESS; + + + Serial.begin(9600); // setup the serial port to 9600 baud + SWversion(); // Display the version number of the software + + // test whether the DS1302 is there + Serial.print("Verifying DS1302 "); + // start by verifying that the chip has a valid signature + if (rtc.read_register(0x20) == 0xa5) { + // Signature is there - set the present flag and mmove on + DS1302Present=1; + Serial.println("present - Valid Signature"); + rtc.write_protect(false); + rtc.halt(false); + } + else + { + // Signature isnt there - may be a new chip - + // do a write to see if it will hold the signature + rtc.write_register(0x20,0xa5); + if (rtc.read_register(0x20) == 0xa5) { + // We can store data - assume that it is a new chip that needs initialisation + // Start by turning off write protection and clearing the clock halt flag. + rtc.write_protect(false); + rtc.halt(false); + // Make a new time object to set the date and time + Time t(2010, 04, 28, 10, 19, 00, 01); + // Set the time and date on the chip + rtc.time(t); + // set the DS1302 present flag + DS1302Present=1; + Serial.println("present - new chip initialised."); + } + else Serial.println("absent"); + } + + // determine whether we are running on old or new hardware + // old hardware tied the push buttons to ground using 4k7 resistors + // and relied on the buttons to pull them high + // new hardware uses internal pullups, and uses the buttons + // to pull the inputs down. + + digitalWrite(FWDButtonPin,HIGH); // Turn on weak pullups + digitalWrite(REVButtonPin,HIGH); // Turn on weak pullups + + OldHardware=0; + if ( digitalRead(FWDButtonPin)==0 && digitalRead(REVButtonPin)==0) + { + Serial.println("Detected Old Hardware"); + OldHardware=1; // we have old hardware + BTNActive = 1; // True = active for old hardware + digitalWrite(FWDButtonPin,LOW); // Turn off weak pullups + digitalWrite(REVButtonPin,LOW); // Turn off weak pullups + + } + else + { + Serial.println("Detected New Hardware"); + OldHardware=0; // we have old hardware + BTNActive = 0; // True = active for old hardware + } + + + // Initialise Timer2: Timer Prescaler /64, + TCCR2A = 0; + TCCR2B |= (1<= 60) { + minute=0; + if (++hour == 25) { + hour=1; + } + } + // debug outputs + Serial.println(); + if (DS1302Present==1) print_DS1302time(); + else Serial.print("Arduino Time: " ); + Serial.print(hour); + Serial.print(":"); + Serial.print(minute); + Serial.print(":"); + Serial.print(second); + Serial.print(" "); + +} + + +void SWversion(void) { + delay(2000); + Serial.println(); + Serial.println("Wordclock -Arduino v3.0a - reduced brightness version"); + Serial.print(LANGUAGE); Serial.println(" header file used"); + Serial.println("(c)2009, 2010, 2011 Doug Jackson"); +} + + +void loop(void) +{ + + #ifdef TESTMODE + second=59; + #endif + + //Serial.println("Loop Started"); + + // heart of the timer - keep looking at the millisecond timer on the Arduino + // and increment the seconds counter every 1000 ms + if ( millis() - msTick >999) { + msTick=millis(); + second++; + // Flash the onboard Pin13 Led so we know something is hapening! + digitalWrite(13,HIGH); + delay(50); + digitalWrite(13,LOW); + delay(50); + digitalWrite(13,HIGH); + delay(50); + digitalWrite(13,LOW); + + #ifndef TESTMODE + if (second%5==0) { + Serial.print(second); + Serial.print(".."); + } + #endif + } + + + + //test to see if we need to increment the time counters + if (second==60) + { + incrementtime(); + displaytime(); + } + + if (DS1302Present==1) { + // Get the current time and date from the chip + Time t = rtc.time(); + second=t.sec; + minute=t.min; + hour=t.hr; + } + + // set the brightnes level based on the current hour - night=7pm - 6.59am + // + if ((hour <7) | (hour >=19)) + current_brightnes=NIGHTBRIGHTNESS; + else + current_brightnes=DAYBRIGHTNESS; + + + // test to see if both buttons are being held down + // if so - start a self test till both buttons are held + // down again. + if ( digitalRead(FWDButtonPin)==BTNActive && digitalRead(REVButtonPin)==BTNActive) + { + selftestmode = !selftestmode; + if (selftestmode) Serial.println("Selftest Mode TRUE"); + else Serial.println("Selftest mode FALSE"); + } + + if (selftestmode) { + for(int i=0; i<100; i++) + { + Display1=255; Display2=255; Display3=255; delay(101-i); + ledsoff();delay(101-i); + if (digitalRead(FWDButtonPin)==1) selftestmode=!selftestmode; + + } + displaytime(); + + } + + + // test to see if a forward button is being held down + // for time setting + if (digitalRead(FWDButtonPin) ==BTNActive ) + // the forward button is down + // and it has been more than one second since we + // last looked + + { + Serial.println("Forward Button Down"); + incrementtime(); + second++; // Increment the second counter to ensure that the name + // flash doesnt happen when setting time + if (DS1302Present==1) { + // Make a new time object to set the date and time + Time t(2010, 04, 28, hour, minute, second, 01); + // Set the time and date on the chip + rtc.time(t); + } + delay(100); + displaytime(); + } + + // test to see if the back button is being held down + // for time setting + if (digitalRead(REVButtonPin)==BTNActive ) + { + + Serial.println("Backwards Button Down"); + minute--; + minute--; + second=0; // decrement the minute counter + if (minute<0) { + minute=58; + if (--hour <0) hour=23; + } + incrementtime(); + second++; // Increment the second counter to ensure that the name + // flash doesnt happen when setting time + + + if (DS1302Present==1) { + // Make a new time object to set the date and time + Time t(2010, 04, 28, hour, minute, second, 01); + // Set the time and date on the chip + rtc.time(t); + } + + displaytime(); + delay(100); + } + +} + + + +