Adurino Dot Watch

The Dot Watch is driven by an ArduinoNG with Atmega8. Dot Watch uses a 8x8 LED matrix to displace the current time. Four columns of LED matrix are used for displaying time in a 24-hour format.

• Columns 1 & 2 are used for hours.
  • Column 1 represents 5 hour increments
  • Column 2 uses 1 hour increments
• Columns 5 & 6 are used for the minutes.
  • Column 5 shows minutes in 10-minute increments
  • Column 6 flashes the minutes in 2-minute increments

Check : http://www.popsci.com/diy/article/2009-02/dot-%E2%80%A2-watch?page=1



1. Connect the LED matrix, Arduino NG and the resistors.

* Pin Assignments are as follows:
*
* 8x8 LED ----------------> Atmega8
* 1 -----------R220--------> D16 A(2): (connect to 220 ohm resistor between LED and Arduino)
* 2 --------------------------> D15 (A1) :
* 3 --------------------------> D14 (A0):
* 4 -----------R220--------> D13:
* 5 --------------------------> D12:
* 6 -----------R220--------> D11 :
* 7 --------------------------> D10 :
* 8 --------------------------> D9 :
* 9 -----------R220--------> D7 :
* 10 ---------R220--------> D6 :
* 11 ------------------------> D5 :
* 12 ------------------------> D4 :
* 13 ---------R220--------> D3 :
* 14 ------------------------> D2 :
* 15 ---------R220--------> D1 :
* 16 ---------R220--------> D0 :

2. Connect the USB cable to the Arduino NG and the computer.

3. Download the following sketch into the Arduino NG and wait for a few seconds. Dot Watch begins to work.
/* Dot Watch Code **
* Main Components:
* Atmega8
* 8x8 LED Matrix *
* Pin Assignments *
* 8x8 LED -> Atmega8
* 1 -> D16 A(2):
* 2 -> D15 (A1) :
* 3 -> D14 (A0):
* 4 -> D13:
* 5 -> D12:
* 6 -> D11 :
* 7 -> D10 :
* 8 -> D9 :
* 9 -> D7 :
* 10 -> D6 :
* 11 -> D5 :
* 12 -> D4 :
* 13 -> D3 :
* 14 -> D2 :
* 15 -> D1 :
* 16 -> D0 : *
* row # LED pin # ________________________________
*...... 0...... 5........I............................................................... I
* ......1.......1........I................................................................I
* ......2.....12........I......LED...................................................I
* ......3...... 2........I......MATRIX............................................I
* ......4.... 14........I......Ark SZ411288k..................................I
* ......5...... 3........I............................................................... I
* ......6...... 7........I............................................................... I
* ......7...... 8........I________________________________I
* .......LED pin #.......13...10...15....9....4.....16.....6.....1
* .......Col #............... 0.....1.....2....3....4.......5.....6.....7
*/
#define millisOverflow 34359738

unsigned long currentMillis = 0;
unsigned long previousMillis = 0;
int valm=0,valh=0;

int ticks = 0;
int seconds = 29;
int minutes = 58;
// The Dot Watch always starts operation @ 1258 hrs
int hours = 12;

// Set LED pins[x] for Arduino pins
int pin[17] = {-1, 16, 15, 14, 13, 12, 11, 10, 9, 7, 6, 5, 4, 3, 2, 1, 0};

// Set LED columns
int col[8] = {pin[13], pin[10], pin[15], pin[9], pin[4], pin[16], pin[6], pin[1]};

// Set LED rows
int row[8] = {pin[5], pin[11], pin[12], pin[2], pin[14], pin[3], pin[7], pin[8]};

void displayFlash() {
// Pulse four columns as seconds ticker
// Set columns 0, 3, 4, & 7 ON
digitalWrite(col[0], HIGH);
digitalWrite(col[3], HIGH);
digitalWrite(col[4], HIGH);
digitalWrite(col[7], HIGH);
//}
// Turn each row ON, then OFF
for (int i=0; i<8; 1 =" 5" 2 =" 1" 5 =" 10" 6 =" 2" displayhourscol1 =" 0;" displayhourscol2 =" 0;" displayminutescol1 =" 0;" displayminutescol2 =" 0;" displayhourscol1 =" displayHours" displayhourscol2 =" displayHours" displayminutescol1 =" displayMinutes" displayminutescol2 =" displayMinutes" displayminutescol2 =" 1;" displayminutescol2 =" 1;" displayminutescol2 =" 2;" displayminutescol2 =" 2;" displayminutescol2 =" 3;" displayminutescol2 =" 3;" displayminutescol2 =" 4;" displayminutescol2 =" 4;" displayminutescol2 =" 5;" counter="0;" dot="0;" now="" column="" 1="" for="" int="" dot="0;"><100); i="0;" i="0;" i="0;" currentmillis =" millis();" ticks =" ticks">= 60) {
minutes++;
seconds = 0;
}
if (minutes >= 60) {
hours = hours + 1;
minutes = 0;
}
if (hours > 23) {
hours = 0;
}
// Flash the watch, then display the time
if (minutes == 0){
displayFlash();
}
if (minutes == 15){
displayFlash();
}
if (minutes == 30){
displayFlash();
}
if (minutes == 45){
displayFlash();
}

displayTime(hours, minutes);

previousMillis = currentMillis;
/*
valm = analogRead(5);
// add one minute when pressed
if(valm<800) minutes="minutes+2;" seconds="0;" valh =" analogRead(4);" seconds="0;" now="" column="" 1="" for="" int="" dot="0;">); } */ }

Binary clock with Arduino

I just made a binary clock with Arduino.
see http://www.danielandrade.net/2008/07/15/binary-clock-with-arduino/





I will use 'Atmega8 with bootloader' to make a simplier one later.

Use LCD4bit with 'Atmega8 with bootloader' and LCD

1. First write 'bootloader' into Atmega8 with 'Arduino bootloader copier'.

2. Insert 'Atmega8 with bootloader' onto Arduino NG board and download LCD sketch into the Atmega8 chip.

3. Remove the Atmega8 chip from the Arduino NG board and insert the Atmega8 chip onto breadboard with LCD, 16 MHz crystal, capacitors, reset resistor, etc, as shown.

---Arduino------LCD---- LCD pin----Atmega8 pin
----------2-------enable-----6--------------4
----------7-------DB4-------11-------------13
----------8-------DB5-------12-------------14
----------9-------DB6-------13-------------15
----------10-----DB7-------14-------------16
----------12-----DI (RS)----4--------------18
---------GND---RW--------5---------------8,22
-----------------------------------------------9----->16 MHz Xtal --->22pF--->GND
-----------------------------------------------10--->16 MHz Xtal --->22pF--->GND
-----------------------------------------------1-----> 6K resistor---> 5V






4. Connect the 5V supply to the breadboard and wait for a few second for Atmega8 to reset.

IT WORKS ! ! !

Arduino AVR programmer - AVRISP

Use Arduino as a AVR programmer to burn the AVR

Circuit
Connect the Arduino Duemilanove and the AVR chip and LEDs as follows:

Arduino..............AVR................LED
Pin 13..................SCK
Pin 12..................MISO
Pin 11..................MOSI
Pin 10..................Reset
+5V......................VCC
GND.....................GND
Pin 9.............................................Communication LED.....+ 330 ohm-->GND
Pin 8.............................................Error LED....................... + 330 ohm --> GND
Pin 7.............................................Heartbeat LED...............+ 330 ohm --> GND

Upload the follwoing sketch into the Arduino Duemilanove. I am using Arduino version 0011 IDE.
// this sketch turns the Arduino into a AVRISP
// using the following pins:
// 10: slave reset
// 11: MOSI
// 12: MISO
// 13: SCK

// Put an LED (with resistor) on the following pins:
// 9: Heartbeat - shows the programmer is running
// 8: Error - Lights up if something goes wrong (use red if that makes sense)
// 7: Programming - In communication with the slave
//
// February 2009 by Randall Bohn
// - Added support for writing to EEPROM (what took so long?)
// Windows users should consider WinAVR's avrdude instead of the
// avrdude included with Arduino software.
//
// January 2008 by Randall Bohn
// - Thanks to Amplificar for helping me with the STK500 protocol
// - The AVRISP/STK500 (mk I) protocol is used in the arduino bootloader
// - The SPI functions herein were developed for the AVR910_ARD programmer
// - More information at http://code.google.com/p/mega-isp

#define SCK 13
#define MISO 12
#define MOSI 11
#define RESET 10

#define LED_HB 9
#define LED_ERR 8
#define LED_PMODE 7

#define HWVER 2
#define SWMAJ 1
#define SWMIN 18

// STK Definitions
#define STK_OK 0x10
#define STK_FAILED 0x11
#define STK_UNKNOWN 0x12
#define STK_INSYNC 0x14
#define STK_NOSYNC 0x15
#define CRC_EOP 0x20 //ok it is a space...

void pulse(int pin, int times);

void setup() {
// 19200?
Serial.begin(19200);
pinMode(7, OUTPUT);
pulse(7, 2);
pinMode(8, OUTPUT);
pulse(8, 2);
pinMode(9, OUTPUT);
pulse(9, 2);
}

int error=0;
int pmode=0;
// address for reading and writing, set by 'U' command
int here;
uint8_t buff[256]; // global block storage

#define beget16(addr) (*addr * 256 + *(addr+1) )
typedef struct param {
uint8_t devicecode;
uint8_t revision;
uint8_t progtype;
uint8_t parmode;
uint8_t polling;
uint8_t selftimed;
uint8_t lockbytes;
uint8_t fusebytes;
int flashpoll;
int eeprompoll;
int pagesize;
int eepromsize;
int flashsize;
}
parameter;

parameter param;

// this provides a heartbeat on pin 9, so you can tell the software is running.
uint8_t hbval=128;
int8_t hbdelta=8;
void heartbeat() {
if (hbval > 192) hbdelta = -hbdelta;
if (hbval < hbdelta =" -hbdelta;" x =" 0;" spcr =" 0x53;" x="SPSR;" x="SPDR;" spdr="b;" reply =" SPDR;" n="spi_send(b);" error =" -1;" n="spi_send(c);" crc_eop ="=" crc_eop ="=" devicecode =" buff[0];" revision =" buff[1];" progtype =" buff[2];" parmode =" buff[3];" polling =" buff[4];" selftimed =" buff[5];" lockbytes =" buff[6];" fusebytes =" buff[7];" flashpoll =" buff[8];" eeprompoll =" beget16(&buff[10]);" pagesize =" beget16(&buff[12]);" eepromsize =" beget16(&buff[14]);" flashsize =" buff[16]" pmode =" 1;" pmode =" 0;" w =" 0;" ch =" spi_transaction(buff[0],">>8 & 0xFF,
addr & 0xFF,
data);
}
void commit(int addr) {
spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0);
}

//#define _current_page(x) (here & 0xFFFFE0)
int current_page(int addr) {
if (param.pagesize == 32) return here & 0xFFFFFFF0;
if (param.pagesize == 64) return here & 0xFFFFFFE0;
if (param.pagesize == 128) return here & 0xFFFFFFC0;
if (param.pagesize == 256) return here & 0xFFFFFF80;
return here;
}
uint8_t write_flash(int length) {
if (param.pagesize < page =" current_page(here);" x =" 0;" page =" current_page(here);" x =" 0;" result =" (char)" length =" 256"> 256) {
Serial.print((char) STK_FAILED);
return;
}
char memtype = getch();
for (int x = 0; x < crc_eop ="=" memtype ="=" result =" (char)write_flash(length);" memtype ="=" result =" (char)write_eeprom(length);">> 8) & 0xFF,
addr & 0xFF,
0);
}

char flash_read_page(int length) {
for (int x = 0; x < low =" flash_read(LOW," high =" flash_read(HIGH," x =" 0;" ee =" spi_transaction(0xA0," result =" (char)STK_FAILED;" length =" 256" memtype =" getch();" memtype ="=" result =" flash_read_page(length);" memtype ="=" result =" eeprom_read_page(length);" ch =" getch();" here =" getch()" low =" getch();" high =" getch();" data =" getch();" error="0;" crc_eop ="=">

You can start using AVRDUDE with this Arduino Duemilanove. First you need to know which port the Arduino is using. Mine is on port com5. You can run the following command line and read the device signature (0×1e910a).

> avrdude -P com5 -p t2313 -c avrisp -b 19200 -u -t

Enter ’sig’ to view the device signature again:

avrdude> sig
Reading | ################################## | 100% 0.02s
Device signature = 0×1e910a

Congratuation ! You have constructed an AVR programmer !!!

You can then develop your program using CodeVisionAVR and debug/simulate the program using AVRStudio.

The program can then be transform into HEX file by CodeVisionAVR.

The HEX file can then be written into the flash of the AVR (e.g. ATTINY2313) using AVRDUDE.

Type the following command line to write the program 'XXXX.hex' into the flash of t2313
> avrdude -P com5 -p t2313 -c avrisp -b 19200 -U flash:w:XXXX.hex
see tutorial in using avrdude : - http://www.ladyada.net/learn/avr/avrdude.html


Check also: - http://www.uchobby.com/index.php/2007/11/04/arduino-avr-in-system-programmer-isp/