Christopher Lu
an mbed tile music game using a capacitive touchpad and uLCD
Dependencies: SDFileSystem mbed wave_player
Revision 0:a1c374b9a4fe, committed 2016-03-14
- Comitter:
- clu67
- Date:
- Mon Mar 14 00:26:24 2016 +0000
- Commit message:
- Initial Release
Changed in this revision
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL.h Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,348 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems TFT touch screens
+//
+// Fork of 4DGL library for 4D Systems LCD displays
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL. If not, see <http://www.gnu.org/licenses/>.
+
+// @author Stephane Rochon
+
+#include "mbed.h"
+#ifndef _uLCD
+#define _uLCD 0
+// Debug Verbose off - SGE commands echoed to USB serial for debugmode=1
+#ifndef DEBUGMODE
+#define DEBUGMODE 0
+#endif
+
+// Common WAIT value in milliseconds between commands
+#define TEMPO 0
+
+// 4DGL SGE Function values for Goldelox Processor
+#define CLS '\xD7'
+#define BAUDRATE '\x0B' //null prefix
+#define VERSION '\x08' //null prefix
+#define BCKGDCOLOR '\x6E'
+#define TXTBCKGDCOLOR '\x7E'
+#define DISPCONTROL '\x68'
+#define SETVOLUME '\x76'
+#define CIRCLE '\xCD'
+#define FCIRCLE '\xCC'
+#define TRIANGLE '\xC9'
+#define LINE '\xD2'
+#define FRECTANGLE '\xCE'
+#define RECTANGLE '\xCF'
+#define ELLIPSE '\x65' //na
+#define PIXEL '\xCB'
+#define READPIXEL '\xCA'
+#define SCREENCOPY '\x63' //na?
+#define PENSIZE '\xD8'
+#define SETFONT '\x7D'
+#define TEXTMODE '\x77'
+#define TEXTBOLD '\x76'
+#define TEXTITALIC '\x75'
+#define TEXTINVERSE '\x74'
+#define TEXTUNDERLINE '\x73'
+#define TEXTWIDTH '\x7C'
+#define TEXTHEIGHT '\x7B'
+#define TEXTCHAR '\xFE'
+#define TEXTSTRING '\x06' //null prefix
+#define MOVECURSOR '\xE4'
+#define BLITCOM '\x0A'
+#define PUTCHAR '\xFE'
+#define DISPPOWER '\x66'
+//media commands for uSD card
+#define MINIT '\xB1'
+#define SBADDRESS '\xB9'
+#define SSADDRESS '\xB8'
+#define READBYTE '\xB7'
+#define READWORD '\xB6'
+#define WRITEBYTE '\xB5'
+#define WRITEWORD '\xB4'
+#define FLUSHMEDIA '\xB2'
+#define DISPLAYIMAGE '\xB3'
+#define DISPLAYVIDEO '\xBB'
+#define DISPLAYFRAME '\xBA'
+
+
+
+// Screen answers
+#define ACK '\x06'
+#define NAK '\x15'
+
+
+
+// Screen states
+#define OFF '\x00'
+#define ON '\x01'
+
+// Graphics modes
+#define SOLID '\x00'
+#define WIREFRAME '\x01'
+
+// Text modes
+#define TRANSPARENT '\x00'
+#define OPAQUE '\x01'
+
+// Fonts Sizes
+#define FONT_7X8 '\x00' //only builtin font
+#define FONT_5X7 '\x04'
+#define FONT_8X8 '\x01'
+#define FONT_8X12 '\x02'
+#define FONT_12X16 '\x03'
+#define MEDIAFONT '\x07'
+
+
+// Data speed
+#define BAUD_110 27271
+#define BAUD_300 9999
+#define BAUD_600 4999
+#define BAUD_1200 2499
+#define BAUD_2400 1249
+#define BAUD_4800 624
+#define BAUD_9600 312
+#define BAUD_14400 207
+#define BAUD_19200 155
+#define BAUD_31250 95
+#define BAUD_38400 77
+#define BAUD_56000 53
+#define BAUD_57600 51
+#define BAUD_115200 25
+#define BAUD_128000 22
+#define BAUD_256000 11
+#define BAUD_300000 10
+#define BAUD_375000 8
+#define BAUD_500000 6
+#define BAUD_600000 4
+#define BAUD_750000 3
+#define BAUD_1000000 2
+#define BAUD_1500000 1
+#define BAUD_3000000 0
+
+// Defined Colors
+#define WHITE 0xFFFFFF
+#define BLACK 0x000000
+#define RED 0xFF0000
+#define GREEN 0x00FF00
+#define BLUE 0x0000FF
+#define LGREY 0xBFBFBF
+#define DGREY 0x5F5F5F
+
+// Mode data
+#define BACKLIGHT '\x00'
+#define DISPLAY '\x01'
+#define CONTRAST '\x02'
+#define POWER '\x03'
+#define ORIENTATION '\x04'
+#define TOUCH_CTRL '\x05'
+#define IMAGE_FORMAT '\x06'
+#define PROTECT_FAT '\x08'
+
+// change this to your specific screen (newer versions) if needed
+// Startup orientation is PORTRAIT so SIZE_X must be lesser than SIZE_Y
+//uLCD144-G2 is a 128 by 128 pixel display
+#define SIZE_X 128
+#define SIZE_Y 128
+
+#define IS_LANDSCAPE 0
+#define IS_PORTRAIT 1
+
+// Screen orientation
+#define LANDSCAPE '\x00'
+#define LANDSCAPE_R '\x01'
+#define PORTRAIT '\x02'
+#define PORTRAIT_R '\x03'
+
+// Parameters
+#define ENABLE '\x00'
+#define DISABLE '\x01'
+#define RESET '\x02'
+
+#define NEW '\x00'
+#define OLD '\x01'
+
+#define DOWN '\x00'
+#define UP '\x01'
+
+#define PROTECT '\x00'
+#define UNPROTECT '\x02'
+
+//**************************************************************************
+// \class uLCD_4DGL uLCD_4DGL.h
+// \brief This is the main class. It shoud be used like this : uLCD_4GDL myLCD(p9,p10,p11);
+/**
+Example:
+* @code
+* // Display a white circle on the screen
+* #include "mbed.h"
+* #include " uLCD_4DGL.h"
+*
+* uLCD_4GDL myLCD(p9,p10,p11);
+*
+* int main() {
+* myLCD.circle(120, 160, 80, WHITE);
+* }
+* @endcode
+*/
+
+class uLCD_4DGL : public Stream
+{
+
+public :
+
+ uLCD_4DGL(PinName tx, PinName rx, PinName rst);
+
+// General Commands *******************************************************************************
+
+ /** Clear the entire screen using the current background colour */
+ void cls();
+
+ /** Reset screen */
+ void reset();
+
+
+ /** Set serial Baud rate (both sides : screen and mbed)
+ * @param Speed Correct BAUD value (see uLCD_4DGL.h)
+ */
+ void baudrate(int speed);
+
+ /** Set background colour to the specified value
+ * @param color in HEX RGB like 0xFF00FF
+ */
+ void background_color(int color);
+
+ /** Set screen display mode to specific values
+ * @param mode See 4DGL documentation
+ * @param value See 4DGL documentation
+ */
+ void textbackground_color(int color);
+
+ /** Set screen display mode to specific values
+ * @param mode See 4DGL documentation
+ * @param value See 4DGL documentation
+ */
+ void display_control(char mode);
+ void display_power(char mode);
+ /** Set internal speaker to specified value
+ * @param value Correct range is 8 - 127
+ */
+ void set_volume(char value);
+
+// Graphics Commands *******************************************************************************
+
+ /** Draw a circle centered at x,y with a radius and a colour. It uses Pen Size stored value to draw a solid or wireframe circle
+ * @param x Horizontal position of the circle centre
+ * @param y Vertical position of the circle centre
+ * @param radius Radius of the circle
+ * @param color Circle color in HEX RGB like 0xFF00FF
+ */
+ void circle(int x , int y , int radius, int color);
+ void filled_circle(int x , int y , int radius, int color);
+ void triangle(int, int, int, int, int, int, int);
+ void line(int, int, int, int, int);
+ void rectangle(int, int, int, int, int);
+ void filled_rectangle(int, int, int, int, int);
+ void pixel(int, int, int);
+ int read_pixel(int, int);
+ void pen_size(char);
+ void BLIT(int x, int y, int w, int h, int *colors);
+
+// Text Commands
+ void set_font(char);
+ void set_font_size(char width, char height);
+ void text_mode(char);
+ void text_bold(char);
+ void text_italic(char);
+ void text_inverse(char);
+ void text_underline(char);
+ void text_width(char);
+ void text_height(char);
+ void text_char(char, char, char, int);
+ void text_string(char *, char, char, char, int);
+ void locate(char, char);
+ void color(int);
+ void putc(char);
+ void puts(char *);
+
+//Media Commands
+ int media_init();
+ void set_byte_address(int, int);
+ void set_sector_address(int, int);
+ char read_byte();
+ int read_word();
+ void write_byte(int);
+ void write_word(int);
+ void flush_media();
+ void display_image(int, int);
+ void display_video(int, int);
+ void display_frame(int, int, int);
+
+// Screen Data
+ int type;
+ int revision;
+ int firmware;
+ int reserved1;
+ int reserved2;
+
+// Text data
+ char current_col;
+ char current_row;
+ int current_color;
+ char current_font;
+ char current_orientation;
+ char max_col;
+ char max_row;
+ int current_w, current_h;
+ int current_fx, current_fy;
+ int current_wf, current_hf;
+
+
+protected :
+
+ Serial _cmd;
+ DigitalOut _rst;
+ //used by printf
+ virtual int _putc(int c) {
+ putc(c);
+ return 0;
+ };
+ virtual int _getc() {
+ return -1;
+ }
+
+ void freeBUFFER (void);
+ void writeBYTE (char);
+ void writeBYTEfast (char);
+ int writeCOMMAND(char *, int);
+ int writeCOMMANDnull(char *, int);
+ int readVERSION (char *, int);
+ int getSTATUS (char *, int);
+ int version (void);
+#if DEBUGMODE
+ Serial pc;
+#endif // DEBUGMODE
+};
+
+typedef unsigned char BYTE;
+#endif
+
+
+
+
+
+
+
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_Graphics.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_Graphics.cpp Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,311 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems LCD screens
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL. If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+#define ARRAY_SIZE(X) sizeof(X)/sizeof(X[0])
+
+//****************************************************************************************************
+void uLCD_4DGL :: circle(int x, int y , int radius, int color) // draw a circle in (x,y)
+{
+ char command[9]= "";
+
+ command[0] = CIRCLE;
+
+ command[1] = (x >> 8) & 0xFF;
+ command[2] = x & 0xFF;
+
+ command[3] = (y >> 8) & 0xFF;
+ command[4] = y & 0xFF;
+
+ command[5] = (radius >> 8) & 0xFF;
+ command[6] = radius & 0xFF;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[7] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[8] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 9);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: filled_circle(int x, int y , int radius, int color) // draw a circle in (x,y)
+{
+ char command[9]= "";
+
+ command[0] = FCIRCLE;
+
+ command[1] = (x >> 8) & 0xFF;
+ command[2] = x & 0xFF;
+
+ command[3] = (y >> 8) & 0xFF;
+ command[4] = y & 0xFF;
+
+ command[5] = (radius >> 8) & 0xFF;
+ command[6] = radius & 0xFF;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[7] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[8] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 9);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: triangle(int x1, int y1 , int x2, int y2, int x3, int y3, int color) // draw a traingle
+{
+ char command[15]= "";
+
+ command[0] = TRIANGLE;
+
+ command[1] = (x1 >> 8) & 0xFF;
+ command[2] = x1 & 0xFF;
+
+ command[3] = (y1 >> 8) & 0xFF;
+ command[4] = y1 & 0xFF;
+
+ command[5] = (x2 >> 8) & 0xFF;
+ command[6] = x2 & 0xFF;
+
+ command[7] = (y2 >> 8) & 0xFF;
+ command[8] = y2 & 0xFF;
+
+ command[9] = (x3 >> 8) & 0xFF;
+ command[10] = x3 & 0xFF;
+
+ command[11] = (y3 >> 8) & 0xFF;
+ command[12] = y3 & 0xFF;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[13] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[14] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 15);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: line(int x1, int y1 , int x2, int y2, int color) // draw a line
+{
+ char command[11]= "";
+
+ command[0] = LINE;
+
+ command[1] = (x1 >> 8) & 0xFF;
+ command[2] = x1 & 0xFF;
+
+ command[3] = (y1 >> 8) & 0xFF;
+ command[4] = y1 & 0xFF;
+
+ command[5] = (x2 >> 8) & 0xFF;
+ command[6] = x2 & 0xFF;
+
+ command[7] = (y2 >> 8) & 0xFF;
+ command[8] = y2 & 0xFF;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[9] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[10] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 11);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: rectangle(int x1, int y1 , int x2, int y2, int color) // draw a rectangle
+{
+ char command[11]= "";
+
+ command[0] = RECTANGLE;
+
+ command[1] = (x1 >> 8) & 0xFF;
+ command[2] = x1 & 0xFF;
+
+ command[3] = (y1 >> 8) & 0xFF;
+ command[4] = y1 & 0xFF;
+
+ command[5] = (x2 >> 8) & 0xFF;
+ command[6] = x2 & 0xFF;
+
+ command[7] = (y2 >> 8) & 0xFF;
+ command[8] = y2 & 0xFF;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[9] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[10] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 11);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: filled_rectangle(int x1, int y1 , int x2, int y2, int color) // draw a rectangle
+{
+ char command[11]= "";
+
+ command[0] = FRECTANGLE;
+
+ command[1] = (x1 >> 8) & 0xFF;
+ command[2] = x1 & 0xFF;
+
+ command[3] = (y1 >> 8) & 0xFF;
+ command[4] = y1 & 0xFF;
+
+ command[5] = (x2 >> 8) & 0xFF;
+ command[6] = x2 & 0xFF;
+
+ command[7] = (y2 >> 8) & 0xFF;
+ command[8] = y2 & 0xFF;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[9] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[10] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 11);
+}
+
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: pixel(int x, int y, int color) // draw a pixel
+{
+ char command[7]= "";
+
+ command[0] = PIXEL;
+
+ command[1] = (x >> 8) & 0xFF;
+ command[2] = x & 0xFF;
+
+ command[3] = (y >> 8) & 0xFF;
+ command[4] = y & 0xFF;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[5] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[6] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 7);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: BLIT(int x, int y, int w, int h, int *colors) // draw a block of pixels
+{
+ int red5, green6, blue5;
+ writeBYTEfast('\x00');
+ writeBYTEfast(BLITCOM);
+ writeBYTEfast((x >> 8) & 0xFF);
+ writeBYTEfast(x & 0xFF);
+ writeBYTEfast((y >> 8) & 0xFF);
+ writeBYTEfast(y & 0xFF);
+ writeBYTEfast((w >> 8) & 0xFF);
+ writeBYTE(w & 0xFF);
+ writeBYTE((h >> 8) & 0xFF);
+ writeBYTE(h & 0xFF);
+ wait_ms(1);
+ for (int i=0; i<w*h; i++) {
+ red5 = (colors[i] >> (16 + 3)) & 0x1F; // get red on 5 bits
+ green6 = (colors[i] >> (8 + 2)) & 0x3F; // get green on 6 bits
+ blue5 = (colors[i] >> (0 + 3)) & 0x1F; // get blue on 5 bits
+ writeBYTEfast(((red5 << 3) + (green6 >> 3)) & 0xFF); // first part of 16 bits color
+ writeBYTEfast(((green6 << 5) + (blue5 >> 0)) & 0xFF); // second part of 16 bits color
+ }
+ int resp=0;
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+ if (_cmd.readable()) resp = _cmd.getc(); // read response if any
+ switch (resp) {
+ case ACK : // if OK return 1
+ resp = 1;
+ break;
+ case NAK : // if NOK return -1
+ resp = -1;
+ break;
+ default :
+ resp = 0; // else return 0
+ break;
+ }
+#if DEBUGMODE
+ pc.printf(" Answer received : %d\n",resp);
+#endif
+
+}
+//******************************************************************************************************
+int uLCD_4DGL :: read_pixel(int x, int y) // read screen info and populate data
+{
+
+ char command[6]= "";
+ command[0] = 0xFF;
+ command[1] = READPIXEL;
+
+ command[2] = (x >> 8) & 0xFF;
+ command[3] = x & 0xFF;
+
+ command[4] = (y >> 8) & 0xFF;
+ command[5] = y & 0xFF;
+
+ int i, temp = 0, color = 0, resp = 0;
+ char response[3] = "";
+
+ freeBUFFER();
+
+ for (i = 0; i < 6; i++) { // send all chars to serial port
+ writeBYTE(command[i]);
+ }
+
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait a bit for screen answer
+
+ while ( resp < ARRAY_SIZE(response)) { //read ack and 16-bit color response
+ temp = _cmd.getc();
+ response[resp++] = (char)temp;
+ }
+
+ color = ((response[1] << 8) + response[2]);
+
+ return color;
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: pen_size(char mode) // set pen to SOLID or WIREFRAME
+{
+ char command[2]= "";
+
+ command[0] = PENSIZE;
+ command[1] = mode;
+ writeCOMMAND(command, 2);
+}
+
+
+
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_Media.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_Media.cpp Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,178 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems LCD screens
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL. If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+
+//Media Commands
+
+//******************************************************************************************************
+int uLCD_4DGL :: media_init()
+{
+ int resp = 0;
+ char command[1] = "";
+ command[0] = MINIT;
+ writeCOMMAND(command, 1);
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+ if (_cmd.readable()) {
+ resp = _cmd.getc(); // read response
+ resp = resp << 8 + _cmd.getc();
+ }
+ return resp;
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: set_byte_address(int hi, int lo)
+{
+ char command[5]= "";
+ command[0] = SBADDRESS;
+
+ command[1] = (hi >> 8) & 0xFF;
+ command[2] = hi & 0xFF;
+
+ command[3] = (lo >> 8) & 0xFF;
+ command[4] = lo & 0xFF;
+ writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: set_sector_address(int hi, int lo)
+{
+
+ char command[5]= "";
+ command[0] = SSADDRESS;
+
+ command[1] = (hi >> 8) & 0xFF;
+ command[2] = hi & 0xFF;
+
+ command[3] = (lo >> 8) & 0xFF;
+ command[4] = lo & 0xFF;
+ writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+char uLCD_4DGL :: read_byte()
+{
+ char resp = 0;
+ char command[1] = "";
+ command[0] = READBYTE;
+ writeCOMMAND(command, 1);
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+ if (_cmd.readable()) {
+ resp = _cmd.getc(); // read response
+ resp = _cmd.getc();
+ }
+ return resp;
+}
+
+//******************************************************************************************************
+int uLCD_4DGL :: read_word()
+{
+ int resp=0;
+ char command[1] = "";
+ command[0] = READWORD;
+ writeCOMMAND(command, 1);
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+ if (_cmd.readable()) {
+ resp = _cmd.getc(); // read response
+ resp = resp << 8 + _cmd.getc();
+ }
+ return resp;
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: write_byte(int value)
+{
+ char command[3]= "";
+
+ command[0] = WRITEBYTE;
+
+ command[1] = (value >> 8) & 0xFF;
+ command[2] = value & 0xFF;
+ writeCOMMAND(command,3);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: write_word(int value)
+{
+ char command[3]= "";
+
+ command[0] = WRITEWORD;
+
+ command[1] = (value >> 8) & 0xFF;
+ command[2] = value & 0xFF;
+ writeCOMMAND(command,3);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: flush_media()
+{
+ char command[1] = "";
+ command[0] = FLUSHMEDIA;
+ writeCOMMAND(command, 1);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: display_image(int x, int y)
+{
+ char command[6]= "";
+ command[0] = DISPLAYIMAGE;
+
+ command[1] = (x >> 8) & 0xFF;
+ command[2] = x & 0xFF;
+
+ command[3] = (y >> 8) & 0xFF;
+ command[4] = y & 0xFF;
+ writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: display_video(int x, int y)
+{
+ char command[5]= "";
+ command[0] = DISPLAYVIDEO;
+
+ command[1] = (x >> 8) & 0xFF;
+ command[2] = x & 0xFF;
+
+ command[3] = (y >> 8) & 0xFF;
+ command[4] = y & 0xFF;
+ writeCOMMAND(command, 5);
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: display_frame(int x, int y, int w)
+{
+ char command[7]= "";
+
+ command[0] = DISPLAYFRAME;
+
+ command[1] = (x >> 8) & 0xFF;
+ command[2] = x & 0xFF;
+
+ command[3] = (y >> 8) & 0xFF;
+ command[4] = y & 0xFF;
+
+ command[5] = (w >> 8) & 0xFF;
+ command[6] = w & 0xFF;
+ writeCOMMAND(command,7);
+}
+
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_Text.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_Text.cpp Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,344 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems TFT touch screens
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL. If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+//****************************************************************************************************
+void uLCD_4DGL :: set_font_size(char width, char height) // set font size
+{
+ if (current_orientation == IS_PORTRAIT) {
+ current_fx = width;
+ current_fy = height;
+ } else {
+ current_fy = height;
+ current_fx = width;
+ }
+ max_col = current_w / (current_fx*current_wf);
+ max_row = current_h / (current_fy*current_hf);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: set_font(char mode) // set font - system or SD media
+{
+ char command[3]= "";
+
+ command[0] = SETFONT;
+ command[1] = 0;
+ command[2] = mode;
+
+ current_font = mode;
+
+ if (current_orientation == IS_PORTRAIT) {
+ current_w = SIZE_X;
+ current_h = SIZE_Y;
+ } else {
+ current_w = SIZE_Y;
+ current_h = SIZE_X;
+ }
+
+ switch (mode) {
+ case FONT_5X7 :
+
+ current_fx = 6;
+ current_fy = 8;
+ break;
+ case FONT_7X8 :
+ current_fx = 7;
+ current_fy = 8;
+ break;
+ case FONT_8X8 :
+ current_fx = 8;
+ current_fy = 8;
+ break;
+ case FONT_8X12 :
+ current_fx = 8;
+ current_fy = 12;
+ break;
+ case FONT_12X16 :
+ current_fx = 12;
+ current_fy = 16;
+ break;
+ default:
+ current_fx = 8;
+ current_fy = 8;
+ }
+
+ max_col = current_w / (current_fx*current_wf);
+ max_row = current_h / (current_fy*current_hf);
+
+ writeCOMMAND(command, 3);
+}
+
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_mode(char mode) // set text mode
+{
+ char command[3]= "";
+
+ command[0] = TEXTMODE;
+ command[1] = 0;
+ command[2] = mode;
+
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_bold(char mode) // set text mode
+{
+ char command[3]= "";
+
+ command[0] = TEXTBOLD;
+ command[1] = 0;
+ command[2] = mode;
+
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_italic(char mode) // set text mode
+{
+ char command[3]= "";
+
+ command[0] = TEXTITALIC;
+ command[1] = 0;
+ command[2] = mode;
+
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_inverse(char mode) // set text mode
+{
+ char command[3]= "";
+
+ command[0] = TEXTINVERSE;
+ command[1] = 0;
+ command[2] = mode;
+
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_underline(char mode) // set text mode
+{
+ char command[3]= "";
+
+ command[0] = TEXTUNDERLINE;
+ command[1] = 0;
+ command[2] = mode;
+
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_width(char width) // set text width
+{
+ char command[3]= "";
+
+ command[0] = TEXTWIDTH;
+ command[1] = 0;
+ command[2] = width;
+ current_wf = width;
+ max_col = current_w / (current_fx*current_wf);
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_height(char height) // set text height
+{
+ char command[3]= "";
+
+ command[0] = TEXTHEIGHT;
+ command[1] = 0;
+ command[2] = height;
+ current_hf = height;
+ max_row = current_h / (current_fy*current_hf);
+ writeCOMMAND(command, 3);
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_char(char c, char col, char row, int color) // draw a text char
+{
+ char command[6]= "";
+ command[0] = 0xE4; //move cursor
+ command[1] = 0;
+ command[2] = row;
+ command[3] = 0;
+ command[4] = col;
+ writeCOMMAND(command, 5);
+
+ command[0] = 0x7F; //set color
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[1] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[2] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+ writeCOMMAND(command, 3);
+
+ command[0] = TEXTCHAR; //print char
+ command[1] = 0;
+ command[2] = c;
+ writeCOMMAND(command, 3);
+
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: text_string(char *s, char col, char row, char font, int color) // draw a text string
+{
+
+ char command[1000]= "";
+ int size = strlen(s);
+ int i = 0;
+
+ set_font(font);
+
+ command[0] = 0xE4; //move cursor
+ command[1] = 0;
+ command[2] = row;
+ command[3] = 0;
+ command[4] = col;
+ writeCOMMAND(command, 5);
+
+ command[0] = 0x7F; //set color
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[1] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[2] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+ writeCOMMAND(command, 3);
+
+ command[0] = TEXTSTRING;
+ for (i=0; i<size; i++) command[1+i] = s[i];
+ command[1+size] = 0;
+ writeCOMMANDnull(command, 2 + size);
+}
+
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: locate(char col, char row) // place text curssor at col, row
+{
+ char command[5] = "";
+ current_col = col;
+ current_row = row;
+ command[0] = MOVECURSOR; //move cursor
+ command[1] = 0;
+ command[2] = current_row;
+ command[3] = 0;
+ command[4] = current_col;
+ writeCOMMAND(command, 5);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: color(int color) // set text color
+{
+ char command[5] = "";
+ current_color = color;
+ command[0] = 0x7F; //set color
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[1] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[2] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: putc(char c) // place char at current cursor position
+//used by virtual printf function _putc
+{
+ char command[6] ="";
+ if(c<0x20) {
+ if(c=='\n') {
+ current_col = 0;
+ current_row++;
+ command[0] = MOVECURSOR; //move cursor to start of next line
+ command[1] = 0;
+ command[2] = current_row;
+ command[3] = 0;
+ command[4] = current_col;
+ writeCOMMAND(command, 5);
+ }
+ if(c=='\r') {
+ current_col = 0;
+ command[0] = MOVECURSOR; //move cursor to start of line
+ command[1] = 0;
+ command[2] = current_row;
+ command[3] = 0;
+ command[4] = current_col;
+ writeCOMMAND(command, 5);
+ }
+ if(c=='\f') {
+ uLCD_4DGL::cls(); //clear screen on form feed
+ }
+ } else {
+ command[0] = PUTCHAR;
+ command[1] = 0x00;
+ command[2] = c;
+ writeCOMMAND(command,3);
+ current_col++;
+ }
+ if (current_col == max_col) {
+ current_col = 0;
+ current_row++;
+ command[0] = MOVECURSOR; //move cursor to next line
+ command[1] = 0;
+ command[2] = current_row;
+ command[3] = 0;
+ command[4] = current_col;
+ writeCOMMAND(command, 5);
+ }
+ if (current_row == max_row) {
+ current_row = 0;
+ command[0] = MOVECURSOR; //move cursor back to start
+ command[1] = 0;
+ command[2] = current_row;
+ command[3] = 0;
+ command[4] = current_col;
+ writeCOMMAND(command, 5);
+ }
+}
+
+
+//****************************************************************************************************
+void uLCD_4DGL :: puts(char *s) // place string at current cursor position
+{
+
+ text_string(s, current_col, current_row, current_font, current_color);
+
+ current_col += strlen(s);
+
+ if (current_col >= max_col) {
+ current_row += current_col / max_col;
+ current_col %= max_col;
+ }
+ if (current_row >= max_row) {
+ current_row %= max_row;
+ }
+}
+
diff -r 000000000000 -r a1c374b9a4fe 4DGL-uLCD-SE/uLCD_4DGL_main.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/4DGL-uLCD-SE/uLCD_4DGL_main.cpp Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,470 @@
+//
+// uLCD_4DGL is a class to drive 4D Systems uLCD 144 G2
+//
+// Copyright (C) <2010> Stephane ROCHON <stephane.rochon at free.fr>
+// Modifed for Goldelox processor <2013> Jim Hamblen
+//
+// uLCD_4DGL is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// uLCD_4DGL is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with uLCD_4DGL. If not, see <http://www.gnu.org/licenses/>.
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+
+#define ARRAY_SIZE(X) sizeof(X)/sizeof(X[0])
+
+//Serial pc(USBTX,USBRX);
+
+
+//******************************************************************************************************
+uLCD_4DGL :: uLCD_4DGL(PinName tx, PinName rx, PinName rst) : _cmd(tx, rx),
+ _rst(rst)
+#if DEBUGMODE
+ ,pc(USBTX, USBRX)
+#endif // DEBUGMODE
+{
+ // Constructor
+ _cmd.baud(9600);
+#if DEBUGMODE
+ pc.baud(115200);
+
+ pc.printf("\n\n\n");
+ pc.printf("*********************\n");
+ pc.printf("uLCD_4DGL CONSTRUCTOR\n");
+ pc.printf("*********************\n");
+#endif
+
+ _rst = 1; // put RESET pin to high to start TFT screen
+ reset();
+ cls(); // clear screen
+ current_col = 0; // initial cursor col
+ current_row = 0; // initial cursor row
+ current_color = WHITE; // initial text color
+ current_orientation = IS_PORTRAIT; // initial screen orientation
+ current_hf = 1;
+ current_wf = 1;
+ set_font(FONT_7X8); // initial font
+// text_mode(OPAQUE); // initial texr mode
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: writeBYTE(char c) // send a BYTE command to screen
+{
+
+ _cmd.putc(c);
+ wait_us(500); //mbed is too fast for LCD at high baud rates in some long commands
+
+#if DEBUGMODE
+ pc.printf(" Char sent : 0x%02X\n",c);
+#endif
+
+}
+
+//******************************************************************************************************
+void uLCD_4DGL :: writeBYTEfast(char c) // send a BYTE command to screen
+{
+
+ _cmd.putc(c);
+ //wait_ms(0.0); //mbed is too fast for LCD at high baud rates - but not in short commands
+
+#if DEBUGMODE
+ pc.printf(" Char sent : 0x%02X\n",c);
+#endif
+
+}
+//******************************************************************************************************
+void uLCD_4DGL :: freeBUFFER(void) // Clear serial buffer before writing command
+{
+
+ while (_cmd.readable()) _cmd.getc(); // clear buffer garbage
+}
+
+//******************************************************************************************************
+int uLCD_4DGL :: writeCOMMAND(char *command, int number) // send several BYTES making a command and return an answer
+{
+
+#if DEBUGMODE
+ pc.printf("\n");
+ pc.printf("New COMMAND : 0x%02X\n", command[0]);
+#endif
+ int i, resp = 0;
+ freeBUFFER();
+ writeBYTE(0xFF);
+ for (i = 0; i < number; i++) {
+ if (i<16)
+ writeBYTEfast(command[i]); // send command to serial port
+ else
+ writeBYTE(command[i]); // send command to serial port but slower
+ }
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+ if (_cmd.readable()) resp = _cmd.getc(); // read response if any
+ switch (resp) {
+ case ACK : // if OK return 1
+ resp = 1;
+ break;
+ case NAK : // if NOK return -1
+ resp = -1;
+ break;
+ default :
+ resp = 0; // else return 0
+ break;
+ }
+#if DEBUGMODE
+ pc.printf(" Answer received : %d\n",resp);
+#endif
+
+ return resp;
+}
+
+//**************************************************************************
+void uLCD_4DGL :: reset() // Reset Screen
+{
+ wait_ms(5);
+ _rst = 0; // put RESET pin to low
+ wait_ms(5); // wait a few milliseconds for command reception
+ _rst = 1; // put RESET back to high
+ wait(3); // wait 3s for screen to restart
+
+ freeBUFFER(); // clean buffer from possible garbage
+}
+//******************************************************************************************************
+int uLCD_4DGL :: writeCOMMANDnull(char *command, int number) // send several BYTES making a command and return an answer
+{
+
+#if DEBUGMODE
+ pc.printf("\n");
+ pc.printf("New COMMAND : 0x%02X\n", command[0]);
+#endif
+ int i, resp = 0;
+ freeBUFFER();
+ writeBYTE(0x00); //command has a null prefix byte
+ for (i = 0; i < number; i++) {
+ if (i<16) //don't overflow LCD UART buffer
+ writeBYTEfast(command[i]); // send command to serial port
+ else
+ writeBYTE(command[i]); // send command to serial port with delay
+ }
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+ if (_cmd.readable()) resp = _cmd.getc(); // read response if any
+ switch (resp) {
+ case ACK : // if OK return 1
+ resp = 1;
+ break;
+ case NAK : // if NOK return -1
+ resp = -1;
+ break;
+ default :
+ resp = 0; // else return 0
+ break;
+ }
+#if DEBUGMODE
+ pc.printf(" Answer received : %d\n",resp);
+#endif
+
+ return resp;
+}
+
+//**************************************************************************
+void uLCD_4DGL :: cls() // clear screen
+{
+ char command[1] = "";
+
+ command[0] = CLS;
+ writeCOMMAND(command, 1);
+ current_row=0;
+ current_col=0;
+ current_hf = 1;
+ current_wf = 1;
+ set_font(FONT_7X8); // initial font
+}
+
+//**************************************************************************
+int uLCD_4DGL :: version() // get API version
+{
+
+ char command[2] = "";
+ command[0] = '\x00';
+ command[1] = VERSION;
+ return readVERSION(command, 2);
+}
+
+//**************************************************************************
+void uLCD_4DGL :: baudrate(int speed) // set screen baud rate
+{
+ char command[3]= "";
+ writeBYTE(0x00);
+ command[0] = BAUDRATE;
+ command[1] = 0;
+ int newbaud = BAUD_9600;
+ switch (speed) {
+ case 110 :
+ newbaud = BAUD_110;
+ break;
+ case 300 :
+ newbaud = BAUD_300;
+ break;
+ case 600 :
+ newbaud = BAUD_600;
+ break;
+ case 1200 :
+ newbaud = BAUD_1200;
+ break;
+ case 2400 :
+ newbaud = BAUD_2400;
+ break;
+ case 4800 :
+ newbaud = BAUD_4800;
+ break;
+ case 9600 :
+ newbaud = BAUD_9600;
+ break;
+ case 14400 :
+ newbaud = BAUD_14400;
+ break;
+ case 19200 :
+ newbaud = BAUD_19200;
+ break;
+ case 31250 :
+ newbaud = BAUD_31250;
+ break;
+ case 38400 :
+ newbaud = BAUD_38400;
+ break;
+ case 56000 :
+ newbaud = BAUD_56000;
+ break;
+ case 57600 :
+ newbaud = BAUD_57600;
+ break;
+ case 115200 :
+ newbaud = BAUD_115200;
+ break;
+ case 128000 :
+ newbaud = BAUD_128000;
+ break;
+ case 256000 :
+ newbaud = BAUD_256000;
+ break;
+ case 300000 :
+ newbaud = BAUD_300000;
+ speed = 272727;
+ break;
+ case 375000 :
+ newbaud = BAUD_375000;
+ speed = 333333;
+ break;
+ case 500000 :
+ newbaud = BAUD_500000;
+ speed = 428571;
+ break;
+ case 600000 :
+ newbaud = BAUD_600000;
+ break;
+ case 750000 : //rates over 600000 are not documented, but seem to work
+ newbaud = BAUD_750000;
+ break;
+ case 1000000 :
+ newbaud = BAUD_1000000;
+ break;
+ case 1500000 :
+ newbaud = BAUD_1500000;
+ break;
+ case 3000000 :
+ newbaud = BAUD_3000000;
+ break;
+ default :
+ newbaud = BAUD_9600;
+ speed = 9600;
+ break;
+ }
+
+ int i, resp = 0;
+
+ freeBUFFER();
+ command[1] = char(newbaud >>8);
+ command[2] = char(newbaud % 256);
+ wait_ms(1);
+ for (i = 0; i <3; i++) writeBYTEfast(command[i]); // send command to serial port
+ for (i = 0; i<10; i++) wait_ms(1);
+ //dont change baud until all characters get sent out
+ _cmd.baud(speed); // set mbed to same speed
+ i=0;
+ while ((!_cmd.readable()) && (i<25000)) {
+ wait_ms(TEMPO); // wait for screen answer - comes 100ms after change
+ i++; //timeout if ack character missed by baud change
+ }
+ if (_cmd.readable()) resp = _cmd.getc(); // read response if any
+ switch (resp) {
+ case ACK : // if OK return 1
+ resp = 1;
+ break;
+ case NAK : // if NOK return -1
+ resp = -1;
+ break;
+ default :
+ resp = 0; // else return 0
+ break;
+ }
+}
+
+//******************************************************************************************************
+int uLCD_4DGL :: readVERSION(char *command, int number) // read screen info and populate data
+{
+
+ int i, temp = 0, resp = 0;
+ char response[5] = "";
+
+ freeBUFFER();
+
+ for (i = 0; i < number; i++) writeBYTE(command[i]); // send all chars to serial port
+
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+
+ while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
+ temp = _cmd.getc();
+ response[resp++] = (char)temp;
+ }
+ switch (resp) {
+ case 2 : // if OK populate data and return 1
+ revision = response[0]<<8 + response[1];
+ resp = 1;
+ break;
+ default :
+ resp = 0; // else return 0
+ break;
+ }
+ return resp;
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: background_color(int color) // set screen background color
+{
+ char command[3]= ""; // input color is in 24bits like 0xRRGGBB
+
+ command[0] = BCKGDCOLOR;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[1] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[2] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: textbackground_color(int color) // set screen background color
+{
+ char command[3]= ""; // input color is in 24bits like 0xRRGGBB
+
+ command[0] = TXTBCKGDCOLOR;
+
+ int red5 = (color >> (16 + 3)) & 0x1F; // get red on 5 bits
+ int green6 = (color >> (8 + 2)) & 0x3F; // get green on 6 bits
+ int blue5 = (color >> (0 + 3)) & 0x1F; // get blue on 5 bits
+
+ command[1] = ((red5 << 3) + (green6 >> 3)) & 0xFF; // first part of 16 bits color
+ command[2] = ((green6 << 5) + (blue5 >> 0)) & 0xFF; // second part of 16 bits color
+
+ writeCOMMAND(command, 3);
+}
+
+//****************************************************************************************************
+void uLCD_4DGL :: display_control(char mode) // set screen mode to value
+{
+ char command[3]= "";
+
+ command[0] = DISPCONTROL;
+ command[1] = 0;
+ command[2] = mode;
+
+ if (mode == ORIENTATION) {
+ switch (mode) {
+ case LANDSCAPE :
+ current_orientation = IS_LANDSCAPE;
+ break;
+ case LANDSCAPE_R :
+ current_orientation = IS_LANDSCAPE;
+ break;
+ case PORTRAIT :
+ current_orientation = IS_PORTRAIT;
+ break;
+ case PORTRAIT_R :
+ current_orientation = IS_PORTRAIT;
+ break;
+ }
+ }
+ writeCOMMAND(command, 3);
+ set_font(current_font);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: display_power(char mode) // set screen mode to value
+{
+ char command[3]= "";
+
+ command[0] = DISPPOWER;
+ command[1] = 0;
+ command[2] = mode;
+ writeCOMMAND(command, 3);
+}
+//****************************************************************************************************
+void uLCD_4DGL :: set_volume(char value) // set sound volume to value
+{
+ char command[2]= "";
+
+ command[0] = SETVOLUME;
+ command[1] = value;
+
+ writeCOMMAND(command, 2);
+}
+
+
+//******************************************************************************************************
+int uLCD_4DGL :: getSTATUS(char *command, int number) // read screen info and populate data
+{
+
+#if DEBUGMODE
+ pc.printf("\n");
+ pc.printf("New COMMAND : 0x%02X\n", command[0]);
+#endif
+
+ int i, temp = 0, resp = 0;
+ char response[5] = "";
+
+ freeBUFFER();
+
+ for (i = 0; i < number; i++) writeBYTE(command[i]); // send all chars to serial port
+
+ while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer
+
+ while (_cmd.readable() && resp < ARRAY_SIZE(response)) {
+ temp = _cmd.getc();
+ response[resp++] = (char)temp;
+ }
+ switch (resp) {
+ case 4 :
+ resp = (int)response[1]; // if OK populate data
+ break;
+ default :
+ resp = -1; // else return 0
+ break;
+ }
+
+#if DEBUGMODE
+ pc.printf(" Answer received : %d\n", resp);
+#endif
+
+ return resp;
+}
+
+
diff -r 000000000000 -r a1c374b9a4fe SDFileSystem.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/SDFileSystem.lib Mon Mar 14 00:26:24 2016 +0000 @@ -0,0 +1,1 @@ +http://developer.mbed.org/users/mbed_official/code/SDFileSystem/#7b35d1709458
diff -r 000000000000 -r a1c374b9a4fe SongPlayer.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/SongPlayer.h Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,52 @@
+#include "mbed.h"
+// new class to play a note on Speaker based on PwmOut class
+class SongPlayer
+{
+public:
+ SongPlayer(PinName pin) : _pin(pin) {
+// _pin(pin) means pass pin to the constructor
+ }
+// class method to play a note based on PwmOut class
+ void PlaySong(float frequency[], float duration[], float volume=1.0) {
+ vol = volume;
+ notecount = 0;
+ _pin.period(1.0/frequency[notecount]);
+ _pin = volume/2.0;
+ noteduration.attach(this,&SongPlayer::nextnote, duration[notecount]);
+ // setup timer to interrupt for next note to play
+ frequencyptr = frequency;
+ durationptr = duration;
+ //returns after first note starts to play
+ }
+ void PlaySong1(float *frequency, float *duration, float volume=1.0) {
+ vol = volume;
+ notecount = 0;
+ _pin.period(1.0/(*frequency));
+ _pin = volume/2.0;
+ noteduration.attach(this,&SongPlayer::nextnote, *duration);
+ // setup timer to interrupt for next note to play
+ frequencyptr = frequency;
+ durationptr = duration;
+ //returns after first note starts to play
+ }
+ void nextnote();
+private:
+ Timeout noteduration;
+ PwmOut _pin;
+ int notecount;
+ float vol;
+ float * frequencyptr;
+ float * durationptr;
+};
+//Interrupt Routine to play next note
+void SongPlayer::nextnote()
+{
+ _pin = 0.0;
+ notecount++; //setup next note in song
+ if (durationptr[notecount]!=0.0) {
+ _pin.period(1.0/frequencyptr[notecount]);
+ noteduration.attach(this,&SongPlayer::nextnote, durationptr[notecount]);
+ _pin = vol/2.0;
+ } else
+ _pin = 0.0; //turn off on last note
+}
diff -r 000000000000 -r a1c374b9a4fe main.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,397 @@
+//ECE 4180 Piano Tiles
+//Spring 2016 Georgia Tech
+//Kushagra Brahmbhatt
+//Christopher Lu
+
+#include "mbed.h"
+#include "uLCD_4DGL.h"
+#include <mpr121.h>
+#include "SongPlayer.h"
+#include "SDFileSystem.h"
+#include "wave_player.h"
+
+//LCD better
+uLCD_4DGL uLCD(p28,p27,p29);
+
+//Speaker
+SongPlayer mySpeaker(p21);
+AnalogOut Speaker(p18);
+
+// Setup the i2c bus on pins 9 and 10
+I2C i2c(p9, p10);
+
+// Setup the Mpr121:
+// Create the interrupt receiver object on pin 26
+InterruptIn interrupt(p26);
+// constructor(i2c object, i2c address of the mpr121)
+Mpr121 mpr121(&i2c, Mpr121::ADD_VSS);
+
+// the pinout on the mbed Cool Components workshop board
+SDFileSystem sd(p5, p6, p7, p8, "sd");
+
+//timer
+Timer t;
+
+//bool key0Press, key4Press, key8Press;
+int vals;
+bool interruptBool;
+int score, timer;
+
+// Key hit/release interrupt routine
+void fallInterrupt() { //void
+
+ int value=mpr121.read(0x00);
+
+ //wait(2);
+ value +=mpr121.read(0x01)<<8;
+ interruptBool = true;
+ vals = value;
+}
+
+
+int press() {
+ int value=mpr121.read(0x00);
+ value +=mpr121.read(0x01)<<8;
+ //1(key 0) 2(key 1) 4 8 16 32 64 128 256 512 1024 2048(key 11)
+ return value;
+}
+
+bool check(int value) {
+ if (value == 1) { //key0
+ if(uLCD.read_pixel(15,90)==BLACK) {
+ return true;
+ }
+ }
+ if (value == 16) { //key4
+ if(uLCD.read_pixel(50,90)==BLACK) {
+ return true;
+ }
+ }
+ if (value == 256) { //key8
+ if(uLCD.read_pixel(90,90)==BLACK) {
+ return true;
+ }
+ }
+ return false;
+}
+
+//initialize the graphics for the game
+void startGame(){
+ uLCD.background_color(WHITE);
+ uLCD.cls();
+ //draw walls
+ uLCD.filled_rectangle(0,103,10,0, BLUE);
+ uLCD.filled_rectangle(117,103,127,0, BLUE);
+ uLCD.filled_rectangle(10,78,117,103, 0xFDF983);
+ uLCD.locate(0,13);
+ uLCD.textbackground_color(WHITE);
+ uLCD.color(RED);
+ uLCD.printf("Score: ");
+ uLCD.locate(9,13);
+ uLCD.printf("Time:");
+ uLCD.locate(4,14);
+ uLCD.text_width(1); //4X size text
+ uLCD.text_height(2);
+ uLCD.printf("Piano Tiles");
+
+
+ //draw the lines
+ uLCD.line(10, 26, 117, 26, BLACK);
+ uLCD.line(10, 52, 117, 52, BLACK);
+ uLCD.line(10, 78, 117, 78, BLACK);
+ uLCD.line(10, 103, 117, 103, BLACK);
+
+ uLCD.line(46, 0, 46, 103, BLACK);
+ uLCD.line(82, 0, 82, 103, BLACK);
+
+}
+
+//moves block down
+int updateBlockY1(int y) {
+ y = y + 26;
+ if (y > 81) {
+ y = 3;
+ }
+ return y;
+}
+
+int updateBlockY2(int y) {
+ y = y + 26;
+ if (y > 101) {
+ y = 23;
+ }
+ return y;
+}
+
+//Frequency of notes for Fur Elise
+float note[85]= {329.63,311.13,329.63,311.13,329.63,246.94,293.66,261.63,220.00,
+ 146.83,174.61,220.0,246.94,174.61,233.08,246.94,261.63, 329.63,
+ 311.13, 329.63, 246.94, 293.66, 261.63, 220.00, 146.83, 174.61,
+ 220.00, 246.94, 174.61, 261.63, 246.94, 220.00, 246.94, 261.63,
+ 293.66, 329.63, 196.00, 329.23, 329.23, 293.63, 164.81, 329.63,
+ 293.63, 261.63, 146.83, 293.63, 261.63, 246.94, 329.63, 311.13,
+ 329.63, 311.13, 329.63, 246.94, 293.66, 261.63, 220.00, 146.83,
+ 174.61, 220.00, 246.94, 174.61, 233.08, 246.94, 261.63, 329.63,
+ 311.13, 329.63, 311.13, 329.63, 311.13, 329.63, 246.94, 293.66,
+ 261.63, 220.00, 146.83, 174.61, 220.00, 246.94, 174.61, 261.63,
+ 246.94, 220.0, 0.0};
+//How long each note plays for
+float duration[85]= {0.3,0.3,0.3,0.3,0.30,0.30,0.30,0.30,0.30,
+ 0.30,0.30,0.30,0.30,0.30,0.30,0.30,0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.30, 0.30, 0.30,
+ 0.30, 0.30, 0.30, 0.30, 0.0};
+
+
+int main() {
+
+ //wait 4 seconds then moves on to graphics of the game
+ uLCD.locate(3,4);
+ uLCD.text_width(1);
+ uLCD.text_height(2);
+ uLCD.printf("Piano Tiles!!!\n");
+ uLCD.text_height(1);
+ uLCD.locate(5,8);
+ uLCD.printf("Playing:");
+ uLCD.locate(5,9);
+ uLCD.printf("Beethoven");
+ uLCD.locate(5,10);
+ uLCD.printf("Fur Elise");
+ uLCD.locate(0,12);
+ uLCD.printf("Get a score above ");
+ uLCD.locate(4,13);
+ uLCD.printf("100 to win!");
+ wait(4);
+
+ interrupt.fall(&fallInterrupt);
+ interrupt.mode(PullUp);
+ startGame();
+
+ //initialization to track tiles
+ int a[16];
+ int y1 = 81; //starting y coordinate to fill in rectangle from the bottom
+ int y2 = 101;
+ int position = 1; //tracks placement of the previous tile for tone so tiles are placed by tones
+
+
+ //initializing the first four set of piano tiles
+ for (int i = 0; i < 4; i++) {
+ if (note[i] < note[i-1] && i != 0){ //if (note<previousnote) then next tile is to the left
+ uLCD.filled_rectangle(49,y1,79,y2, BLACK);
+ a[4*i + 0] = 49;
+ a[4*i + 1] = y1;
+ a[4*i + 2] = 79;
+ a[4*i + 3] = y2;
+ position = 2;
+ }
+ else if (i == 0 || note[i] > note[i-1]) { //initial start is on right side of screen
+ uLCD.filled_rectangle(85,y1,115,y2, BLACK);
+ a[4*i + 0] = 85;
+ a[4*i + 1] = y1;
+ a[4*i + 2] = 115;
+ a[4*i + 3] = y2;
+ position = 3;
+ }
+ //move from bottom of the screen to the top
+ y1 = y1 - 26;
+ y2 = y2 - 26;
+ }
+ //array used for holding all the tiles
+ int block1_x1 = a[0];
+ int block1_y1 = a[1];
+ int block1_x2 = a[2];
+ int block1_y2 = a[3];
+ int block2_x1 = a[4];
+ int block2_y1 = a[5];
+ int block2_x2 = a[6];
+ int block2_y2 = a[7];
+ int block3_x1 = a[8];
+ int block3_y1 = a[9];
+ int block3_x2 = a[10];
+ int block3_y2 = a[11];
+ int block4_x1 = a[12];
+ int block4_y1 = a[13];
+ int block4_x2 = a[14];
+ int block4_y2 = a[15];
+
+ t.start();
+
+ //starting the game
+ while(1) {
+ if (interruptBool) { //key is pressed
+ uLCD.locate(0,0);
+ bool checkTrue = check(vals);
+ uLCD.locate(0,0);
+
+ if (checkTrue) { //if right correct key is pressed, tiles are replaced and move down
+ uLCD.filled_rectangle(block1_x1, block1_y1, block1_x2, block1_y2, WHITE);
+ uLCD.filled_rectangle(block2_x1, block2_y1, block2_x2, block2_y2, WHITE);
+ uLCD.filled_rectangle(block3_x1, block3_y1, block3_x2, block3_y2, WHITE);
+ uLCD.filled_rectangle(block4_x1, block4_y1, block4_x2, block4_y2, WHITE);
+ block1_y1 = updateBlockY1(block1_y1);
+ block1_y2 = updateBlockY2(block1_y2);
+ block2_y1 = updateBlockY1(block2_y1);
+ block2_y2 = updateBlockY2(block2_y2);
+ block3_y1 = updateBlockY1(block3_y1);
+ block3_y2 = updateBlockY2(block3_y2);
+ block4_y1 = updateBlockY1(block4_y1);
+ block4_y2 = updateBlockY2(block4_y2);
+
+ //the following if statements determine position of the following tiles based on the
+ //frequencies of the note that is being played
+ if(block1_y1 == 3)
+ {
+ if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+ block1_x1 = 13;
+ block1_x2 = 43;
+ position = 1;
+ } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+ block1_x1 = 49;
+ block1_x2 = 79;
+ position = 2;
+ } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3)) {
+ block1_x1 = 85;
+ block1_x2 = 115;
+ position = 3;
+ }
+ }
+ if(block2_y1 == 3)
+ {
+ if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+ block2_x1 = 13;
+ block2_x2 = 43;
+ position = 1;
+ } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+ block2_x1 = 49;
+ block2_x2 = 79;
+ position = 2;
+ } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3)) {
+ block2_x1 = 85;
+ block2_x2 = 115;
+ position = 3;
+ }
+ }
+ if(block3_y1 == 3)
+ {
+ if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+ block3_x1 = 13;
+ block3_x2 = 43;
+ position = 1;
+ } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+ block3_x1 = 49;
+ block3_x2 = 79;
+ position = 2;
+ } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3)) {
+ block3_x1 = 85;
+ block3_x2 = 115;
+ position = 3;
+ }
+ }
+ if(block4_y1 == 3)
+ {
+ if (note[score%85+4] < note[score%85+3] && (position == 1 || position == 2)) {
+ block4_x1 = 13;
+ block4_x2 = 43;
+ position = 1;
+ } else if ((note[score%85+4] < note[score%85+3] && position == 3) || (note[score%85+4] > note[score%85+3] && position == 1 )) {
+ block4_x1 = 49;
+ block4_x2 = 79;
+ position = 2;
+ } else if (note[score%85+4] > note[score%85+3] && (position == 2 || position == 3)) {
+ block4_x1 = 85;
+ block4_x2 = 115;
+ position = 3;
+ }
+ }
+
+ //fill in the tiles
+ uLCD.filled_rectangle(block1_x1, block1_y1, block1_x2, block1_y2, BLACK);
+ uLCD.filled_rectangle(block2_x1, block2_y1, block2_x2, block2_y2, BLACK);
+ uLCD.filled_rectangle(block3_x1, block3_y1, block3_x2, block3_y2, BLACK);
+ uLCD.filled_rectangle(block4_x1, block4_y1, block4_x2, block4_y2, BLACK);
+ interruptBool = false;
+
+ //plays the note as the keypad is being pressed
+ float note1[] = {note[score%85]};
+ float duration1[] = {duration[score%85]};
+ mySpeaker.PlaySong(note1,duration1);
+ score++;
+
+ //updates the time and score
+ uLCD.text_width(1);
+ uLCD.text_height(1);
+ uLCD.locate(0,13);
+ uLCD.textbackground_color(WHITE);
+ uLCD.color(RED);
+ uLCD.printf("Score:%d", score);
+ uLCD.locate(9,13);
+ uLCD.printf("Time:%0.1f", t.read());
+
+
+ }
+ else { //while loop breaks when the wrong key is pressed
+ break;
+ //Game Over Screen outside while loop
+ }
+ } //end of interruptBool
+ }//end of while loop
+
+
+ //win or lose music
+ wave_player waver(&Speaker);
+ //vector<string> filenames; //filenames are stored in a vector string
+ bool PLAY = true;
+ bool *PlayStopPtr = &PLAY;
+ FILE *wave_file;
+
+ //victory and game over screen
+ if (score >= 100)
+ {
+ uLCD.cls();
+ uLCD.locate(0,4);
+ uLCD.text_width(2); //4X size text
+ uLCD.text_height(2);
+ uLCD.printf("Victory!!");
+ uLCD.text_width(1); //4X size text
+ uLCD.text_height(1);
+ uLCD.locate(4,7);
+ uLCD.printf("SCORE:%d", score);
+ t.stop();
+ uLCD.locate(4,8);
+ uLCD.printf("Time:%0.2f", t.read());
+ uLCD.locate(0,10);
+ uLCD.printf("Thanks for playing");
+
+ FILE *wave_file;
+ wave_file=fopen("/sd/wavfiles/victory.wav","r");
+ waver.play(wave_file,PlayStopPtr);
+ }
+ else
+ {
+ uLCD.cls();
+ uLCD.locate(0,4);
+ uLCD.text_width(2); //4X size text
+ uLCD.text_height(2);
+ uLCD.printf("Game Over");
+ uLCD.text_width(1); //4X size text
+ uLCD.text_height(1);
+ uLCD.locate(4,7);
+ uLCD.printf("SCORE:%d", score);
+ t.stop();
+ uLCD.locate(4,8);
+ uLCD.printf("Time:%0.2f", t.read());
+ uLCD.locate(0,10);
+ uLCD.printf("Thanks for playing");
+
+ FILE *wave_file;
+ wave_file=fopen("/sd/wavfiles/defeat.wav","r");
+ waver.play(wave_file,PlayStopPtr);
+ }
+}
diff -r 000000000000 -r a1c374b9a4fe mbed.bld --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Mon Mar 14 00:26:24 2016 +0000 @@ -0,0 +1,1 @@ +http://world3.dev.mbed.org/users/mbed_official/code/mbed/builds/824293ae5e43 \ No newline at end of file
diff -r 000000000000 -r a1c374b9a4fe mpr121/mpr121.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpr121/mpr121.cpp Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,221 @@
+/*
+Copyright (c) 2011 Anthony Buckton (abuckton [at] blackink [dot} net {dot} au)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+*/
+
+#include <mbed.h>
+#include <sstream>
+#include <string>
+#include <list>
+
+#include <mpr121.h>
+
+Mpr121::Mpr121(I2C *i2c, Address i2cAddress)
+{
+ this->i2c = i2c;
+
+ address = i2cAddress;
+
+ // Configure the MPR121 settings to default
+ this->configureSettings();
+}
+
+
+void Mpr121::configureSettings()
+{
+ // Put the MPR into setup mode
+ this->write(ELE_CFG,0x00);
+
+ // Electrode filters for when data is > baseline
+ unsigned char gtBaseline[] = {
+ 0x01, //MHD_R
+ 0x01, //NHD_R
+ 0x00, //NCL_R
+ 0x00 //FDL_R
+ };
+
+ writeMany(MHD_R,gtBaseline,4);
+
+ // Electrode filters for when data is < baseline
+ unsigned char ltBaseline[] = {
+ 0x01, //MHD_F
+ 0x01, //NHD_F
+ 0xFF, //NCL_F
+ 0x02 //FDL_F
+ };
+
+ writeMany(MHD_F,ltBaseline,4);
+
+ // Electrode touch and release thresholds
+ unsigned char electrodeThresholds[] = {
+ E_THR_T, // Touch Threshhold
+ E_THR_R // Release Threshold
+ };
+
+ for(int i=0; i<12; i++){
+ int result = writeMany((ELE0_T+(i*2)),electrodeThresholds,2);
+ }
+
+ // Proximity Settings
+ unsigned char proximitySettings[] = {
+ 0xff, //MHD_Prox_R
+ 0xff, //NHD_Prox_R
+ 0x00, //NCL_Prox_R
+ 0x00, //FDL_Prox_R
+ 0x01, //MHD_Prox_F
+ 0x01, //NHD_Prox_F
+ 0xFF, //NCL_Prox_F
+ 0xff, //FDL_Prox_F
+ 0x00, //NHD_Prox_T
+ 0x00, //NCL_Prox_T
+ 0x00 //NFD_Prox_T
+ };
+ writeMany(MHDPROXR,proximitySettings,11);
+
+ unsigned char proxThresh[] = {
+ PROX_THR_T, // Touch Threshold
+ PROX_THR_R // Release Threshold
+ };
+ writeMany(EPROXTTH,proxThresh,2);
+
+ this->write(FIL_CFG,0x04);
+
+ // Set the electrode config to transition to active mode
+ this->write(ELE_CFG,0x0c);
+}
+
+void Mpr121::setElectrodeThreshold(int electrode, unsigned char touch, unsigned char release){
+
+ if(electrode > 11) return;
+
+ // Get the current mode
+ unsigned char mode = this->read(ELE_CFG);
+
+ // Put the MPR into setup mode
+ this->write(ELE_CFG,0x00);
+
+ // Write the new threshold
+ this->write((ELE0_T+(electrode*2)), touch);
+ this->write((ELE0_T+(electrode*2)+1), release);
+
+ //Restore the operating mode
+ this->write(ELE_CFG, mode);
+}
+
+
+unsigned char Mpr121::read(int key){
+
+ unsigned char data[2];
+
+ //Start the command
+ i2c->start();
+
+ // Address the target (Write mode)
+ int ack1= i2c->write(address);
+
+ // Set the register key to read
+ int ack2 = i2c->write(key);
+
+ // Re-start for read of data
+ i2c->start();
+
+ // Re-send the target address in read mode
+ int ack3 = i2c->write(address+1);
+
+ // Read in the result
+ data[0] = i2c->read(0);
+
+ // Reset the bus
+ i2c->stop();
+
+ return data[0];
+}
+
+
+int Mpr121::write(int key, unsigned char value){
+
+ //Start the command
+ i2c->start();
+
+ // Address the target (Write mode)
+ int ack1= i2c->write(address);
+
+ // Set the register key to write
+ int ack2 = i2c->write(key);
+
+ // Read in the result
+ int ack3 = i2c->write(value);
+
+ // Reset the bus
+ i2c->stop();
+
+ return (ack1+ack2+ack3)-3;
+}
+
+
+int Mpr121::writeMany(int start, unsigned char* dataSet, int length){
+ //Start the command
+ i2c->start();
+
+ // Address the target (Write mode)
+ int ack= i2c->write(address);
+ if(ack!=1){
+ return -1;
+ }
+
+ // Set the register key to write
+ ack = i2c->write(start);
+ if(ack!=1){
+ return -1;
+ }
+
+ // Write the date set
+ int count = 0;
+ while(ack==1 && (count < length)){
+ ack = i2c->write(dataSet[count]);
+ count++;
+ }
+ // Stop the cmd
+ i2c->stop();
+
+ return count;
+}
+
+
+bool Mpr121::getProximityMode(){
+ if(this->read(ELE_CFG) > 0x0c)
+ return true;
+ else
+ return false;
+}
+
+void Mpr121::setProximityMode(bool mode){
+ this->write(ELE_CFG,0x00);
+ if(mode){
+ this->write(ELE_CFG,0x30); //Sense proximity from ALL pads
+ } else {
+ this->write(ELE_CFG,0x0c); //Sense touch, all 12 pads active.
+ }
+}
+
+
+int Mpr121::readTouchData(){
+ return this->read(0x00);
+}
diff -r 000000000000 -r a1c374b9a4fe mpr121/mpr121.h
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mpr121/mpr121.h Mon Mar 14 00:26:24 2016 +0000
@@ -0,0 +1,158 @@
+/*
+Copyright (c) 2011 Anthony Buckton (abuckton [at] blackink [dot} net {dot} au)
+
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+ Parts written by Jim Lindblom of Sparkfun
+ Ported to mbed by A.Buckton, Feb 2011
+*/
+
+#ifndef MPR121_H
+#define MPR121_H
+
+//using namespace std;
+
+class Mpr121
+{
+
+public:
+ // i2c Addresses, bit-shifted
+ enum Address { ADD_VSS = 0xb4,// ADD->VSS = 0x5a <-wiring on Sparkfun board
+ ADD_VDD = 0xb6,// ADD->VDD = 0x5b
+ ADD_SCL = 0xb8,// ADD->SDA = 0x5c
+ ADD_SDA = 0xba // ADD->SCL = 0x5d
+ };
+
+ // Real initialiser, takes the i2c address of the device.
+ Mpr121(I2C *i2c, Address i2cAddress);
+
+ bool getProximityMode();
+
+ void setProximityMode(bool mode);
+
+ int readTouchData();
+
+ unsigned char read(int key);
+
+ int write(int address, unsigned char value);
+ int writeMany(int start, unsigned char* dataSet, int length);
+
+ void setElectrodeThreshold(int electrodeId, unsigned char touchThreshold, unsigned char releaseThreshold);
+
+protected:
+ // Configures the MPR with standard settings. This is permitted to be overwritten by sub-classes.
+ void configureSettings();
+
+private:
+ // The I2C bus instance.
+ I2C *i2c;
+
+ // i2c address of this mpr121
+ Address address;
+};
+
+
+// MPR121 Register Defines
+#define MHD_R 0x2B
+#define NHD_R 0x2C
+#define NCL_R 0x2D
+#define FDL_R 0x2E
+#define MHD_F 0x2F
+#define NHD_F 0x30
+#define NCL_F 0x31
+#define FDL_F 0x32
+#define NHDT 0x33
+#define NCLT 0x34
+#define FDLT 0x35
+// Proximity sensing controls
+#define MHDPROXR 0x36
+#define NHDPROXR 0x37
+#define NCLPROXR 0x38
+#define FDLPROXR 0x39
+#define MHDPROXF 0x3A
+#define NHDPROXF 0x3B
+#define NCLPROXF 0x3C
+#define FDLPROXF 0x3D
+#define NHDPROXT 0x3E
+#define NCLPROXT 0x3F
+#define FDLPROXT 0x40
+// Electrode Touch/Release thresholds
+#define ELE0_T 0x41
+#define ELE0_R 0x42
+#define ELE1_T 0x43
+#define ELE1_R 0x44
+#define ELE2_T 0x45
+#define ELE2_R 0x46
+#define ELE3_T 0x47
+#define ELE3_R 0x48
+#define ELE4_T 0x49
+#define ELE4_R 0x4A
+#define ELE5_T 0x4B
+#define ELE5_R 0x4C
+#define ELE6_T 0x4D
+#define ELE6_R 0x4E
+#define ELE7_T 0x4F
+#define ELE7_R 0x50
+#define ELE8_T 0x51
+#define ELE8_R 0x52
+#define ELE9_T 0x53
+#define ELE9_R 0x54
+#define ELE10_T 0x55
+#define ELE10_R 0x56
+#define ELE11_T 0x57
+#define ELE11_R 0x58
+// Proximity Touch/Release thresholds
+#define EPROXTTH 0x59
+#define EPROXRTH 0x5A
+// Debounce configuration
+#define DEB_CFG 0x5B
+// AFE- Analogue Front End configuration
+#define AFE_CFG 0x5C
+// Filter configuration
+#define FIL_CFG 0x5D
+// Electrode configuration - transistions to "active mode"
+#define ELE_CFG 0x5E
+
+#define GPIO_CTRL0 0x73
+#define GPIO_CTRL1 0x74
+#define GPIO_DATA 0x75
+#define GPIO_DIR 0x76
+#define GPIO_EN 0x77
+#define GPIO_SET 0x78
+#define GPIO_CLEAR 0x79
+#define GPIO_TOGGLE 0x7A
+// Auto configration registers
+#define AUTO_CFG_0 0x7B
+#define AUTO_CFG_U 0x7D
+#define AUTO_CFG_L 0x7E
+#define AUTO_CFG_T 0x7F
+
+// Threshold defaults
+// Electrode touch threshold
+#define E_THR_T 0x0F
+// Electrode release threshold
+#define E_THR_R 0x0A
+// Prox touch threshold
+#define PROX_THR_T 0x02
+// Prox release threshold
+#define PROX_THR_R 0x02
+
+#endif
+
diff -r 000000000000 -r a1c374b9a4fe wave_player.lib --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/wave_player.lib Mon Mar 14 00:26:24 2016 +0000 @@ -0,0 +1,1 @@ +http://developer.mbed.org/users/zchen311/code/wave_player/#353c78110e44