aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorChristopher Baines <cbaines8@gmail.com>2011-08-31 19:45:00 +0100
committerChristopher Baines <cbaines8@gmail.com>2011-08-31 19:45:00 +0100
commit96654ea19b12be4b43230f3ff9f908eebcb416ca (patch)
treed6c6100302db17c73e4d75673d637796cee9ffd6
parent4667303e15c534d390abee467eeaaee850e2d6f5 (diff)
downloadpunchingbag-96654ea19b12be4b43230f3ff9f908eebcb416ca.tar
punchingbag-96654ea19b12be4b43230f3ff9f908eebcb416ca.tar.gz
Initial commit for the modified libaries used and the ButtonMatrix arduino code. I have just cleaned this up, but not tested it.
-rwxr-xr-xArduino/ButtonMatrix/ButtonMatrix.pde62
-rwxr-xr-xArduino/Libraies/AS1107/AS1107.cpp769
-rwxr-xr-xArduino/Libraies/AS1107/AS1107.h147
-rw-r--r--Arduino/Libraies/AS1107/README1
-rwxr-xr-xArduino/Libraies/AS1107/examples/LEDMatrix/LEDMatrix.pde131
-rwxr-xr-xArduino/Libraies/AS1107/keywords.txt39
-rwxr-xr-xArduino/Libraies/Keypad/Examples/CustomKeypad/CustomKeypad.pde37
-rwxr-xr-xArduino/Libraies/Keypad/Examples/DynamicKeypad/DynamicKeypad.pde187
-rwxr-xr-xArduino/Libraies/Keypad/Examples/EventKeypad/EventKeypad.pde72
-rwxr-xr-xArduino/Libraies/Keypad/Examples/HelloKeypad/HelloKeypad.pde35
-rwxr-xr-xArduino/Libraies/Keypad/Keypad.cpp174
-rwxr-xr-xArduino/Libraies/Keypad/Keypad.h108
-rw-r--r--Arduino/Libraies/Keypad/README1
-rwxr-xr-xArduino/Libraies/Keypad/keywords.txt17
14 files changed, 1780 insertions, 0 deletions
diff --git a/Arduino/ButtonMatrix/ButtonMatrix.pde b/Arduino/ButtonMatrix/ButtonMatrix.pde
new file mode 100755
index 0000000..85a9bfa
--- /dev/null
+++ b/Arduino/ButtonMatrix/ButtonMatrix.pde
@@ -0,0 +1,62 @@
+#include <Keypad.h> // Needs to be the modified version
+
+const byte ROWS = 19;
+const byte COLS = 8;
+
+/* Each of the buttons can be refered to by a number
+ At the moment the byte overflow for the 127+ numbers is dealt with at the
+ getKey time, but if a unsigned byte could be used here it would remove the need
+ for the correction?
+*/
+char keys[COLS][ROWS] = {
+{1, 9, 17, 25, 33, 41, 49, 57, 65, 73, 81, 89, 97, 105, 113, 121, 129, 137, 145},
+{2, 10, 18, 26, 34, 42, 50, 58, 66, 74, 82, 90, 98, 106, 114, 122, 130, 138, 146},
+{3, 11, 19, 27, 35, 43, 51, 59, 67, 75, 83, 91, 99, 107, 115, 123, 131, 139, 147},
+{4, 12, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, 132, 140, 148},
+{5, 13, 21, 29, 37, 45, 53, 61, 69, 77, 85, 93, 101, 109, 117, 125, 133, 141, 149},
+{6, 14, 22, 30, 38, 46, 54, 62, 70, 78, 86, 94, 102, 110, 118, 126, 134, 142, 150},
+{7, 15, 23, 31, 39, 47, 55, 63, 71, 79, 87, 95, 103, 111, 119, 127, 135, 143, 151},
+{8, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128, 136, 144, 152}
+};
+
+byte colPins[COLS] = {9, 8, 7, 6, 5, 4, 3, 2};
+byte rowPins[ROWS] = {14, 15, 16, 17, 18, 19, 20, 21, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42};
+
+/*
+ Becuase of the diodes being fitted the WRONG WAY ROUND,
+ the columns are rows and the rows are columns, have fun!
+*/
+// ROW COL ROWS COLS
+Keypad keypad = Keypad( makeKeymap(testKeysTwo), colPins, rowPins, COLS, ROWS);
+
+void setup(){
+ Serial.begin(115200);
+ Serial.println("Go");
+
+}
+/* Send numbers back and forth to test the integrity of the serial communication
+ Computer sends the first byte
+*/
+boolean runSerialTest() {
+ Serial.println("Begining Serial Test");
+ delay(10);
+ byte sByte cByte;
+ for (int i=0; i<10000; i++) {
+ sByte = Serial.read();
+ if (sByte != cByte && i != 0) return false;
+ sByte = ((sByte * 10) % 127);
+ Serial.write(sByte);
+ cByte = ((sByte * 10) % 127); // The next expected byte
+ }
+ return true;
+}
+
+void loop(){
+ // Serial.println("GetKeyCall");
+ char customKey = customKeypad.getKey();
+ int customKeyInt = customKey;
+ if (customKeyInt < 0) customKeyInt += 256;
+ if (customKey != NO_KEY){
+ Serial.println(customKeyInt);
+ }
+}
diff --git a/Arduino/Libraies/AS1107/AS1107.cpp b/Arduino/Libraies/AS1107/AS1107.cpp
new file mode 100755
index 0000000..c61819e
--- /dev/null
+++ b/Arduino/Libraies/AS1107/AS1107.cpp
@@ -0,0 +1,769 @@
+/*
+ AS1107.cpp - Library for interfacing the AS1107 LED Driver Chip
+ Created by Stephan Elsner, March 29, 2011
+
+ Scrolltext uses a proportional character font
+ Tested with Arduino Duemilenove
+ version 0.82
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+#include <avr/pgmspace.h>
+#include "WProgram.h"
+#include "AS1107.h"
+
+const byte AS1107::_repcharoff = 27;
+
+// Font Data
+PROGMEM prog_uchar _font[] = {
+ // -------- Space
+ 0b00000000,
+ 0b00000000,
+ 0b00000000,
+ 0b00000000,
+ // -------- A
+ 0b01111110,
+ 0b10010000,
+ 0b10010000,
+ 0b01111110,
+ // -------- B
+ 0b01101100,
+ 0b10010010,
+ 0b10010010,
+ 0b11111110,
+ // -------- C
+ 0b10000010,
+ 0b10000010,
+ 0b01111100,
+ // -------- D
+ 0b00111000,
+ 0b01000100,
+ 0b10000010,
+ 0b11111110,
+ // -------- E
+ 0b10000010,
+ 0b10010010,
+ 0b11111110,
+ // -------- F
+ 0b10000000,
+ 0b10010000,
+ 0b11111110,
+ // -------- G
+ 0b01011100,
+ 0b10010010,
+ 0b10000010,
+ 0b01111100,
+ // -------- H
+ 0b11111110,
+ 0b00010000,
+ 0b00010000,
+ 0b11111110,
+ // -------- I
+ 0b10000010,
+ 0b11111110,
+ 0b10000010,
+ // -------- J
+ 0b11111100,
+ 0b00000010,
+ 0b00001100,
+ // -------- K
+ 0b10000110,
+ 0b01001000,
+ 0b00110000,
+ 0b11111110,
+ // -------- L
+ 0b00000010,
+ 0b00000010,
+ 0b11111110,
+ // -------- M
+ 0b11111110,
+ 0b01100000,
+ 0b00111100,
+ 0b01100000,
+ 0b11111110,
+ // -------- N
+ 0b11111110,
+ 0b00011000,
+ 0b01100000,
+ 0b11111110,
+ // -------- O
+ 0b01111100,
+ 0b10000010,
+ 0b10000010,
+ 0b01111100,
+ // -------- P
+ 0b01100000,
+ 0b10010000,
+ 0b10010000,
+ 0b11111110,
+ // -------- Q
+ 0b01111010,
+ 0b10000100,
+ 0b10001010,
+ 0b01111100,
+ // -------- R
+ 0b01100110,
+ 0b10011000,
+ 0b10010000,
+ 0b11111110,
+ // -------- S
+ 0b10001100,
+ 0b10010010,
+ 0b01100010,
+ // -------- T
+ 0b10000000,
+ 0b11111110,
+ 0b10000000,
+ // -------- U
+ 0b11111100,
+ 0b00000010,
+ 0b00000010,
+ 0b11111100,
+ // -------- V
+ 0b11000000,
+ 0b00111000,
+ 0b00000110,
+ 0b00111000,
+ 0b11000000,
+ // -------- W
+ 0b11111110,
+ 0b00001100,
+ 0b00111000,
+ 0b00001100,
+ 0b11111110,
+ // -------- X
+ 0b11000110,
+ 0b00111000,
+ 0b00111000,
+ 0b11000110,
+ // -------- Y
+ 0b11100000,
+ 0b00011110,
+ 0b11100000,
+ // -------- Z
+ 0b11000010,
+ 0b10110010,
+ 0b10001110,
+ // -------- Unknown character
+ 0b00111000,
+ 0b00111000,
+ 0b00111000,
+ // -------- 0
+ 0b01111100,
+ 0b10100010,
+ 0b10010010,
+ 0b01111100,
+ // -------- 1
+ 0b11111110,
+ 0b01000000,
+ // -------- 2
+ 0b01100010,
+ 0b10010010,
+ 0b10001110,
+ // -------- 3
+ 0b01101100,
+ 0b10010010,
+ 0b10000010,
+ // -------- 4
+ 0b11111110,
+ 0b00010000,
+ 0b11110000,
+ // -------- 5
+ 0b10001100,
+ 0b10010010,
+ 0b11110010,
+ // -------- 6
+ 0b01001100,
+ 0b10010010,
+ 0b10010010,
+ 0b01111100,
+ // -------- 7
+ 0b11100000,
+ 0b10011110,
+ 0b10000000,
+ // -------- 8
+ 0b01101100,
+ 0b10010010,
+ 0b10010010,
+ 0b01101100,
+ // -------- 9
+ 0b01111100,
+ 0b10010010,
+ 0b10010010,
+ 0b01100100,
+ // -------- :
+ 0b00100100,
+ // -------- ;
+ 0b00100110,
+ 0b00000001,
+ // -------- !
+ 0b01100000,
+ 0b11111010,
+ 0b01100000,
+ // -------- Heart
+ 0b01111000,
+ 0b11111100,
+ 0b11111110,
+ 0b01111111,
+ 0b11111110,
+ 0b11111100,
+ 0b01111000,
+ // -------- <
+ 0b01000100,
+ 0b00101000,
+ 0b00010000,
+ // -------- =
+ 0b00101000,
+ 0b00101000,
+ 0b00101000,
+ 0b00101000,
+ // -------- >
+ 0b00010000,
+ 0b00101000,
+ 0b01000100,
+ // -------- ?
+ 0b01100000,
+ 0b10011010,
+ 0b10000000,
+ // -------- @
+ 0b01111100,
+ 0b10000010,
+ 0b10111010,
+ 0b10100010,
+ 0b01011100,
+ // -------- (
+ 0b10000010,
+ 0b01111100,
+ // -------- )
+ 0b01111100,
+ 0b10000010,
+ // -------- *
+ 0b00101000,
+ 0b00010000,
+ 0b00101000,
+ // -------- +
+ 0b00010000,
+ 0b00010000,
+ 0b01111100,
+ 0b00010000,
+ 0b00010000,
+ // -------- ,
+ 0b00000110,
+ 0b00000001,
+ // -------- -
+ 0b00010000,
+ 0b00010000,
+ 0b00010000,
+ 0b00010000,
+ // -------- .
+ 0b00000010,
+ // -------- /
+ 0b11000000,
+ 0b00111000,
+ 0b00000110,
+ // -------- a
+ 0b00111110,
+ 0b00100010,
+ 0b00100010,
+ 0b00011100,
+ // -------- b
+ 0b00011100,
+ 0b00100010,
+ 0b00100010,
+ 0b11111110,
+ // -------- c
+ 0b00100010,
+ 0b00100010,
+ 0b00011100,
+ // -------- d
+ 0b11111110,
+ 0b00100010,
+ 0b00100010,
+ 0b00011100,
+ // -------- e
+ 0b00011000,
+ 0b00101010,
+ 0b00101010,
+ 0b00011100,
+ // -------- f
+ 0b10010000,
+ 0b01111110,
+ 0b00010000,
+ // -------- g
+ 0b00111110,
+ 0b00100101,
+ 0b00100101,
+ 0b00011000,
+ // -------- h
+ 0b00011110,
+ 0b00100000,
+ 0b00100000,
+ 0b11111110,
+ // -------- i
+ 0b00000010,
+ 0b01011110,
+ 0b00010010,
+ // -------- j
+ 0b01011110,
+ 0b00000001,
+ 0b00000001,
+ // -------- k
+ 0b00100010,
+ 0b00010100,
+ 0b00001000,
+ 0b11111110,
+ // -------- l
+ 0b00000010,
+ 0b11111100,
+ // -------- m
+ 0b00011110,
+ 0b00100000,
+ 0b00111110,
+ 0b00100000,
+ 0b00111110,
+ // -------- n
+ 0b00011110,
+ 0b00100000,
+ 0b00100000,
+ 0b00111110,
+ // -------- o
+ 0b00011100,
+ 0b00100010,
+ 0b00100010,
+ 0b00011100,
+ // -------- p
+ 0b00011100,
+ 0b00100010,
+ 0b00100010,
+ 0b00111111,
+ // -------- q
+ 0b00111111,
+ 0b00100010,
+ 0b00100010,
+ 0b00011100,
+ // -------- r
+ 0b00010000,
+ 0b00100000,
+ 0b00111110,
+ // -------- s
+ 0b00100100,
+ 0b00101010,
+ 0b00101010,
+ 0b00010010,
+ // -------- t
+ 0b00100010,
+ 0b11111100,
+ 0b00100000,
+ // -------- u
+ 0b00111110,
+ 0b00000010,
+ 0b00000010,
+ 0b00111100,
+ // -------- v
+ 0b00111000,
+ 0b00000110,
+ 0b00111000,
+ // -------- w
+ 0b00111110,
+ 0b00000010,
+ 0b00011110,
+ 0b00000010,
+ 0b00111100,
+ // -------- x
+ 0b00110110,
+ 0b00001000,
+ 0b00110110,
+ // -------- y
+ 0b00111110,
+ 0b00000101,
+ 0b00000101,
+ 0b00111001,
+ // -------- z
+ 0b00110010,
+ 0b00101010,
+ 0b00100110,
+ 0b00100010,
+ 0b11000001
+};
+
+// Char width table
+PROGMEM prog_uchar _charwidth[] = {4,4,4,3,4,3,3,4,4,3,3,4,3,5,4,4,4,4,4,3,3,4,5,5,4,3,3,
+ 3,4,2,3,3,3,3,4,3,4,4,1,2,3,7,3,4,3,3,5,2,2,3,5,2,4,1,3,
+ 4,4,3,4,4,3,4,4,3,3,4,2,5,4,4,4,4,3,4,3,4,3,5,3,4,4,0 };
+
+// ASCII Codes of the implemented characters
+PROGMEM prog_uchar _charcodes[] = {32,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,
+ 81,82,83,84,85,86,87,88,89,90,255,48,49,50,51,52,53,
+ 54,55,56,57,58,59,33,3,60,61,62,63,64,40,41,42,43,44,
+ 45,46,47,97,98,99,100,101,102,103,104,105,106,107,108,
+ 109,110,111,112,113,114,115,116,117,118,119,120,121,
+ 122,0};
+// ------------------------------------------------------------------------------------
+// Constructor, initialize arduino
+AS1107::AS1107(byte cspin, byte clkpin, byte datapin)
+{
+ _cspin = cspin;
+ _clkpin = clkpin;
+ _datapin = datapin;
+ pinMode(cspin, OUTPUT);
+ pinMode(clkpin, OUTPUT);
+ pinMode(datapin, OUTPUT);
+ digitalWrite(cspin,HIGH);
+ digitalWrite(clkpin,LOW);
+ digitalWrite(datapin,LOW);
+}
+
+// ------------------------------------------------------------------------------------
+// Initializes Arduino and AS1107
+// buffer is the initial screen buffer
+void AS1107::Init(byte * buffer)
+{
+ _buffer = buffer;
+ CalculateCharOffsets();
+ // Clear Screen buffer
+ Clear();
+ for (int i=0; i<=HighestCtrlNum; i++) {
+ WriteRegister(i, Registers::Shutdown, ShutdownModes::Normal);
+ WriteRegister(i, Registers::DecodeMode, 0x00);
+ WriteRegister(i, Registers::IntensityControl, 0x00);
+ WriteRegister(i, Registers::ScanLimit, 0x07);
+ }
+}
+
+// ------------------------------------------------------------------------------------
+// Set the Screen buffer
+void AS1107::SetBuffer(byte * buffer)
+{
+ _buffer = buffer;
+}
+
+// ------------------------------------------------------------------------------------
+// Writes Data to a Register of the AS1106/AS1107
+// chip: Number of the controller chip (starting at 0 for the left)
+// reg: Register of the controller
+// data: Data to be written
+void AS1107::WriteRegister( byte chip, byte reg, byte data)
+{
+ if (chip>=0 && chip <= HighestCtrlNum) {
+ chip = HighestCtrlNum -chip;
+ digitalWrite(_cspin,LOW);
+ for (int i=0; i<=HighestCtrlNum; i++) {
+ if (i == chip) {
+ shiftOut(_datapin, _clkpin, MSBFIRST, reg);
+ shiftOut(_datapin, _clkpin, MSBFIRST, data);
+ }
+ else {
+ shiftOut(_datapin, _clkpin, MSBFIRST, Registers::NoOp);
+ shiftOut(_datapin, _clkpin, MSBFIRST, 0);
+ }
+ }
+ digitalWrite(_cspin,HIGH);
+ }
+}
+
+// ------------------------------------------------------------------------------------
+// Writes a column of data to the LED-Matrix
+// column: column number, starting at 0
+// data : screen data to be written
+void AS1107::WriteColumn( byte column, byte data)
+{
+ // if you use unusual matrix row wiring, you can manipulate data here
+ byte chip = (column) >>3;
+ byte reg = (column % 8) +1;
+ WriteRegister(chip, reg, data);
+}
+
+// ------------------------------------------------------------------------------------
+// Sets the status of a LED in the screen buffer
+void AS1107::SetLed(int x, int y, byte value)
+{
+ if (x<=Maxx && y<=Maxy && x>=0 && y>=0) {
+ if (value>0) value = 1;
+ SetLedInternal(x, y, value);
+ }
+}
+
+// ------------------------------------------------------------------------------------
+// Writes Buffer to Screen
+// needs to be called after a graphics operation to see anything
+void AS1107::Update()
+{
+ for (byte i=0; i<=Maxx; i++) {
+ WriteColumn(i, _buffer[i]);
+ }
+}
+
+// ------------------------------------------------------------------------------------
+// Clear the Screen Buffer
+void AS1107::Clear()
+{
+ for (byte i=0; i<=Maxx; _buffer[i++]=0);
+}
+
+// ------------------------------------------------------------------------------------
+// Shift the content of the Screen buffer to the left
+void AS1107::ShiftLeft()
+{
+ for (byte i=1; i<=Maxx; i++) {
+ _buffer[i-1] = _buffer[i];
+ }
+ _buffer[Maxx] = 0;
+}
+// ------------------------------------------------------------------------------------
+// Shift the content of the Screen buffer to the right
+void AS1107::ShiftRight()
+{
+ for (byte i=Maxx; i>=1; i--) {
+ _buffer[i] = _buffer[i-1];
+ }
+ _buffer[0] = 0;
+}
+// ------------------------------------------------------------------------------------
+// Shift the content of the Screen buffer up
+void AS1107::ShiftUp()
+{
+ for (byte i=0; i<=Maxx; i++) {
+ _buffer[i] = _buffer[i]<<1 & 0xFE;
+ }
+}
+// ------------------------------------------------------------------------------------
+// Shift the content of the Screen buffer up
+void AS1107::ShiftUp(byte from, byte to)
+{
+ for (byte i=from; i<=to; i++) {
+ _buffer[i] = _buffer[i]<<1 & 0xFE;
+ }
+}
+// ------------------------------------------------------------------------------------
+// Shift the content of the Screen buffer down
+void AS1107::ShiftDown()
+{
+ for (byte i=0; i<=Maxx; i++) {
+ _buffer[i] = _buffer[i]>>1 & 0x7F;
+ }
+}
+// ------------------------------------------------------------------------------------
+// Shift the content of the Screen buffer down
+void AS1107::ShiftDown(byte from, byte to)
+{
+ for (byte i=from; i<=to; i++) {
+ _buffer[i] = _buffer[i]>>1 & 0x7F;
+ }
+}
+// ------------------------------------------------------------------------------------
+// draws a line from x0 ,y0 to x1,y1
+void AS1107::DrawLine(int x0, int y0, int x1, int y1)
+{
+
+ int dx = abs(x1-x0), sx = x0<x1 ? 1 : -1;
+ int dy = -abs(y1-y0), sy = y0<y1 ? 1 : -1;
+ int err = dx+dy, e2; /* error value e_xy */
+
+ for(;;){ /* loop */
+ SetLed(x0,y0,ON);
+ if (x0==x1 && y0==y1) break;
+ e2 = 2*err;
+ if (e2 >= dy) { err += dy; x0 += sx; } /* e_xy+e_x > 0 */
+ if (e2 <= dx) { err += dx; y0 += sy; } /* e_xy+e_y < 0 */
+ }
+}
+// ------------------------------------------------------------------------------------
+// draws a box from x0,x0 to x1,y1
+void AS1107::DrawBox(int x0, int y0, int x1, int y1)
+{
+ DrawLine(x0,y0,x1,y0);
+ DrawLine(x1,y0,x1,y1);
+ DrawLine(x1,y1,x0,y1);
+ DrawLine(x0,y1,x0,y0);
+}
+// ------------------------------------------------------------------------------------
+// draws an ellipse
+// center xm, ym - radius a,b
+void AS1107::DrawEllipse(int xm, int ym, int a, int b)
+{
+ if (a ==0 && b== 0) {
+ SetLed(xm,ym,ON);
+ return;
+ }
+
+ int dx = 0, dy = b; /* first quadrant from top left to bottom right */
+ int a2 = a*a, b2 = b*b;
+ int err = b2-(2*b-1)*a2, e2; /* error value in the first step */
+
+ do {
+ SetLed(xm+dx, ym+dy, ON); /* I. Quadrant */
+ SetLed(xm-dx, ym+dy, ON); /* II. Quadrant */
+ SetLed(xm-dx, ym-dy, ON); /* III. Quadrant */
+ SetLed(xm+dx, ym-dy, ON); /* IV. Quadrant */
+
+ e2 = 2*err;
+ if (e2 < (2*dx+1)*b2) { dx++; err += (2*dx+1)*b2; }
+ if (e2 > -(2*dy-1)*a2) { dy--; err -= (2*dy-1)*a2; }
+ } while (dy >= 0);
+
+ while (dx++ < a) { /* correction for flat ellipses (b=1) */
+ SetLed(xm+dx, ym, ON);
+ SetLed(xm-dx, ym, ON);
+ }
+}
+
+// ------------------------------------------------------------------------------------
+// Writes Text at a screen position
+void AS1107::DrawText (int x, int y, char *str)
+{
+ byte count;
+ char thechar;
+ while (*str != '\0') {
+ Serial.println(*str,DEC);
+ x+=DrawChar(x, y, *str);
+ str++;
+ }
+}
+
+// ------------------------------------------------------------------------------------
+// Draws a single character at a screen position
+// returns the x-position for the next character
+byte AS1107::DrawChar (int x, int y, char thechar)
+{
+ y+=7;
+ byte charnum, colct, count=0, colbits;
+ int fontidx;
+ charnum = GetInternalCharCode(thechar);
+
+ // get the location of the first column of the font
+ fontidx = _charoffset[charnum]-1;
+
+ // get the width of the font
+ colct = pgm_read_byte_near(_charwidth + charnum);
+ for (byte i=colct; i>0; i--) {
+ colbits = pgm_read_byte_near(_font + fontidx + i);
+ for (byte j=0; j<=7; j++) {
+ if ((colbits >>j) & 1) {
+ SetLed(x, y-j, 1);
+ }
+ }
+ x++;
+ }
+ return colct+1;
+}
+// ------------------------------------------------------------------------------------
+// Sets the Text for Scrolline
+void AS1107::SetScrollText(char *string, int charspacing)
+{
+ _charspacing = charspacing;
+ _outputstring = string;
+ _curchr = string;
+ _hastext = true;
+ _colct =-1;
+}
+
+// ------------------------------------------------------------------------------------
+// Scrolls the text one pixel to the left
+// returns true if last character has been displayed
+boolean AS1107::TextScroll()
+{
+ boolean lastchar = false;
+ byte colbits = 0;
+ if (_colct == (0-_charspacing-1)) {
+ lastchar = NextCharacter();
+ }
+ if (_colct>=0) {
+ colbits = pgm_read_byte_near(_font + _fontidx + _colct);
+ }
+ ShiftLeft();
+ _buffer[Maxx] = colbits;
+ Update();
+ _colct--;
+ return lastchar;
+}
+
+// ------------------------------------------------------------------------------------
+// PRIVATE (Internal) functions
+// ------------------------------------------------------------------------------------
+// Set LED without Parameter check
+void AS1107::SetLedInternal(byte x, byte y, byte value)
+{
+ if (value != 0) {
+ _buffer[x] |= value << (Maxy-y);
+ } else {
+ _buffer[x] &= ~(1 << (Maxy-y));
+ }
+}
+
+// ------------------------------------------------------------------------------------
+// fetches the next character of the Scrollline
+// returns true if string is at the end
+boolean AS1107::NextCharacter()
+{
+ boolean lastchar = false;
+ if (_hastext) {
+ char thechar = *_curchr;
+ boolean found = false;
+ byte charnum = 0;
+ byte i;
+ // if the string ends, start from the beginning
+ if (thechar == 0) {
+ lastchar = true;
+ _curchr = _outputstring;
+ thechar = *_curchr;
+ }
+
+ charnum = GetInternalCharCode(thechar);
+
+ // get the offset of the first column of the character
+ _fontidx = _charoffset[charnum];
+
+ // get the width of the font
+ _colct = pgm_read_byte_near(_charwidth + charnum) -1;
+ }
+ else {
+ _fontidx= _charoffset[_repcharoff];
+ _colct = pgm_read_byte_near(_charwidth + _repcharoff);
+ }
+ *_curchr++;
+ return lastchar;
+}
+// ------------------------------------------------------------------------------------
+// calculates Character offsets from font width table in EEPROM
+void AS1107::CalculateCharOffsets()
+{
+ int off =0;
+ int idx=0;
+ int w=0;
+ int i=0;
+
+ do {
+ _charoffset[i]=off;
+ w = pgm_read_byte_near(_charwidth+i);
+ off += w;
+ i++;
+ } while (w != 0);
+}
+
+// ------------------------------------------------------------------------------------
+// gets the character number of the built-in-font from the ASCII table
+// returns number of the replacement character for unknown characters
+byte AS1107::GetInternalCharCode(byte thechar)
+{
+ int i=0;
+ int charnum;
+ do {
+ charnum = pgm_read_byte_near(_charcodes + i);
+ if (charnum == thechar) break;
+ i++;
+ } while (charnum != 0 );
+ if (charnum == 0) i = _repcharoff;
+ return i;
+} \ No newline at end of file
diff --git a/Arduino/Libraies/AS1107/AS1107.h b/Arduino/Libraies/AS1107/AS1107.h
new file mode 100755
index 0000000..60ad6ad
--- /dev/null
+++ b/Arduino/Libraies/AS1107/AS1107.h
@@ -0,0 +1,147 @@
+/*
+ AS1107.h - Library for interfacing the AS1107 LED Driver Chip
+ Created by Stephan Elsner 2011
+ version 0.82
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#ifndef AS1107_h
+#define AS1107_h
+
+#include "WProgram.h"
+#include <avr/pgmspace.h>
+
+#define ON 1
+#define OFF 0
+
+
+// --------------------------------------------------------------------------------------------------------------------------
+class AS1107
+{
+ public:
+ AS1107(byte cspin, byte clkpin, byte datapin);
+ void WriteRegister2(byte chip, byte reg, byte data);
+ void WriteRegister(byte chip, byte reg, byte data);
+ void WriteColumn( byte column, byte data);
+ void Init(byte *buffer);
+ void SetBuffer(byte *buffer);
+ void SetLed(int x, int y, byte value);
+ void Clear();
+ void Update();
+ void ShiftLeft();
+ void ShiftRight();
+ void ShiftUp();
+ void ShiftDown();
+ void ShiftUp(byte from, byte to);
+ void ShiftDown(byte from, byte to);
+ void DrawLine(int x0, int y0, int x1, int y1);
+ void DrawBox(int x0, int y0, int x1, int y1);
+ void DrawEllipse(int xm, int ym, int a, int b);
+ void SetScrollText(char *string, int charspacing);
+ void DrawText (int x, int y, char *str);
+ byte DrawChar (int x, int y, char thechar);
+
+ boolean TextScroll();
+
+ // ***************************************
+ // Set your module configuration here
+ // ***************************************
+ static const byte Maxx=15; // maximum x - Pixels of the Module
+ static const byte Maxy=7; // maximum y - Pixels of the Module
+ static const byte HighestCtrlNum=1; // Number of Matrix modules -1 (0 = single module)
+
+ private:
+ byte _cspin;
+ byte _clkpin;
+ byte _datapin;
+ byte *_buffer; // pointer to current screen buffer
+
+ static const byte _repcharoff; // Offset of the replacement for unknown characers
+ int _charoffset[82]; // Start position in Array
+ char *_outputstring; // pointer to start of output string
+ char *_curchr; // pointer to current char of output String
+ int _fontidx; // current byte in font to display
+ int _colct; // to count the columns of character to display
+ byte _charspacing; // the coulumns of space between characters
+ boolean _hastext;
+
+ void SetLedInternal(byte x, byte y, byte value);
+ boolean NextCharacter();
+ void CalculateCharOffsets();
+ byte GetInternalCharCode(byte thechar);
+};
+
+// --------------------------------------------------------------------------------------------------------------------------
+// AS1107-Register
+class Registers
+{
+ public:
+ static const byte NoOp = 0x00;
+ static const byte Digit0 = 0x01;
+ static const byte Digit1 = 0x02;
+ static const byte Digit2 = 0x03;
+ static const byte Digit3 = 0x04;
+ static const byte Digit4 = 0x05;
+ static const byte Digit5 = 0x06;
+ static const byte Digit6 = 0x07;
+ static const byte Digit7 = 0x08;
+ static const byte DecodeMode = 0x09;
+ static const byte IntensityControl = 0x0A;
+ static const byte ScanLimit = 0x0B;
+ static const byte Shutdown = 0x0C;
+ static const byte Feature = 0x0E;
+ static const byte DisplayTest = 0x0F;
+};
+
+// --------------------------------------------------------------------------------------------------------------------------
+// Values to write to the Shutdown Register
+class ShutdownModes
+{
+ public:
+ static const byte ShutdownResetFeature = 0x00; // Shutdown Mode, Reset Feature Register to Default Settings
+ static const byte Shutdown = 0x80; // Shutdown Mode, leaving Feature Register unchanged
+ static const byte NormalResetFeature = 0x01; // Normal Mode, Reset Feature
+ static const byte Normal = 0x81; // Normal Mode, Feature unchanged
+};
+
+// Bits in the feature-Register, desired Settings must be OR'ed together
+class Features
+{
+ public:
+ static const byte ExternalClock = 0x01; // ExternalClock active
+ static const byte ResetRegisters = 0x02; // Resets all control registers except the Feature Register.
+ static const byte HexDecoding = 0x04; // 1 = Enable HEX decoding, 0 = Enable Code-B decoding
+ static const byte SPIEnable = 0x08; // Enables the SPI-compatible interface.(AS1106 only).
+ static const byte BlinkEnable = 0x10; // Enables blinking.
+ static const byte BlinkSlow = 0x20; // Sets blink with low frequency
+ // (with the internal oscillator enabled)
+
+ static const byte BlinkSync = 0x40; // Synchronizes blinking on the rising edge of pin LOAD/CSN.
+ // The multiplex and blink timing counter is cleared on the
+ // rising edge of pin LOAD/CSN. By setting this bit in
+ // multiple AS1106/AS1107 devices, the blink timing can
+ // be synchronized across all the devices.
+
+ static const byte BlinkStartWithOn = 0x80; // Start Blinking with display enabled phase.
+ // When bit D4 (blink_en) is set, bit D7
+ // determines how blinking starts.
+ // 0 = Blinking starts with the display turned off.
+ // 1 = Blinking starts with the display turned on.
+};
+
+#endif
+
+ \ No newline at end of file
diff --git a/Arduino/Libraies/AS1107/README b/Arduino/Libraies/AS1107/README
new file mode 100644
index 0000000..3e1dea9
--- /dev/null
+++ b/Arduino/Libraies/AS1107/README
@@ -0,0 +1 @@
+Changed SetLed so that it can turn LED's off as well as on.
diff --git a/Arduino/Libraies/AS1107/examples/LEDMatrix/LEDMatrix.pde b/Arduino/Libraies/AS1107/examples/LEDMatrix/LEDMatrix.pde
new file mode 100755
index 0000000..377331d
--- /dev/null
+++ b/Arduino/Libraies/AS1107/examples/LEDMatrix/LEDMatrix.pde
@@ -0,0 +1,131 @@
+// test program for three cascaded AS1107
+// if you got a different configuration you need to
+// modify the library itself.
+
+#include <AS1107.h>
+
+// Arduino pins
+const byte CsnPin = 2 ; // Chip select (Low active)
+const byte ClkPin = 3 ; // Serial Clock
+const byte DataPin = 4 ; // Serial Data
+
+byte buffer [ 24 ] ; // Screen buffer (No. of modules * 8)
+AS1107 matrix ( CsnPin, ClkPin, DataPin ) ;
+
+const byte d = 0 ;
+int count= 1 ;
+void setup ( )
+{
+matrix. Init ( buffer ) ;
+matrix. SetScrollText ( " Three 8x8 LED dot matrix modules driven by three AS1107 LED controllers using just four I/O pins of the Arduino for serial data. That is surprisingly fast, look:" , 1 ) ;
+}
+
+void loop ( )
+{
+if ( matrix. TextScroll ( ) ) {
+delay ( 2000 ) ;
+for ( int i= 0 ; i<= 7 ; i++ ) {
+matrix. ShiftUp ( ) ;
+delay ( 50 ) ;
+matrix. Update ( ) ;
+}
+for ( int i= 0 ; i<= 10 ; i++ ) {
+CirclePulsate ( ) ;
+}
+StarsDown ( ) ;
+for ( int i= 0 ; i<= 5 ; i++ ) {
+Rotator1 ( ) ;
+}
+StarsRight ( ) ;
+for ( int i= 0 ; i<=AS1107:: Maxx ; i++ ) {
+matrix. ShiftRight ( ) ;
+delay ( 5 ) ;
+matrix. Update ( ) ;
+}
+for ( int i= 1 ; i<= 3 ; i++ )
+{
+bounce ( ) ;
+}
+}
+delay ( 10 ) ;
+}
+
+void CirclePulsate ( )
+{
+for ( int i= 0 ; i<= 15 ; i++ ) {
+matrix. Clear ( ) ;
+matrix. DrawEllipse ( AS1107:: Maxx / 2 , 4 ,i,i ) ;
+matrix. Update ( ) ;
+delay ( d ) ;
+}
+}
+void StarsDown ( )
+{
+for ( int i= 0 ; i<= 200 ; i++ ) {
+matrix. ShiftDown ( ) ;
+matrix. SetLed ( ( byte ) random ( 0 ,AS1107:: Maxx + 1 ) , 0 , 1 ) ;
+matrix. Update ( ) ;
+delay ( d ) ;
+}
+}
+void StarsRight ( )
+{
+for ( int i= 0 ; i<= 200 ; i++ ) {
+matrix. ShiftRight ( ) ;
+matrix. SetLed ( 0 , ( byte ) random ( 0 ,AS1107:: Maxy + 1 ) , 1 ) ;
+matrix. Update ( ) ;
+delay ( d ) ;
+}
+}
+void Rotator1 ( )
+{
+for ( int i= 0 ; i<=AS1107:: Maxx - 1 ; i++ ) {
+matrix. Clear ( ) ;
+matrix. DrawLine ( i, 0 ,AS1107:: Maxx -i,AS1107:: Maxy ) ;
+matrix. Update ( ) ;
+delay ( d ) ;
+}
+for ( int i= 0 ; i<= 6 ; i++ ) {
+matrix. Clear ( ) ;
+matrix. DrawLine ( AS1107:: Maxx ,i, 0 , 7 -i ) ;
+matrix. Update ( ) ;
+delay ( d ) ;
+}
+}
+
+void bounce ( )
+{
+int rad= 0 ;
+float y=random ( 0 ,AS1107:: Maxy + 1 ) ;
+float x=random ( 0 ,AS1107:: Maxx + 1 ) ;
+float xacc=random ( 0 , 5 ) - 2 ;
+float yacc=random ( 0 , 5 ) - 2 ;
+float yg= 0 . 08 ;
+if ( xacc == 0 ) xacc == 1 ;
+if ( yacc == 0 ) yacc == - 1 ;
+for ( int i= 1 ; i<= 300 ; i++ )
+{
+x+=xacc;
+y+=yacc;
+yacc += yg;
+if ( x >= ( AS1107:: Maxx -rad ) ) {
+xacc = -xacc* 0 . 9 ;
+x= AS1107:: Maxx -rad;
+}
+else if ( x <= rad ) {
+xacc = -xacc* 0 . 8 ;
+x= rad;
+}
+if ( y >= ( AS1107:: Maxy -rad ) ) {
+yacc = - ( yacc* 0 . 80 ) ;
+y= AS1107:: Maxy -rad;
+}
+else if ( y <= rad ) {
+yacc = -yacc* 0 . 8 ;
+y= rad;
+}
+matrix. Clear ( ) ;
+matrix. SetLed ( x,y, 1 ) ;
+matrix. Update ( ) ;
+}
+} \ No newline at end of file
diff --git a/Arduino/Libraies/AS1107/keywords.txt b/Arduino/Libraies/AS1107/keywords.txt
new file mode 100755
index 0000000..06ffc27
--- /dev/null
+++ b/Arduino/Libraies/AS1107/keywords.txt
@@ -0,0 +1,39 @@
+#######################################
+# Syntax Coloring Map For AS1107Graphic
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+AS1107 KEYWORD1
+
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+WriteRegister KEYWORD2
+WriteColumn KEYWORD2
+Init KEYWORD2
+SetLed KEYWORD2
+Clear KEYWORD2
+Update KEYWORD2
+ShiftLeft KEYWORD2
+ShiftRight KEYWORD2
+ShiftUp KEYWORD2
+ShiftDown KEYWORD2
+DrawLine KEYWORD2
+DrawBox KEYWORD2
+DrawEllipse KEYWORD2
+DrawText KEYWORD2
+DrawChar KEYWORD2
+SetScrollText KEYWORD2
+TextScroll KEYWORD2
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+
+ON LITERAL1
+OFF LITERAL1 \ No newline at end of file
diff --git a/Arduino/Libraies/Keypad/Examples/CustomKeypad/CustomKeypad.pde b/Arduino/Libraies/Keypad/Examples/CustomKeypad/CustomKeypad.pde
new file mode 100755
index 0000000..408bcdb
--- /dev/null
+++ b/Arduino/Libraies/Keypad/Examples/CustomKeypad/CustomKeypad.pde
@@ -0,0 +1,37 @@
+/* @file CustomKeypad.pde
+|| @version 1.0
+|| @author Alexander Brevig
+|| @contact alexanderbrevig@gmail.com
+||
+|| @description
+|| | Demonstrates changing the keypad size and key values.
+|| #
+*/
+#include <Keypad.h>
+
+const byte ROWS = 4; //four rows
+const byte COLS = 4; //four columns
+//define the cymbols on the buttons of the keypads
+char hexaKeys[ROWS][COLS] = {
+ {'0','1','2','3'},
+ {'4','5','6','7'},
+ {'8','9','A','B'},
+ {'C','D','E','F'}
+};
+byte rowPins[ROWS] = {3, 2, 1, 0}; //connect to the row pinouts of the keypad
+byte colPins[COLS] = {7, 6, 5, 4}; //connect to the column pinouts of the keypad
+
+//initialize an instance of class NewKeypad
+Keypad cusomKeypad = Keypad( makeKeymap(hexaKeys), rowPins, colPins, ROWS, COLS);
+
+void setup(){
+ Serial.begin(9600);
+}
+
+void loop(){
+ char customKey = cusomKeypad.getKey();
+
+ if (customKey != NO_KEY){
+ Serial.println(customKey);
+ }
+}
diff --git a/Arduino/Libraies/Keypad/Examples/DynamicKeypad/DynamicKeypad.pde b/Arduino/Libraies/Keypad/Examples/DynamicKeypad/DynamicKeypad.pde
new file mode 100755
index 0000000..01f2ffe
--- /dev/null
+++ b/Arduino/Libraies/Keypad/Examples/DynamicKeypad/DynamicKeypad.pde
@@ -0,0 +1,187 @@
+/* @file DynamicKeypad.pde
+|| @version 1.0
+|| @author Mark Stanley
+|| @contact mstanley@technologist.com
+||
+|| @dificulty: Intermediate
+||
+|| *** THE KEYPAD REQUIRES PULL-UP RESISTORS ON THE ROW PINS. ***
+||
+|| @description
+|| | This is a demonstration of keypadEvents. It's used to switch between keymaps
+|| | while using only one keypad. The main concepts being demonstrated are:
+|| |
+|| | Using the keypad events, PRESSED, HOLD and RELEASED to simplify coding.
+|| | How to use setHoldTime() and why.
+|| | Making more than one thing happen with the same key.
+|| | Assigning and changing keymaps on the fly.
+|| |
+|| | Another useful feature is also included with this demonstration although
+|| | it's not really one of the concepts that I wanted to show you. If you look
+|| | at the code in the PRESSED event you will see that the first section of that
+|| | code is used to scroll through three different letters on each key. For
+|| | example, pressing the '2' key will step through the letters 'd', 'e' and 'f'.
+|| |
+|| |
+|| | Using the keypad events, PRESSED, HOLD and RELEASED to simplify coding
+|| | Very simply, the PRESSED event occurs imediately upon detecting a pressed
+|| | key and will not happen again until after a RELEASED event. When the HOLD
+|| | event fires it always falls between PRESSED and RELEASED. However, it will
+|| | only occur if a key has been pressed for longer than the setHoldTime() interval.
+|| |
+|| | How to use setHoldTime() and why
+|| | Take a look at keypad.setHoldTime(500) in the code. It is used to set the
+|| | time delay between a PRESSED event and the start of a HOLD event. The value
+|| | 500 is in milliseconds (mS) and is equivalent to half a second. After pressing
+|| | a key for 500mS the HOLD event will fire and any code contained therein will be
+|| | executed. This event will stay active for as long as you hold the key except
+|| | in the case of bug #1 listed above.
+|| |
+|| | Making more than one thing happen with the same key.
+|| | If you look under the PRESSED event (case PRESSED:) you will see that the '#'
+|| | is used to print a new line, Serial.println(). But take a look at the first
+|| | half of the HOLD event and you will see the same key being used to switch back
+|| | and forth between the letter and number keymaps that were created with alphaKeys[4][5]
+|| | and numberKeys[4][5] respectively.
+|| |
+|| | Assigning and changing keymaps on the fly
+|| | You will see that the '#' key has been designated to perform two different functions
+|| | depending on how long you hold it down. If you press the '#' key for less than the
+|| | setHoldTime() then it will print a new line. However, if you hold if for longer
+|| | than that it will switch back and forth between numbers and letters. You can see the
+|| | keymap changes in the HOLD event.
+|| |
+|| |
+|| | In addition...
+|| | You might notice a couple of things that you won't find in the Arduino language
+|| | reference. The first would be #include <ctype.h>. This is a standard library from
+|| | the C programming language and though I don't normally demonstrate these types of
+|| | things from outside the Arduino language reference I felt that its use here was
+|| | justified by the simplicity that it brings to this sketch.
+|| | That simplicity is provided by the two calls to isalpha(key) and isdigit(key).
+|| | The first one is used to decide if the key that was pressed is any letter from a-z
+|| | or A-Z and the second one decides if the key is any number from 0-9. The return
+|| | value from these two functions is either a zero or some positive number greater
+|| | than zero. This makes it very simple to test a key and see if it is a number or
+|| | a letter. So when you see the following:
+|| |
+|| | if (isalpha(key)) // this tests to see if your key was a letter
+|| |
+|| | And the following may be more familiar to some but it is equivalent:
+|| |
+|| | if (isalpha(key) != 0) // this tests to see if your key was a letter
+|| |
+|| | And Finally...
+|| | To better understand how the event handler affects your code you will need to remember
+|| | that it gets called only when you press, hold or release a key. However, once a key
+|| | is pressed or held then the event handler gets called at the full speed of the loop().
+|| |
+|| | *** THE KEYPAD REQUIRES PULL-UP RESISTORS ON THE ROW PINS. ***
+|| #
+*/
+#include <Keypad.h>
+#include <ctype.h>
+
+// Define the keymaps. The blank spot (lower left) is the space character.
+char alphaKeys[4][3] = {
+ { 'a','d','g' },
+ { 'j','m','p' },
+ { 's','v','y' },
+ { ' ','.','#' }
+};
+
+char numberKeys[4][3] = {
+ { '1','2','3' },
+ { '4','5','6' },
+ { '7','8','9' },
+ { ' ','0','#' }
+};
+
+boolean alpha = false; // Start with the numeric keypad.
+
+char* keypadMap = (alpha == true) ? makeKeymap(alphaKeys) : makeKeymap(numberKeys);
+
+// Connect keypad ROW0, ROW1, ROW2 and ROW3 to these pins, eg. ROW0 = Arduino pin2.
+byte rowPins[] = { 9, 8, 7, 6 };
+
+// Connect keypad COL0, COL1 and COL2 to these pins, eg. COL0 = Arduino pin6.
+byte colPins[] = { 12, 11, 10 };
+
+//create a new Keypad
+Keypad keypad = Keypad(keypadMap, rowPins, colPins, sizeof(rowPins), sizeof(colPins));
+
+const byte ledPin = 13; // Use the LED on pin 13.
+
+void setup() {
+ Serial.begin(9600);
+ digitalWrite(ledPin, HIGH); // Turns the LED on.
+ keypad.addEventListener(keypadEvent); // Add an event listener.
+ keypad.setHoldTime(500); // Default is 1000mS
+ keypad.setDebounceTime(250); // Default is 50mS
+}
+
+void loop() {
+ char key = keypad.getKey();
+
+ if (alpha) { // Flash the LED if we are using the letter keymap.
+ digitalWrite(ledPin,!digitalRead(ledPin));
+ delay(100);
+ }
+}
+
+// Take care of some special events.
+void keypadEvent(KeypadEvent key) {
+ static char virtKey = NO_KEY; // Stores the last virtual key press. (Alpha keys only)
+ static char physKey = NO_KEY; // Stores the last physical key press. (Alpha keys only)
+ static char buildStr[12];
+ static byte buildCount;
+ static byte pressCount;
+
+ switch (keypad.getState())
+ {
+ case PRESSED:
+ if (isalpha(key)) { // This is a letter key so we're using the letter keymap.
+ if (physKey != key) { // New key so start with the first of 3 characters.
+ pressCount = 0;
+ virtKey = key;
+ physKey = key;
+ }
+ else { // Pressed the same key again...
+ virtKey++; // so select the next character on that key.
+ pressCount++; // Tracks how many times we press the same key.
+ }
+ if (pressCount > 2) { // Last character reached so cycle back to start.
+ pressCount = 0;
+ virtKey = key;
+ }
+ Serial.print(virtKey); // Used for testing.
+ }
+ if (isdigit(key) || key == ' ' || key == '.') Serial.print(key);
+ if (key == '#') Serial.println();
+ break;
+
+ case HOLD:
+ if (key == '#') { // Toggle between keymaps.
+ if (alpha == true) { // We are currently using a keymap with letters
+ keypad.begin(*numberKeys); // and want to change to numbers.
+ alpha = false;
+ }
+ else { // Or, we are currently using a keymap with numbers
+ keypad.begin(*alphaKeys); // and want to change to letters.
+ alpha = true;
+ }
+ }
+ else { // Some key other than '#' was pressed.
+ buildStr[buildCount++] = (isalpha(key)) ? virtKey : key;
+ buildStr[buildCount] = '\0';
+ Serial.println();
+ Serial.println(buildStr);
+ }
+ break;
+
+ case RELEASED:
+ if (buildCount >= sizeof(buildStr)) buildCount = 0; // Our string is full. Start fresh.
+ break;
+
+ } // end switch-case
+} // end keypad events
diff --git a/Arduino/Libraies/Keypad/Examples/EventKeypad/EventKeypad.pde b/Arduino/Libraies/Keypad/Examples/EventKeypad/EventKeypad.pde
new file mode 100755
index 0000000..db53ff0
--- /dev/null
+++ b/Arduino/Libraies/Keypad/Examples/EventKeypad/EventKeypad.pde
@@ -0,0 +1,72 @@
+/* @file EventSerialKeypad.pde
+|| @version 1.0
+|| @author Alexander Brevig
+|| @contact alexanderbrevig@gmail.com
+||
+|| @description
+|| | Demonstrates using the KeypadEvent.
+|| #
+*/
+#include <Keypad.h>
+
+const byte ROWS = 4; //four rows
+const byte COLS = 4; //four columns
+char keys[ROWS][COLS] = {
+ {'1','2','3','A'},
+ {'4','5','6','B'},
+ {'7','8','9','C'},
+ {'#','0','*','D'}
+};
+byte rowPins[ROWS] = {2,3,4,5}; //connect to the row pinouts of the keypad
+byte colPins[COLS] = {6,7,8,9}; //connect to the column pinouts of the keypad
+
+Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
+byte ledPin = 13;
+
+boolean blink = false;
+
+void setup(){
+ Serial.begin(9600);
+ pinMode(ledPin, OUTPUT); // sets the digital pin as output
+ digitalWrite(ledPin, HIGH); // sets the LED on
+ keypad.addEventListener(keypadEvent); //add an event listener for this keypad
+}
+
+void loop(){
+ char key = keypad.getKey();
+
+ if (key != NO_KEY) {
+ Serial.println(key);
+ }
+ if (blink){
+ digitalWrite(ledPin,!digitalRead(ledPin));
+ delay(100);
+ }
+}
+
+//take care of some special events
+void keypadEvent(KeypadEvent key){
+ switch (keypad.getState()){
+ case PRESSED:
+ switch (key){
+ case '#': digitalWrite(ledPin,!digitalRead(ledPin)); break;
+ case '*':
+ digitalWrite(ledPin,!digitalRead(ledPin));
+ break;
+ }
+ break;
+ case RELEASED:
+ switch (key){
+ case '*':
+ digitalWrite(ledPin,!digitalRead(ledPin));
+ blink = false;
+ break;
+ }
+ break;
+ case HOLD:
+ switch (key){
+ case '*': blink = true; break;
+ }
+ break;
+ }
+}
diff --git a/Arduino/Libraies/Keypad/Examples/HelloKeypad/HelloKeypad.pde b/Arduino/Libraies/Keypad/Examples/HelloKeypad/HelloKeypad.pde
new file mode 100755
index 0000000..c001965
--- /dev/null
+++ b/Arduino/Libraies/Keypad/Examples/HelloKeypad/HelloKeypad.pde
@@ -0,0 +1,35 @@
+/* @file HelloKeypad.pde
+|| @version 1.0
+|| @author Alexander Brevig
+|| @contact alexanderbrevig@gmail.com
+||
+|| @description
+|| | Demonstrates the simplest use of the matrix Keypad library.
+|| #
+*/
+#include <Keypad.h>
+
+const byte ROWS = 4; //four rows
+const byte COLS = 3; //three columns
+char keys[ROWS][COLS] = {
+ {'1','2','3'},
+ {'4','5','6'},
+ {'7','8','9'},
+ {'#','0','*'}
+};
+byte rowPins[ROWS] = {5, 4, 3, 2}; //connect to the row pinouts of the keypad
+byte colPins[COLS] = {8, 7, 6}; //connect to the column pinouts of the keypad
+
+Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS );
+
+void setup(){
+ Serial.begin(9600);
+}
+
+void loop(){
+ char key = keypad.getKey();
+
+ if (key != NO_KEY){
+ Serial.println(key);
+ }
+}
diff --git a/Arduino/Libraies/Keypad/Keypad.cpp b/Arduino/Libraies/Keypad/Keypad.cpp
new file mode 100755
index 0000000..3c7ffc6
--- /dev/null
+++ b/Arduino/Libraies/Keypad/Keypad.cpp
@@ -0,0 +1,174 @@
+/*
+||
+|| @file Keypad.h
+|| @version 1.8
+|| @author Mark Stanley, Alexander Brevig
+|| @contact mstanley@technologist.com, alexanderbrevig@gmail.com
+||
+|| @description
+|| | This library provides a simple interface for using matrix
+|| | keypads. It supports the use of multiple keypads with the
+|| | same or different sets of keys. It also supports user
+|| | selectable pins and definable keymaps.
+|| #
+||
+|| @license
+|| | This library is free software; you can redistribute it and/or
+|| | modify it under the terms of the GNU Lesser General Public
+|| | License as published by the Free Software Foundation; version
+|| | 2.1 of the License.
+|| |
+|| | This library 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
+|| | Lesser General Public License for more details.
+|| |
+|| | You should have received a copy of the GNU Lesser General Public
+|| | License along with this library; if not, write to the Free Software
+|| | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+|| #
+||
+*/
+
+#include "Keypad.h"
+
+// <<constructor>> Allows custom keymap. pin configuration and keypad size
+Keypad::Keypad(char *userKeymap, byte *row, byte *col, byte rows, byte cols)
+{
+ rowPins = row;
+ columnPins = col;
+
+ //Serial.println("Override");
+ size.rows = rows;
+ //size.rows = 8;
+ size.columns = cols;
+ //size.columns = 16;
+
+ //Serial.print("Constructor Col ");
+ //int colSize = size.columns;
+ //Serial.print(colSize);
+ //int rowSize = size.rows;
+ //Serial.print(" Row ");
+ //Serial.println(rowSize);
+
+ begin(userKeymap);
+
+ lastUpdate = 0;
+ debounceTime = 50;
+ holdTime = 1000;
+ keypadEventListener = 0;
+ currentKey = NO_KEY;
+ state = IDLE;
+
+ initializePins();
+}
+
+// Let the user define a keymap - assume the same row- / columncount as defined in constructor
+void Keypad::begin( char *userKeymap){
+ keymap = userKeymap;
+}
+
+// Returns the keykode of the pressed key, or NO_KEY if no key is pressed
+char Keypad::getKey(){
+ //Serial.print("GetKey Col ");
+ //int colSize = size.columns;
+ //Serial.print(colSize);
+ //int rowSize = size.rows;
+ //Serial.print(" Row ");
+ //Serial.println(rowSize);
+ char key = NO_KEY; // Assume that no key is pressed, this is the default return for getKey()
+ for (byte c=0; c<size.columns; c++){
+ //Serial.print("col ");
+ //int cInt = c;
+ //Serial.println(cInt);
+ digitalWrite(columnPins[c],LOW); // Activate the current column.
+ for (byte r=0; r<size.rows; r++){ // Scan all the rows for a key press.
+ //Serial.print("row");
+ //int rInt = r;
+ //Serial.println(rInt);
+ // The user pressed a button for more then debounceTime microseconds.
+ if (currentKey == keymap[c+(r*size.columns)]){
+ // Button hold
+ if (((millis()-lastUpdate) >= holdTime) && digitalRead(rowPins[r]) == LOW){
+ transitionTo(HOLD);
+ }
+ // Button release
+ if (((millis()-lastUpdate) >= debounceTime) && digitalRead(rowPins[r]) == HIGH){
+ transitionTo(RELEASED);
+ currentKey = NO_KEY;
+ }
+ }
+ // Button pressed event. The user pressed a button.
+ else if (((millis()-lastUpdate) >= debounceTime) && digitalRead(rowPins[r]) == LOW){
+ digitalWrite(columnPins[c],HIGH); // De-activate the current column.
+ key = keymap[c+(r*size.columns)];
+ lastUpdate = millis();
+ goto EVALUATE_KEY; // Save resources and do not attempt to parse to keys at a time
+ }
+ }
+ digitalWrite(columnPins[c],HIGH); // De-activate the current column.
+ }
+
+ EVALUATE_KEY:
+ if (key != NO_KEY && key != currentKey){
+ currentKey = key;
+ transitionTo(PRESSED);
+ return currentKey;
+ }
+ else{
+ return NO_KEY;
+ }
+}
+
+
+KeypadState Keypad::getState(){
+ return state;
+}
+
+void Keypad::setDebounceTime(unsigned int debounce){
+ debounceTime = debounce;
+}
+void Keypad::setHoldTime(unsigned int hold){
+ holdTime = hold;
+}
+
+void Keypad::addEventListener(void (*listener)(char)){
+ keypadEventListener = listener;
+}
+
+//private
+void Keypad::transitionTo(KeypadState newState){
+ if (state!=newState){
+ state = newState;
+ if (keypadEventListener!=NULL){
+ keypadEventListener(currentKey);
+ }
+ }
+}
+
+void Keypad::initializePins(){
+ for (byte r=0; r<size.rows; r++){
+ for (byte c=0; c<size.columns; c++){
+ pinMode(columnPins[c],OUTPUT);
+ digitalWrite(columnPins[c],HIGH);
+ }
+ //configure row pin modes and states
+ pinMode(rowPins[r],INPUT);
+ digitalWrite(rowPins[r],HIGH);
+ }
+}
+
+/*
+|| @changelog
+|| | 2009-07-08 - Alexander Brevig : Library does not use 2d arrays
+|| | 2009-06-15 - Alexander Brevig : Added transitionTo
+|| | 2009-06-15 - Alexander Brevig : Added getState()
+|| | 2009-06-13 - Mark Stanley : Fixed bug in getKey() that returns the wrong key if debounceTime is too short.
+|| | 2009-06-13 - Mark Stanley : Minor bug fix: Added 'currentKey = NO_KEY' to constructors.
+|| | 2009-05-19 - Alexander Brevig : Added setHoldTime()
+|| | 2009-05-15 - Alexander Brevig : Changed begin() amd getKey(), this Library should be operational.
+|| | 2009-05-09 - Alexander Brevig : Changed getKey()
+|| | 2009-04-28 - Alexander Brevig : Modified API, and made variables private
+|| | 2007-XX-XX - Mark Stanley : Initial Release
+|| #
+*/
diff --git a/Arduino/Libraies/Keypad/Keypad.h b/Arduino/Libraies/Keypad/Keypad.h
new file mode 100755
index 0000000..bab6132
--- /dev/null
+++ b/Arduino/Libraies/Keypad/Keypad.h
@@ -0,0 +1,108 @@
+/*
+||
+|| @file Keypad.h
+|| @version 1.8
+|| @author Mark Stanley, Alexander Brevig
+|| @contact mstanley@technologist.com, alexanderbrevig@gmail.com
+||
+|| @description
+|| | This library provides a simple interface for using matrix
+|| | keypads. It supports the use of multiple keypads with the
+|| | same or different sets of keys. It also supports user
+|| | selectable pins and definable keymaps.
+|| #
+||
+|| @license
+|| | This library is free software; you can redistribute it and/or
+|| | modify it under the terms of the GNU Lesser General Public
+|| | License as published by the Free Software Foundation; version
+|| | 2.1 of the License.
+|| |
+|| | This library 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
+|| | Lesser General Public License for more details.
+|| |
+|| | You should have received a copy of the GNU Lesser General Public
+|| | License along with this library; if not, write to the Free Software
+|| | Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+|| #
+||
+*/
+
+#ifndef KEYPAD_H
+#define KEYPAD_H
+
+#include <WProgram.h>
+
+#define makeKeymap(x) ((char*)x)
+
+typedef char KeypadEvent;
+
+typedef enum {
+ IDLE=0,
+ PRESSED,
+ RELEASED,
+ HOLD
+} KeypadState;
+
+// : 8 refers to the variable occupying 8 bits of memory
+typedef struct {
+ byte rows : 8;
+ byte columns : 8;
+} KeypadSize;
+
+const char NO_KEY = '\0';
+#define KEY_RELEASED NO_KEY
+
+class Keypad {
+public:
+ /*
+ Keypad();
+ Keypad(byte row[], byte col[], byte rows, byte cols);
+ */
+ Keypad(char *userKeymap, byte *row, byte *col, byte rows, byte cols);
+
+ //void begin(); //DEPRECATED!
+ void begin(char *userKeymap);
+ char getKey();
+ KeypadState getState();
+ void setDebounceTime(unsigned int debounce);
+ void setHoldTime(unsigned int hold);
+ void addEventListener(void (*listener)(char));
+
+private:
+ void transitionTo(KeypadState newState);
+ void initializePins();
+
+ char *keymap;
+ byte *rowPins;
+ byte *columnPins;
+ KeypadSize size;
+ KeypadState state;
+ char currentKey;
+ unsigned long lastUpdate;
+ unsigned int debounceTime;
+ unsigned int holdTime;
+ void (*keypadEventListener)(char);
+};
+
+#endif
+
+/*
+|| @changelog
+|| | 1.8 2009-07-08 - Alexander Brevig : No longer uses arrays
+|| | 1.7 2009-06-18 - Alexander Brevig : This library is a Finite State Machine
+|| | every time a state changes the keypadEventListener will trigger, if set
+|| | 1.7 2009-06-18 - Alexander Brevig : Added setDebounceTime
+|| | setHoldTime specifies the amount of microseconds before a HOLD state triggers
+|| | 1.7 2009-06-18 - Alexander Brevig : Added transitionTo
+|| | 1.6 2009-06-15 - Alexander Brevig : Added getState() and state variable
+|| | 1.5 2009-05-19 - Alexander Brevig : Added setHoldTime()
+|| | 1.4 2009-05-15 - Alexander Brevig : Added addEventListener
+|| | 1.3 2009-05-12 - Alexander Brevig : Added lastUdate, in order to do simple debouncing
+|| | 1.2 2009-05-09 - Alexander Brevig : Changed getKey()
+|| | 1.1 2009-04-28 - Alexander Brevig : Modified API, and made variables private
+|| | 1.0 2007-XX-XX - Mark Stanley : Initial Release
+|| #
+*/
diff --git a/Arduino/Libraies/Keypad/README b/Arduino/Libraies/Keypad/README
new file mode 100644
index 0000000..504a22a
--- /dev/null
+++ b/Arduino/Libraies/Keypad/README
@@ -0,0 +1 @@
+Modified the bit fields in the KeypadSize structure to allow for a big enough matrix
diff --git a/Arduino/Libraies/Keypad/keywords.txt b/Arduino/Libraies/Keypad/keywords.txt
new file mode 100755
index 0000000..2ae39b8
--- /dev/null
+++ b/Arduino/Libraies/Keypad/keywords.txt
@@ -0,0 +1,17 @@
+Keypad KEYWORD1
+KeypadEvent KEYWORD1
+
+begin KEYWORD2
+getKey KEYWORD2
+getState KEYWORD2
+setHoldTime KEYWORD2
+addEventListener KEYWORD2
+
+# this is a macro that converts 2d arrays to pointers
+makeKeymap KEYWORD2
+
+# this is a way to standardize the client code, help enhance the use of the name keypadEvent
+keypadEvent KEYWORD2
+
+NO_KEY LITERAL1
+KEY_RELEASED LITERAL1