Subversion Repositories idreammicro-arduino

Compare Revisions

Ignore whitespace Rev 20 → Rev 21

/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);
 
}