/trunk/libraries/AdafruitRTClib/RTClib.cpp |
---|
0,0 → 1,240 |
// Code by JeeLabs http://news.jeelabs.org/code/ |
// Released to the public domain! Enjoy! |
#include <Wire.h> |
#include <avr/pgmspace.h> |
#include "RTClib.h" |
#define DS1307_ADDRESS 0x68 |
#define SECONDS_PER_DAY 86400L |
#define SECONDS_FROM_1970_TO_2000 946684800 |
#if (ARDUINO >= 100) |
#include <Arduino.h> // capital A so it is error prone on case-sensitive filesystems |
#else |
#include <WProgram.h> |
#endif |
int i = 0; //The new wire library needs to take an int when you are sending for the zero register |
//////////////////////////////////////////////////////////////////////////////// |
// utility code, some of this could be exposed in the DateTime API if needed |
const uint8_t daysInMonth [] PROGMEM = { 31,28,31,30,31,30,31,31,30,31,30,31 }; //has to be const or compiler compaints |
// number of days since 2000/01/01, valid for 2001..2099 |
static uint16_t date2days(uint16_t y, uint8_t m, uint8_t d) { |
if (y >= 2000) |
y -= 2000; |
uint16_t days = d; |
for (uint8_t i = 1; i < m; ++i) |
days += pgm_read_byte(daysInMonth + i - 1); |
if (m > 2 && y % 4 == 0) |
++days; |
return days + 365 * y + (y + 3) / 4 - 1; |
} |
static long time2long(uint16_t days, uint8_t h, uint8_t m, uint8_t s) { |
return ((days * 24L + h) * 60 + m) * 60 + s; |
} |
//////////////////////////////////////////////////////////////////////////////// |
// DateTime implementation - ignores time zones and DST changes |
// NOTE: also ignores leap seconds, see http://en.wikipedia.org/wiki/Leap_second |
DateTime::DateTime (uint32_t t) { |
t -= SECONDS_FROM_1970_TO_2000; // bring to 2000 timestamp from 1970 |
ss = t % 60; |
t /= 60; |
mm = t % 60; |
t /= 60; |
hh = t % 24; |
uint16_t days = t / 24; |
uint8_t leap; |
for (yOff = 0; ; ++yOff) { |
leap = yOff % 4 == 0; |
if (days < 365 + leap) |
break; |
days -= 365 + leap; |
} |
for (m = 1; ; ++m) { |
uint8_t daysPerMonth = pgm_read_byte(daysInMonth + m - 1); |
if (leap && m == 2) |
++daysPerMonth; |
if (days < daysPerMonth) |
break; |
days -= daysPerMonth; |
} |
d = days + 1; |
} |
DateTime::DateTime (uint16_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t min, uint8_t sec) { |
if (year >= 2000) |
year -= 2000; |
yOff = year; |
m = month; |
d = day; |
hh = hour; |
mm = min; |
ss = sec; |
} |
static uint8_t conv2d(const char* p) { |
uint8_t v = 0; |
if ('0' <= *p && *p <= '9') |
v = *p - '0'; |
return 10 * v + *++p - '0'; |
} |
// A convenient constructor for using "the compiler's time": |
// DateTime now (__DATE__, __TIME__); |
// NOTE: using PSTR would further reduce the RAM footprint |
DateTime::DateTime (const char* date, const char* time) { |
// sample input: date = "Dec 26 2009", time = "12:34:56" |
yOff = conv2d(date + 9); |
// Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec |
switch (date[0]) { |
case 'J': m = date[1] == 'a' ? 1 : m = date[2] == 'n' ? 6 : 7; break; |
case 'F': m = 2; break; |
case 'A': m = date[2] == 'r' ? 4 : 8; break; |
case 'M': m = date[2] == 'r' ? 3 : 5; break; |
case 'S': m = 9; break; |
case 'O': m = 10; break; |
case 'N': m = 11; break; |
case 'D': m = 12; break; |
} |
d = conv2d(date + 4); |
hh = conv2d(time); |
mm = conv2d(time + 3); |
ss = conv2d(time + 6); |
} |
uint8_t DateTime::dayOfWeek() const { |
uint16_t day = date2days(yOff, m, d); |
return (day + 6) % 7; // Jan 1, 2000 is a Saturday, i.e. returns 6 |
} |
uint32_t DateTime::unixtime(void) const { |
uint32_t t; |
uint16_t days = date2days(yOff, m, d); |
t = time2long(days, hh, mm, ss); |
t += SECONDS_FROM_1970_TO_2000; // seconds from 1970 to 2000 |
return t; |
} |
//////////////////////////////////////////////////////////////////////////////// |
// RTC_DS1307 implementation |
static uint8_t bcd2bin (uint8_t val) { return val - 6 * (val >> 4); } |
static uint8_t bin2bcd (uint8_t val) { return val + 6 * (val / 10); } |
uint8_t RTC_DS1307::begin(void) { |
return 1; |
} |
#if (ARDUINO >= 100) |
uint8_t RTC_DS1307::isrunning(void) { |
Wire.beginTransmission(DS1307_ADDRESS); |
Wire.write(i); |
Wire.endTransmission(); |
Wire.requestFrom(DS1307_ADDRESS, 1); |
uint8_t ss = Wire.read(); |
return !(ss>>7); |
} |
void RTC_DS1307::adjust(const DateTime& dt) { |
Wire.beginTransmission(DS1307_ADDRESS); |
Wire.write(i); |
Wire.write(bin2bcd(dt.second())); |
Wire.write(bin2bcd(dt.minute())); |
Wire.write(bin2bcd(dt.hour())); |
Wire.write(bin2bcd(0)); |
Wire.write(bin2bcd(dt.day())); |
Wire.write(bin2bcd(dt.month())); |
Wire.write(bin2bcd(dt.year() - 2000)); |
Wire.write(i); |
Wire.endTransmission(); |
} |
DateTime RTC_DS1307::now() { |
Wire.beginTransmission(DS1307_ADDRESS); |
Wire.write(i); |
Wire.endTransmission(); |
Wire.requestFrom(DS1307_ADDRESS, 7); |
uint8_t ss = bcd2bin(Wire.read() & 0x7F); |
uint8_t mm = bcd2bin(Wire.read()); |
uint8_t hh = bcd2bin(Wire.read()); |
Wire.read(); |
uint8_t d = bcd2bin(Wire.read()); |
uint8_t m = bcd2bin(Wire.read()); |
uint16_t y = bcd2bin(Wire.read()) + 2000; |
return DateTime (y, m, d, hh, mm, ss); |
} |
#else |
uint8_t RTC_DS1307::isrunning(void) { |
Wire.beginTransmission(DS1307_ADDRESS); |
Wire.send(i); |
Wire.endTransmission(); |
Wire.requestFrom(DS1307_ADDRESS, 1); |
uint8_t ss = Wire.receive(); |
return !(ss>>7); |
} |
void RTC_DS1307::adjust(const DateTime& dt) { |
Wire.beginTransmission(DS1307_ADDRESS); |
Wire.send(i); |
Wire.send(bin2bcd(dt.second())); |
Wire.send(bin2bcd(dt.minute())); |
Wire.send(bin2bcd(dt.hour())); |
Wire.send(bin2bcd(0)); |
Wire.send(bin2bcd(dt.day())); |
Wire.send(bin2bcd(dt.month())); |
Wire.send(bin2bcd(dt.year() - 2000)); |
Wire.send(i); |
Wire.endTransmission(); |
} |
DateTime RTC_DS1307::now() { |
Wire.beginTransmission(DS1307_ADDRESS); |
Wire.send(i); |
Wire.endTransmission(); |
Wire.requestFrom(DS1307_ADDRESS, 7); |
uint8_t ss = bcd2bin(Wire.receive() & 0x7F); |
uint8_t mm = bcd2bin(Wire.receive()); |
uint8_t hh = bcd2bin(Wire.receive()); |
Wire.receive(); |
uint8_t d = bcd2bin(Wire.receive()); |
uint8_t m = bcd2bin(Wire.receive()); |
uint16_t y = bcd2bin(Wire.receive()) + 2000; |
return DateTime (y, m, d, hh, mm, ss); |
} |
#endif |
//////////////////////////////////////////////////////////////////////////////// |
// RTC_Millis implementation |
long RTC_Millis::offset = 0; |
void RTC_Millis::adjust(const DateTime& dt) { |
offset = dt.unixtime() - millis() / 1000; |
} |
DateTime RTC_Millis::now() { |
return (uint32_t)(offset + millis() / 1000); |
} |
//////////////////////////////////////////////////////////////////////////////// |
/trunk/libraries/AdafruitRTClib/RTClib.h |
---|
0,0 → 1,47 |
// Code by JeeLabs http://news.jeelabs.org/code/ |
// Released to the public domain! Enjoy! |
// Simple general-purpose date/time class (no TZ / DST / leap second handling!) |
class DateTime { |
public: |
DateTime (uint32_t t =0); |
DateTime (uint16_t year, uint8_t month, uint8_t day, |
uint8_t hour =0, uint8_t min =0, uint8_t sec =0); |
DateTime (const char* date, const char* time); |
uint16_t year() const { return 2000 + yOff; } |
uint8_t month() const { return m; } |
uint8_t day() const { return d; } |
uint8_t hour() const { return hh; } |
uint8_t minute() const { return mm; } |
uint8_t second() const { return ss; } |
uint8_t dayOfWeek() const; |
// 32-bit times as seconds since 1/1/2000 |
long secondstime() const; |
// 32-bit times as seconds since 1/1/1970 |
uint32_t unixtime(void) const; |
protected: |
uint8_t yOff, m, d, hh, mm, ss; |
}; |
// RTC based on the DS1307 chip connected via I2C and the Wire library |
class RTC_DS1307 { |
public: |
static uint8_t begin(void); |
static void adjust(const DateTime& dt); |
uint8_t isrunning(void); |
static DateTime now(); |
}; |
// RTC using the internal millis() clock, has to be initialized before use |
// NOTE: this clock won't be correct once the millis() timer rolls over (>49d?) |
class RTC_Millis { |
public: |
static void begin(const DateTime& dt) { adjust(dt); } |
static void adjust(const DateTime& dt); |
static DateTime now(); |
protected: |
static long offset; |
}; |
/trunk/libraries/AdafruitRTClib/keywords.txt |
---|
0,0 → 1,34 |
####################################### |
# Syntax Coloring Map For RTC |
####################################### |
####################################### |
# Datatypes (KEYWORD1) |
####################################### |
DateTime KEYWORD1 |
RTC_DS1307 KEYWORD1 |
RTC_Millis KEYWORD1 |
####################################### |
# Methods and Functions (KEYWORD2) |
####################################### |
year KEYWORD2 |
month KEYWORD2 |
day KEYWORD2 |
hour KEYWORD2 |
minute KEYWORD2 |
second KEYWORD2 |
dayOfWeek KEYWORD2 |
secondstime KEYWORD2 |
unixtime KEYWORD2 |
begin KEYWORD2 |
adjust KEYWORD2 |
isrunning KEYWORD2 |
now KEYWORD2 |
####################################### |
# Constants (LITERAL1) |
####################################### |
/trunk/libraries/AdafruitRTClib/examples/datecalc/datecalc.pde |
---|
0,0 → 1,65 |
// Simple date conversions and calculations |
#include <Wire.h> |
#include "RTClib.h" |
void showDate(const char* txt, const DateTime& dt) { |
Serial.print(txt); |
Serial.print(' '); |
Serial.print(dt.year(), DEC); |
Serial.print('/'); |
Serial.print(dt.month(), DEC); |
Serial.print('/'); |
Serial.print(dt.day(), DEC); |
Serial.print(' '); |
Serial.print(dt.hour(), DEC); |
Serial.print(':'); |
Serial.print(dt.minute(), DEC); |
Serial.print(':'); |
Serial.print(dt.second(), DEC); |
Serial.print(" = "); |
Serial.print(dt.unixtime()); |
Serial.print("s / "); |
Serial.print(dt.unixtime() / 86400L); |
Serial.print("d since 1970"); |
Serial.println(); |
} |
void setup () { |
Serial.begin(57600); |
DateTime dt0 (0, 1, 1, 0, 0, 0); |
showDate("dt0", dt0); |
DateTime dt1 (1, 1, 1, 0, 0, 0); |
showDate("dt1", dt1); |
DateTime dt2 (2009, 1, 1, 0, 0, 0); |
showDate("dt2", dt2); |
DateTime dt3 (2009, 1, 2, 0, 0, 0); |
showDate("dt3", dt3); |
DateTime dt4 (2009, 1, 27, 0, 0, 0); |
showDate("dt4", dt4); |
DateTime dt5 (2009, 2, 27, 0, 0, 0); |
showDate("dt5", dt5); |
DateTime dt6 (2009, 12, 27, 0, 0, 0); |
showDate("dt6", dt6); |
DateTime dt7 (dt6.unixtime() + 3600); // one hour later |
showDate("dt7", dt7); |
DateTime dt8 (dt6.unixtime() + 86400L); // one day later |
showDate("dt8", dt8); |
DateTime dt9 (dt6.unixtime() + 7 * 86400L); // one week later |
showDate("dt9", dt9); |
} |
void loop () { |
} |
/trunk/libraries/AdafruitRTClib/examples/ds1307/ds1307.pde |
---|
0,0 → 1,61 |
// Date and time functions using a DS1307 RTC connected via I2C and Wire lib |
#include <Wire.h> |
#include "RTClib.h" |
RTC_DS1307 RTC; |
void setup () { |
Serial.begin(57600); |
Wire.begin(); |
RTC.begin(); |
if (! RTC.isrunning()) { |
Serial.println("RTC is NOT running!"); |
// following line sets the RTC to the date & time this sketch was compiled |
RTC.adjust(DateTime(__DATE__, __TIME__)); |
} |
} |
void loop () { |
DateTime now = RTC.now(); |
Serial.print(now.year(), DEC); |
Serial.print('/'); |
Serial.print(now.month(), DEC); |
Serial.print('/'); |
Serial.print(now.day(), DEC); |
Serial.print(' '); |
Serial.print(now.hour(), DEC); |
Serial.print(':'); |
Serial.print(now.minute(), DEC); |
Serial.print(':'); |
Serial.print(now.second(), DEC); |
Serial.println(); |
Serial.print(" since midnight 1/1/1970 = "); |
Serial.print(now.unixtime()); |
Serial.print("s = "); |
Serial.print(now.unixtime() / 86400L); |
Serial.println("d"); |
// calculate a date which is 7 days and 30 seconds into the future |
DateTime future (now.unixtime() + 7 * 86400L + 30); |
Serial.print(" now + 7d + 30s: "); |
Serial.print(future.year(), DEC); |
Serial.print('/'); |
Serial.print(future.month(), DEC); |
Serial.print('/'); |
Serial.print(future.day(), DEC); |
Serial.print(' '); |
Serial.print(future.hour(), DEC); |
Serial.print(':'); |
Serial.print(future.minute(), DEC); |
Serial.print(':'); |
Serial.print(future.second(), DEC); |
Serial.println(); |
Serial.println(); |
delay(3000); |
} |
/trunk/libraries/AdafruitRTClib/examples/softrtc/softrtc.pde |
---|
0,0 → 1,52 |
// Date and time functions using just software, based on millis() & timer |
#include <Wire.h> |
#include "RTClib.h" |
RTC_Millis RTC; |
void setup () { |
Serial.begin(57600); |
// following line sets the RTC to the date & time this sketch was compiled |
RTC.begin(DateTime(__DATE__, __TIME__)); |
} |
void loop () { |
DateTime now = RTC.now(); |
Serial.print(now.year(), DEC); |
Serial.print('/'); |
Serial.print(now.month(), DEC); |
Serial.print('/'); |
Serial.print(now.day(), DEC); |
Serial.print(' '); |
Serial.print(now.hour(), DEC); |
Serial.print(':'); |
Serial.print(now.minute(), DEC); |
Serial.print(':'); |
Serial.print(now.second(), DEC); |
Serial.println(); |
Serial.print(" seconds since 1970: "); |
Serial.println(now.unixtime()); |
// calculate a date which is 7 days and 30 seconds into the future |
DateTime future (now.unixtime() + 7 * 86400L + 30); |
Serial.print(" now + 7d + 30s: "); |
Serial.print(future.year(), DEC); |
Serial.print('/'); |
Serial.print(future.month(), DEC); |
Serial.print('/'); |
Serial.print(future.day(), DEC); |
Serial.print(' '); |
Serial.print(future.hour(), DEC); |
Serial.print(':'); |
Serial.print(future.minute(), DEC); |
Serial.print(':'); |
Serial.print(future.second(), DEC); |
Serial.println(); |
Serial.println(); |
delay(3000); |
} |
/trunk/libraries/SnootlabDeuligne/Deuligne.h |
---|
0,0 → 1,140 |
/* |
* Deuligne.h |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
*/ |
#ifndef SNOOTLCDI2C_h |
#define SNOOTLCDI2C_h |
#if defined(ARDUINO) && ARDUINO >= 100 |
#define SNOOT_RETURN size_t |
#define SNOOT_WIREWRITE Wire.write |
#else |
#define SNOOT_RETURN void |
#define SNOOT_WIREWRITE Wire.send |
#endif |
#include <inttypes.h> |
#include <Print.h> |
// commands |
#define LCD_CLEARDISPLAY 0x01 |
#define LCD_RETURNHOME 0x02 |
#define LCD_ENTRYMODESET 0x04 |
#define LCD_DISPLAYCONTROL 0x08 |
#define LCD_CURSORSHIFT 0x10 |
#define LCD_FUNCTIONSET 0x20 |
#define LCD_SETCGRAMADDR 0x40 |
#define LCD_SETDDRAMADDR 0x80 |
// flags for display entry mode |
#define LCD_ENTRYRIGHT 0x00 |
#define LCD_ENTRYLEFT 0x02 |
#define LCD_ENTRYSHIFTINCREMENT 0x01 |
#define LCD_ENTRYSHIFTDECREMENT 0x00 |
// flags for display on/off control |
#define LCD_DISPLAYON 0x04 |
#define LCD_DISPLAYOFF 0x00 |
#define LCD_CURSORON 0x02 |
#define LCD_CURSOROFF 0x00 |
#define LCD_BLINKON 0x01 |
#define LCD_BLINKOFF 0x00 |
// flags for display/cursor shift |
#define LCD_DISPLAYMOVE 0x08 |
#define LCD_CURSORMOVE 0x00 |
#define LCD_MOVERIGHT 0x04 |
#define LCD_MOVELEFT 0x00 |
// flags for function set |
#define LCD_8BITMODE 0x10 |
#define LCD_4BITMODE 0x00 |
#define LCD_2LINE 0x08 |
#define LCD_1LINE 0x00 |
#define LCD_5x11DOTS 0x04 |
#define LCD_5x8DOTS 0x00 |
// overclcking I2C |
#define CPU_FREQ 16000000L // (...) - a discuter, car fonction vitesse clock cpu |
#define TWI_FREQ_MCP23008 400000L |
// IMPORTANT! Wire. must have a begin() before calling init() |
class Deuligne : public Print { |
public: |
Deuligne(int devI2CAddress=0xA7, int num_lines=2, int lcdwidth=16, int bufferwidth= 40); |
void commandWrite(int command); |
void init(); |
void clear(); |
void begin(uint8_t cols, uint8_t rows, uint8_t charsize = LCD_5x8DOTS); |
virtual SNOOT_RETURN write(uint8_t); |
// virtual void print(uint8_t); |
// virtual void printIn(uint8_t*); |
void backLight( bool turnOn ); |
//non-core--------------- |
//void cursorTo(int line_num, int x); |
void setCursor(uint8_t col, uint8_t row); |
//{cursorTo(n,x);} |
//void leftScroll(int chars, int delay_time); |
//end of non-core-------- |
//4bit only, therefore ideally private but may be needed by user |
//void commandWriteNibble(int nibble); |
// virtual void print(int value){print((uint8_t)value);} |
// virtual void printIn(char value[]){print((uint8_t*)value);} |
/** |
* from LiquidCrystal (official arduino) Library |
***/ |
void createChar(uint8_t, uint8_t[]); |
void command(uint8_t); |
void home(); |
void noDisplay(); |
void display(); |
void noBlink(); |
void blink(); |
void noCursor(); |
void cursor(); |
void scrollDisplayLeft(); |
void scrollDisplayRight(); |
void leftToRight(); |
void rightToLeft(); |
void autoscroll(); |
void noAutoscroll(); |
int get_key(); |
private: |
//void pulseEnablePin(); |
//void pushNibble(int nibble); |
//void pushByte(int value); |
int myNumLines; |
int myWidth; |
int myAddress; |
int myBufferwidth; |
int adc_key_in; |
// int adc_key_val[5]; |
int NUM_KEYS; |
uint8_t _displayfunction; |
uint8_t _displaycontrol; |
uint8_t _displaymode; |
}; |
#endif |
/trunk/libraries/SnootlabDeuligne/keywords.txt |
---|
0,0 → 1,37 |
####################################### |
# Syntax Coloring Map For Deuligne |
####################################### |
####################################### |
# Datatypes (KEYWORD1) |
####################################### |
Deuligne KEYWORD1 |
####################################### |
# Methods and Functions (KEYWORD2) |
####################################### |
# begin KEYWORD2 |
clear KEYWORD2 |
home KEYWORD2 |
print KEYWORD2 |
setCursor KEYWORD2 |
cursor KEYWORD2 |
noCursor KEYWORD2 |
blink KEYWORD2 |
noBlink KEYWORD2 |
display KEYWORD2 |
noDisplay KEYWORD2 |
autoscroll KEYWORD2 |
noAutoscroll KEYWORD2 |
leftToRight KEYWORD2 |
rightToLeft KEYWORD2 |
scrollDisplayLeft KEYWORD2 |
scrollDisplayRight KEYWORD2 |
backLight KEYWORD2 |
createChar KEYWORD2 |
####################################### |
# Constants (LITERAL1) |
####################################### |
/trunk/libraries/SnootlabDeuligne/README.md |
---|
0,0 → 1,33 |
# Requirements |
* Arduino: http://arduino.cc |
# Hardware |
Connect the following pins from MCP23008 to LCD |
* P0 - D4 |
* P1 - D5 |
* P2 - D6 |
* P3 - D7 |
* P4 - RS |
* P5 - RW (not used, set to 0 to ground for write) |
* P6 - Bl (backlight switch) |
* P7 - E |
# Install |
## on Mac |
### Using Finder |
* In Finder, go to "_Documents_", create folder "_Arduino_" inside, and create folder "_libraries_" inside "_Arduino_" folder |
* Download [Deuligne lib](http://github.com/Snootlab/Deuligne/zipball/master), and copy unzipped content - should be a folder named Snootlab-Deuligne-xxxx - to "_libraries_" folder |
### Using Terminal |
Copy Deuligne lib in your sketchbook, with the default path set in Arduino preferences: |
git clone https://github.com/Snootlab/Deuligne.git |
mkdir -p ~/Documents/Arduino/libraries/ |
ln -sf Deuligne ~/Documents/Arduino/libraries/Deuligne |
/trunk/libraries/SnootlabDeuligne/Deuligne.cpp |
---|
0,0 → 1,265 |
/*** |
* |
* |
* Deuligne library |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
**/ |
#include "Deuligne.h" |
#include <Wire.h> |
extern "C" { |
#include <stdio.h> //not needed yet |
#include <string.h> //needed for strlen() |
#include <inttypes.h> |
#if defined(ARDUINO) &&ARDUINO < 100 |
#include "WConstants.h" //all things wiring / arduino |
#endif |
} |
#if defined(ARDUINO) && ARDUINO >= 100 |
#include "Arduino.h" |
#endif |
//command bytes for LCD |
#define CMD_CLR 0x01 |
#define CMD_RIGHT 0x1C |
#define CMD_LEFT 0x18 |
#define CMD_HOME 0x02 |
//stuff the library user might call--------------------------------- |
//constructor. num_lines must be 1 or 2, currently. |
byte dataPlusMask = 0x20; // TODO!!! |
int adc_key_val[5] ={ |
50, 190, 400, 540, 770 }; |
Deuligne::Deuligne( int devI2CAddress, int num_lines, int lcdwidth, int bufferwidth) { |
myNumLines = num_lines; |
myWidth = lcdwidth; |
myAddress = devI2CAddress; |
myBufferwidth= bufferwidth; |
NUM_KEYS = 5; |
} |
void SetMCPReg( byte deviceAddr, byte reg, byte val ) { |
Wire.beginTransmission(deviceAddr); |
SNOOT_WIREWRITE(reg); |
SNOOT_WIREWRITE(val); |
Wire.endTransmission(); |
} |
void SendToLCD( byte deviceAddr, byte data ) { |
data |= dataPlusMask; |
SetMCPReg(deviceAddr,0x0A,data); |
data ^= 0x10; // E |
delayMicroseconds(1); |
SetMCPReg(deviceAddr,0x0A,data); |
data ^= 0x10; // E |
delayMicroseconds(1); |
SetMCPReg(deviceAddr,0x0A,data); |
delay(1); |
} |
void WriteLCDByte( byte deviceAddr, byte bdata ) { |
SendToLCD(deviceAddr,bdata >> 4); |
SendToLCD(deviceAddr,bdata & 0x0F); |
} |
void Deuligne::init( void ) { |
TWBR = ((CPU_FREQ / TWI_FREQ_MCP23008) - 16) / 2; |
dataPlusMask = 0; // initial: 0 |
SetMCPReg(myAddress,0x05,0x0C); // set CONFREG (0x05) to 0 |
SetMCPReg(myAddress,0x00,0x00); // set IOREG (0x00) to 0 |
// |
delay(50); |
SendToLCD(myAddress,0x03); |
delay(5); |
SendToLCD(myAddress,0x03); |
delayMicroseconds(100); |
SendToLCD(myAddress,0x03); |
delay(5); |
SendToLCD(myAddress,0x02); |
WriteLCDByte(myAddress,0x28); |
WriteLCDByte(myAddress,0x08); |
WriteLCDByte(myAddress,0x0C); // turn on, cursor off, no blinking |
delayMicroseconds(60); |
WriteLCDByte(myAddress,LCD_CLEARDISPLAY); // clear display |
delay(3); |
_displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF; |
// Initialize to default text direction (for romance languages) |
_displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT; |
// set the entry mode |
command(LCD_ENTRYMODESET | _displaymode); |
backLight(1); |
display(); |
} |
void Deuligne::backLight( bool turnOn ) { |
dataPlusMask |= 0x80; // Lights mask |
if (!turnOn) dataPlusMask ^= 0x80; |
SetMCPReg(myAddress,0x0A,dataPlusMask); |
} |
SNOOT_RETURN Deuligne::write( uint8_t value ) { |
dataPlusMask |= 0x40; // RS |
WriteLCDByte(myAddress,(byte)value); |
dataPlusMask ^= 0x40; // RS |
} |
/* |
void Deuligne::printIn( char value[] ) { |
for ( char *p = value; *p != 0; p++ ) |
print(*p); |
} |
*/ |
void Deuligne::clear() { |
command(CMD_CLR); |
} |
void Deuligne::begin(uint8_t cols, uint8_t lines, uint8_t dotsize) { |
} |
void Deuligne::setCursor(uint8_t col, uint8_t row) { |
int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 }; |
if ( row > myNumLines ) { |
row = myNumLines-1; // we count rows starting w/0 |
} |
command(LCD_SETDDRAMADDR | (col + row_offsets[row])); |
} |
/* |
void Deuligne::cursorTo(int line_num, int x) { |
command(CMD_HOME); |
int targetPos = x + line_num * myBufferwidth; |
for ( int i = 0; i < targetPos; i++) |
command(0x14); |
}*/ |
void Deuligne::command( uint8_t command ) { |
// RS - leave low |
WriteLCDByte(myAddress,command); |
delay(1); |
} |
/** |
* From LiquidCrystal (official arduino) Library |
**/ |
// Allows us to fill the first 8 CGRAM locations |
// with custom characters |
void Deuligne::createChar(uint8_t location, uint8_t charmap[]) { |
location &= 0x7; // we only have 8 locations 0-7 |
command(LCD_SETCGRAMADDR | (location << 3)); |
for (int i=0; i<8; i++) { |
write(charmap[i]); |
} |
} |
// Turn the display on/off (quickly) |
void Deuligne::noDisplay() { |
_displaycontrol &= ~LCD_DISPLAYON; |
command(LCD_DISPLAYCONTROL | _displaycontrol); |
} |
void Deuligne::display() { |
_displaycontrol |= LCD_DISPLAYON; |
command(LCD_DISPLAYCONTROL | _displaycontrol); |
} |
// Turns the underline cursor on/off |
void Deuligne::noCursor() { |
_displaycontrol &= ~LCD_CURSORON; |
command(LCD_DISPLAYCONTROL | _displaycontrol); |
} |
void Deuligne::cursor() { |
_displaycontrol |= LCD_CURSORON; |
command(LCD_DISPLAYCONTROL | _displaycontrol); |
} |
// Turn on and off the blinking cursor |
void Deuligne::noBlink() { |
_displaycontrol &= ~LCD_BLINKON; |
command(LCD_DISPLAYCONTROL | _displaycontrol); |
} |
void Deuligne::blink() { |
_displaycontrol |= LCD_BLINKON; |
command(LCD_DISPLAYCONTROL | _displaycontrol); |
} |
// These commands scroll the display without changing the RAM |
void Deuligne::scrollDisplayLeft(void) { |
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT); |
} |
void Deuligne::scrollDisplayRight(void) { |
command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT); |
} |
// This is for text that flows Left to Right |
void Deuligne::leftToRight(void) { |
_displaymode |= LCD_ENTRYLEFT; |
command(LCD_ENTRYMODESET | _displaymode); |
} |
// This is for text that flows Right to Left |
void Deuligne::rightToLeft(void) { |
_displaymode &= ~LCD_ENTRYLEFT; |
command(LCD_ENTRYMODESET | _displaymode); |
} |
// This will 'right justify' text from the cursor |
void Deuligne::autoscroll(void) { |
_displaymode |= LCD_ENTRYSHIFTINCREMENT; |
command(LCD_ENTRYMODESET | _displaymode); |
} |
// This will 'left justify' text from the cursor |
void Deuligne::noAutoscroll(void) { |
_displaymode &= ~LCD_ENTRYSHIFTINCREMENT; |
command(LCD_ENTRYMODESET | _displaymode); |
} |
void Deuligne::home() |
{ |
command(LCD_RETURNHOME); // set cursor position to zero |
delayMicroseconds(2000); // this command takes a long time! |
} |
// Get Joystick value |
// Convert ADC value to key number : |
// 0: Right Key |
// 1: Up Key |
// 2: Down Key |
// 3: Left Key |
// 4: Select Key |
int Deuligne::get_key(){ |
adc_key_in = analogRead(0); // read the value from the sensor |
int k; |
// determine which key is pressed |
for (k = 0; k < NUM_KEYS; k++) |
{ |
if (adc_key_in < adc_key_val[k]) |
{ |
return k; |
} |
} |
if (k >= NUM_KEYS) |
k = -1; // No valid key pressed |
return k; |
} |
/trunk/libraries/SnootlabDeuligne/examples/Blink/Blink.pde |
---|
0,0 → 1,56 |
/* |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on official arduino LiquidCrystal Library |
- Blink |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch prints "Hello World!" to the LCD and makes the |
cursor block blink. |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include "Wire.h" |
#include <Deuligne.h> |
// initialize the library with the numbers of the interface pins |
Deuligne lcd; |
void setup() { |
// set up the LCD's number of columns and rows: |
lcd.init(); |
// Print a message to the LCD. |
lcd.print("hello, world!"); |
} |
void loop() { |
// Turn off the blinking cursor: |
lcd.noBlink(); |
delay(3000); |
// Turn on the blinking cursor: |
lcd.blink(); |
delay(3000); |
} |
/trunk/libraries/SnootlabDeuligne/examples/Smiley/Smiley.pde |
---|
0,0 → 1,44 |
/* |
* Smiley |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
* Demo for custom characters on LCD display |
* Should display a simple :) on top left corner |
*/ |
#include <Wire.h> |
#include <Deuligne.h> |
Deuligne lcd; |
// Custom caracter, 5 significant bits for each byte |
byte smiley [8]={ |
B00000, |
B10001, |
B00000, |
B00000, |
B10001, |
B01110, |
B00000 |
}; |
void setup(){ |
Wire.begin(); |
lcd.init(); |
lcd.createChar(0,smiley); |
lcd.setCursor(0,0); // need to re-position after createChar |
lcd.write(0); |
} |
void loop(){ |
// Switch backlight every second |
lcd.backLight(true); |
delay(1000); |
lcd.backLight(false); |
delay(1000); |
} |
/trunk/libraries/SnootlabDeuligne/examples/Display/Display.pde |
---|
0,0 → 1,66 |
/* |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on official arduino LiquidCrystal Library |
- display() and noDisplay() |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch prints "Hello World!" to the LCD and uses the |
display() and noDisplay() functions to turn on and off |
the display. |
The circuit: |
* LCD RS pin to digital pin 12 |
* LCD Enable pin to digital pin 11 |
* LCD D4 pin to digital pin 5 |
* LCD D5 pin to digital pin 4 |
* LCD D6 pin to digital pin 3 |
* LCD D7 pin to digital pin 2 |
* LCD R/W pin to ground |
* 10K resistor: |
* ends to +5V and ground |
* wiper to LCD VO pin (pin 3) |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include "Wire.h" |
#include <Deuligne.h> |
// initialize the library with the numbers of the interface pins |
Deuligne lcd; |
void setup() { |
// set up the LCD's number of columns and rows: |
lcd.init(); |
// Print a message to the LCD. |
lcd.print("hello, world!"); |
} |
void loop() { |
// Turn off the display: |
lcd.noDisplay(); |
delay(500); |
// Turn on the display: |
lcd.display(); |
delay(500); |
} |
/trunk/libraries/SnootlabDeuligne/examples/SerialDisplay/SerialDisplay.pde |
---|
0,0 → 1,60 |
/* |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on official arduino LiquidCrystal Library |
- Serial Input |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch displays text sent over the serial port |
(e.g. from the Serial Monitor) on an attached LCD. |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include "Wire.h" |
#include <Deuligne.h> |
// initialize the library with the numbers of the interface pins |
Deuligne lcd; |
void setup(){ |
// set up the LCD's number of columns and rows: |
lcd.init(); |
// initialize the serial communications: |
Serial.begin(9600); |
} |
void loop() |
{ |
// when characters arrive over the serial port... |
if (Serial.available()) { |
// wait a bit for the entire message to arrive |
delay(100); |
// clear the screen |
lcd.clear(); |
// read all the available characters |
while (Serial.available() > 0) { |
// display each character to the LCD |
lcd.write(Serial.read()); |
} |
} |
} |
/trunk/libraries/SnootlabDeuligne/examples/TextDirection/TextDirection.pde |
---|
0,0 → 1,83 |
/* |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on arduino LiquidCrystal Library - TextDirection |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch demonstrates how to use leftToRight() and rightToLeft() |
to move the cursor. |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include <Wire.h> |
#include <Deuligne.h> |
// initialize the library with the numbers of the interface pins |
Deuligne lcd; |
int thisChar = 'a'; |
void setup() { |
Wire.begin(); |
// set up the LCD's number of columns and rows: |
lcd.init(); |
// turn on the cursor: |
lcd.cursor(); |
Serial.begin(9600); |
} |
void loop() { |
// reverse directions at 'm': |
if (thisChar == 'm') { |
// go right for the next letter |
lcd.rightToLeft(); |
} |
// reverse again at 's': |
if (thisChar == 's') { |
// go left for the next letter |
lcd.leftToRight(); |
} |
// reset at 'z': |
if (thisChar > 'z') { |
// go to (0,0): |
lcd.home(); |
// start again at 0 |
thisChar = 'a'; |
} |
// print the character |
lcd.print(thisChar, BYTE); |
// wait a second: |
delay(1000); |
// increment the letter: |
thisChar++; |
} |
/trunk/libraries/SnootlabDeuligne/examples/DemoJoy/DemoJoy.pde |
---|
0,0 → 1,68 |
/* |
* Snootlab Deuligne joystick testing demo |
* Initial code from nuelectronics |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
*/ |
#include <Wire.h> // I2C library include |
#include <Deuligne.h> // LCD library include |
Deuligne lcd; // lcd object declaration |
//Key message |
char msgs[5][15] = { |
"Right Key OK ", |
"Up Key OK ", |
"Down Key OK ", |
"Left Key OK ", |
"Select Key OK" }; |
int key=-1; |
int oldkey=-1; |
void setup() |
{ |
Wire.begin(); // join i2c |
lcd.init(); // LCD init |
lcd.clear(); // Clear Display |
lcd.backLight(true); // Backlight ON |
lcd.setCursor(5,0); // Place cursor row 6, 1st line (counting from 0) |
lcd.print("Setup"); |
lcd.setCursor(7,1); // Place cursor row 8, 2nd line (counting from 0) |
lcd.print("ok"); |
delay(2000); |
lcd.clear(); |
lcd.print("Move Joystick"); |
} |
void loop() { |
key = lcd.get_key(); // read the value from the sensor & convert into key press |
if (key != oldkey) // if keypress is detected |
{ |
delay(50); // wait for debounce time |
key = lcd.get_key(); // read the value from the sensor & convert into key press |
if (key != oldkey) |
{ |
oldkey = key; |
if (key >=0){ |
// set the cursor to column 0, line 1 |
// (note: line 1 is the second row, since counting begins with 0): |
lcd.setCursor(0, 1); |
// print the key pressed: |
lcd.print(msgs[key]); |
} |
} |
} |
//delay(1000); |
} |
/trunk/libraries/SnootlabDeuligne/examples/Autoscroll/Autoscroll.pde |
---|
0,0 → 1,72 |
/* |
* Deuligne.h |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on official arduino LiquidCrystal Library |
- Autoscroll |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch demonstrates the use of the autoscroll() |
and noAutoscroll() functions to make new text scroll or not. |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include "Wire.h" |
#include <Deuligne.h> |
// initialize the library with the numbers of the interface pins |
Deuligne lcd; |
void setup() { |
// set up the LCD's number of columns and rows: |
Wire.begin(); // join i2c bus (address optional for master) |
lcd.init(); // initialisation du panneau LCD (obligatoire) |
} |
void loop() { |
// set the cursor to (0,0): |
lcd.setCursor(0, 0); |
// print from 0 to 9: |
for (int thisChar = 0; thisChar < 10; thisChar++) { |
lcd.print(thisChar); |
delay(500); |
} |
// set the cursor to (16,1): |
lcd.setCursor(16,1); |
// set the display to automatically scroll: |
lcd.autoscroll(); |
// print from 0 to 9: |
for (int thisChar = 0; thisChar < 10; thisChar++) { |
lcd.print(thisChar); |
delay(500); |
} |
// turn off automatic scrolling |
lcd.noAutoscroll(); |
// clear screen for the next loop: |
lcd.clear(); |
} |
/trunk/libraries/SnootlabDeuligne/examples/First/First.pde |
---|
0,0 → 1,42 |
/* |
* First.pde |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
* Basic usage example |
* |
*/ |
#include <Wire.h> |
#include <Deuligne.h> |
// Object initialization |
Deuligne lcd; |
void setup() |
{ |
Wire.begin(); // join i2c bus (address optional for master) |
lcd.init(); // LCD panel initializatino |
lcd.clear(); // clear display |
lcd.setCursor(0,0); // top left |
lcd.print("Config"); |
lcd.setCursor(7,0); // middle top line (7 from 0-15) |
lcd.print("ok"); |
delay(1000); |
} |
void loop() |
{ |
lcd.clear(); // clear screen |
lcd.backLight(true); |
lcd.setCursor(0,0); // top left corner |
lcd.print("Deuligne"); |
lcd.setCursor(7,1); // middle bottom line (7 from 0-15) |
lcd.print((long)millis()/1000); |
delay(1000); |
} |
/trunk/libraries/SnootlabDeuligne/examples/HelloWorld/HelloWorld.pde |
---|
0,0 → 1,52 |
/* |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on official arduino LiquidCrystal Library |
- Hello World |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch prints "Hello World!" to the LCD |
and shows the time. |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include "Wire.h" |
#include <Deuligne.h> |
// initialize the library with the numbers of the interface pins |
Deuligne lcd; |
void setup() { |
// set up the LCD's number of columns and rows: |
lcd.init(); |
// Print a message to the LCD. |
lcd.print("hello, world!"); |
} |
void loop() { |
// set the cursor to column 0, line 1 |
// (note: line 1 is the second row, since counting begins with 0): |
lcd.setCursor(0, 1); |
// print the number of seconds since reset: |
lcd.print(millis()/1000); |
} |
/trunk/libraries/SnootlabDeuligne/examples/Cursor/Cursor.pde |
---|
0,0 → 1,54 |
/* |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on official arduino LiquidCrystal Library |
- Cursor |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch prints "Hello World!" to the LCD and |
uses the cursor() and noCursor() methods to turn |
on and off the cursor. |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include "Wire.h" |
#include <Deuligne.h> |
// initialize the library with the numbers of the interface pins |
Deuligne lcd; |
void setup() { |
// set up the LCD's number of columns and rows: |
lcd.init(); |
// Print a message to the LCD. |
lcd.print("hello, world!"); |
} |
void loop() { |
// Turn off the cursor: |
lcd.noCursor(); |
delay(500); |
// Turn on the cursor: |
lcd.cursor(); |
delay(500); |
} |
/trunk/libraries/SnootlabDeuligne/examples/Scroll/Scroll.pde |
---|
0,0 → 1,82 |
/* |
* Deuligne.h |
* |
* copyleft 2011 snootlab |
* free software, have fun ! |
* |
based on arduino LiquidCrystal Library |
- scrollDisplayLeft() and scrollDisplayRight() |
Demonstrates the use a 16x2 LCD display. The LiquidCrystal |
library works with all LCD displays that are compatible with the |
Hitachi HD44780 driver. There are many of them out there, and you |
can usually tell them by the 16-pin interface. |
This sketch prints "Hello World!" to the LCD and uses the |
scrollDisplayLeft() and scrollDisplayRight() methods to scroll |
the text. |
Library originally added 18 Apr 2008 |
by David A. Mellis |
library modified 5 Jul 2009 |
by Limor Fried (http://www.ladyada.net) |
example added 9 Jul 2009 |
by Tom Igoe |
modified 22 Nov 2010 |
by Tom Igoe |
This example code is in the public domain. |
http://www.arduino.cc/en/Tutorial/LiquidCrystal |
*/ |
// include the library code: |
#include <Wire.h> |
#include <Deuligne.h> |
// object initialization |
Deuligne lcd; |
void setup() { |
Wire.begin(); |
// set up the LCD's number of columns and rows: |
lcd.init(); |
// Print a message to the LCD. |
lcd.print("hello, world!"); |
delay(1000); |
} |
void loop() { |
// scroll 13 positions (string length) to the left |
// to move it offscreen left: |
for (int positionCounter = 0; positionCounter < 13; positionCounter++) { |
// scroll one position left: |
lcd.scrollDisplayLeft(); |
// wait a bit: |
delay(150); |
} |
// scroll 29 positions (string length + display length) to the right |
// to move it offscreen right: |
for (int positionCounter = 0; positionCounter < 29; positionCounter++) { |
// scroll one position right: |
lcd.scrollDisplayRight(); |
// wait a bit: |
delay(150); |
} |
// scroll 16 positions (display length + string length) to the left |
// to move it back to center: |
for (int positionCounter = 0; positionCounter < 16; positionCounter++) { |
// scroll one position left: |
lcd.scrollDisplayLeft(); |
// wait a bit: |
delay(150); |
} |
// delay at the end of the full loop: |
delay(1000); |
} |