![](/media/cache/img/default_profile.jpg.50x50_q85.jpg)
Allow user to connect multiple screen.
Revision 0:052d0f82433e, committed 2015-03-11
- Comitter:
- Ratchapong
- Date:
- Wed Mar 11 05:00:37 2015 +0000
- Commit message:
- Working
Changed in this revision
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/4DGL-uLCD-SE/uLCD_4DGL.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,344 @@ +#ifndef ULCD_4DGL_H +#define ULCD_4DGL_H +// +// 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" + +// 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 +*/ +using namespace mbed; + +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
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/4DGL-uLCD-SE/uLCD_4DGL_Graphics.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,310 @@ +// +// 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[2] = ""; + + freeBUFFER(); + + for (i = 0; i < 6; i++) { // send all chars to serial port + writeBYTE(command[i]); + } + + while (!_cmd.readable()) wait_ms(TEMPO); // wait for screen answer + + while (_cmd.readable() && resp < ARRAY_SIZE(response)) { + temp = _cmd.getc(); + response[resp++] = (char)temp; + } + + color = ((response[0] << 8) + response[1]); + + return color; // WARNING : this is 16bits color, not 24bits... need to be fixed +} + + +//**************************************************************************************************** +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); +} + + +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/4DGL-uLCD-SE/uLCD_4DGL_Media.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,177 @@ +// +// 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); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/4DGL-uLCD-SE/uLCD_4DGL_Text.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,343 @@ +// +// 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; + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/4DGL-uLCD-SE/uLCD_4DGL_main.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,469 @@ +// +// 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; +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Game.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,75 @@ +#include "Graphics.h" + + + +class Controller +{ +public: + + AnalogIn& sliderh; + AnalogIn& sliderv; + +public: + Controller(AnalogIn& sliderh, AnalogIn& sliderv) : sliderh(sliderh), sliderv(sliderv) { + + } +}; + +class Game +{ +private: + Renderer& renderer; + Controller& controller; + Scene scene; + +public: + Game(Renderer& renderer, Controller& ctrl) + : renderer(renderer), controller(ctrl) { + + scene.bg = renderer.background; + + buildScene(); + } + +private: + void buildScene() { + + + Block pad; + pad.locked = true; + pad.coord.x = 10; + pad.coord.y = 10; + pad.copy(); + pad.color = -1; + scene.paddle = pad; + } + + +public: + void getInput(int posx, int posy) { + scene.paddle.store_prev(); + + if (posx > 600) { + scene.paddle.coord.x = scene.paddle.coord.x + 5; + } else if (posx < 400) { + scene.paddle.coord.x = scene.paddle.coord.x - 5; + } + + if (posy > 600) { + scene.paddle.coord.y = scene.paddle.coord.y + 5; + } else if (posy < 400) { + scene.paddle.coord.y = scene.paddle.coord.y - 5; + } + + + scene.paddle.updated = true; + } + + + void loop() { + renderer.render(scene); + } + + +}; +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Graphics.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,105 @@ +#include "uLCD_Multiscreen.h" + +struct vec2 { + float x; + float y; +}; + + +class Renderer; + + +class Block +{ + friend Renderer; + +private: + + vec2 next_coord; + vec2 next_size; + +public: + bool updated; + bool locked; + + bool render; + vec2 coord; + vec2 size; + + int color; + + vec2 prev_coord; + vec2 prev_size; + + Block() : updated(true), locked(false), render(true) { + coord.x = 0; + coord.y = 0; + color = RED; + size.x = 2; + size.y = 2; + } + + virtual void next_swap(){ + coord = next_coord; + size = next_size; + + } + + void store_prev() { + prev_coord = coord; + prev_size = size; + } + + void copy() { + prev_coord = coord; + prev_size = size; + + next_coord = coord; + next_size = size; + + } + + +}; + + +class Scene +{ +public: + int bg; + Block paddle; + +}; + + +class Renderer +{ +private: +public: + uLCD_Multiscreen& g; + int background; + vec2 screen; + + Renderer(uLCD_Multiscreen& gfx, vec2 screen) : g(gfx), screen(screen) { + } + void render(Scene s) { + + + //draw paddle + { + Block* b = &(s.paddle); + if(b->updated) { + //draw over where it was + g.unfilledCirlce(b->prev_coord.x, b->prev_coord.y, 10, background); //x1,y1,x2,y2,color + //draw new location + g.unfilledCirlce(b->coord.x, b->coord.y, 10, b->color); //x1,y1,x2,y2,color + + b->updated = false; + } + } + + + + + } +}; \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/main.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,55 @@ +#include "mbed.h" +#include "rtos.h" +#include "uLCD_4DGL.h" +#include "Game.h" +#include "uLCD_Multiscreen.h" + + +//already defined +//#define SIZE_X 128 +//#define SIZE_Y 128 + +//display +uLCD_4DGL screen1(p28, p27, p11); +uLCD_4DGL screen2(p9, p10, p11); +std::vector<uLCD_4DGL*> my_screens; + + +//inputs +AnalogIn sliderh(p15); +AnalogIn sliderv(p16); + + + +//game objects + + + + +int main() { + my_screens.push_back(&screen1); + my_screens.push_back(&screen2); +uLCD_Multiscreen multiscreen(my_screens); +Controller controller(sliderh, sliderv); +vec2 screen = {SIZE_X, SIZE_Y}; +Renderer gfx(multiscreen, screen); +Game game(gfx, controller); + + + + multiscreen.setBaudRate(3000000); + multiscreen.changeBackground(0x444444); + gfx.background = 0x444444; + multiscreen.cls(); + //multiscreen.unfilledRectangle(0, 0, 50, 10, -1); + + while(true){ + int x = sliderh.read()* 1000; + int y = sliderv.read()* 1000; + + //printf(controller.sliderv ); + game.loop(); + game.getInput(x, y); + //Thread::wait(10); + } +} \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed-rtos.lib Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/mbed-rtos/#63988a2238f7
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mbed.bld Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,1 @@ +http://mbed.org/users/mbed_official/code/mbed/builds/7e07b6fb45cf \ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/BackgroundColor.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,8 @@ +#include "BackgroundColor.h" +#include "uLCD_4DGL.h" +BackgroundColor::BackgroundColor(int color) { + this->color = color; +} +void BackgroundColor::execute(uLCD_4DGL* uLCD) { + uLCD->background_color(color); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/BackgroundColor.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,12 @@ +#ifndef BACKGROUNDCOLOR_H +#define BACKGROUNDCOLOR_H +#include "Command.h" +#include "uLCD_4DGL.h" +class BackgroundColor: public Command { + private: + int color; + public: + BackgroundColor(int color); + virtual void execute(uLCD_4DGL* uLCD); +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/BaudRate.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,8 @@ +#include "BaudRate.h" +#include "uLCD_4DGL.h" +BaudRate::BaudRate(int rate) { + this->rate = rate; +} +void BaudRate::execute(uLCD_4DGL* uLCD) { + uLCD->baudrate(rate); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/BaudRate.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,12 @@ +#ifndef BAUDRATE_H +#define BAUDRATE_H +#include "Command.h" +#include "uLCD_4DGL.h" +class BaudRate: public Command { + private: + int rate; + public: + BaudRate(int rate); + virtual void execute(uLCD_4DGL* uLCD); +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/Blit.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,14 @@ +#include "Blit.h" +Blit::Blit(int x, int y, int w, int h, int *colors) { + this->x = x; + this->y = y; + this->w = w; + this->h = h; + this->colors = new int[w*h]; + for (int i = 0; i < w*h; i++) { + this->colors[i] = colors[i]; + } +} +void Blit::execute(uLCD_4DGL* uLCD) { + uLCD->BLIT(x,y,w,h,colors); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/Blit.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,16 @@ +#ifndef BLIT_H +#define BLIT_H +#include "Command.h" +#include "uLCD_4DGL.h" +class Blit: public Command { + private: + int x; + int y; + int w; + int h; + int *colors; + public: + Blit(int x, int y, int w, int h, int *colors); + virtual void execute(uLCD_4DGL* uLCD); +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/ClearScreen.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,5 @@ +#include "ClearScreen.h" +#include "uLCD_4DGL.h" +void ClearScreen::execute(uLCD_4DGL* uLCD) { + uLCD->cls(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/ClearScreen.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,8 @@ +#ifndef CLEARSCREEN_H +#define CLEARSCREEN_H +#include "Command.h" +#include "uLCD_4DGL.h" +class ClearScreen: public Command { + virtual void execute(uLCD_4DGL* uLCD); +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/Command.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,15 @@ +#ifndef COMMAND_H +#define COMMAND_H +#include "uLCD_4DGL.h" +/** + * Class represents a uLCD command. + */ +class Command { + public: + /** + * Executes the command on the target uLCD. + * @param uLCD the lcd to execute the command on. + */ + virtual void execute(uLCD_4DGL* uLCD) = 0; +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/DrawPixel.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,10 @@ +#include "DrawPixel.h" +#include "uLCD_4DGL.h" +DrawPixel::DrawPixel(int x, int y, int color) { + this->x = x; + this->y = y; + this->color = color; +} +void DrawPixel::execute(uLCD_4DGL* uLCD) { + uLCD->pixel(x,y,color); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/DrawPixel.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,14 @@ +#ifndef DRAWPIXEL_H +#define DRAWPIXEL_H +#include "Command.h" +#include "uLCD_4DGL.h" +class DrawPixel: public Command { + private: + int x; + int y; + int color; + public: + DrawPixel(int x, int y, int color); + virtual void execute(uLCD_4DGL* uLCD); +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/Reset.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,5 @@ +#include "Reset.h" +#include "uLCD_4DGL.h" +void Reset::execute(uLCD_4DGL* uLCD) { + uLCD->reset(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/Reset.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,8 @@ +#ifndef RESET_H +#define RESET_H +#include "Command.h" +#include "uLCD_4DGL.h" +class Reset: public Command { + virtual void execute(uLCD_4DGL* uLCD); +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/ScreenUpdater.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,42 @@ +#include "ScreenUpdater.h" +#include "uLCD_4DGL.h" +#include "mbed.h" +static void uLCD_thread_func(void const *args) { + //printf("Thread alive."); + uLCD_4DGL *lcd = ((uLCD_Thread_Args*)args)->uLCD; + std::queue<Command*> *commands = ((uLCD_Thread_Args*)args)->commands; + Mutex *commands_mutex = ((uLCD_Thread_Args*)args)->commands_mutex; + while (true) { + if (!commands->empty()) { + commands_mutex->lock(); + Command *command = commands->front(); + commands->pop(); + command->execute(lcd); + delete command; + commands_mutex->unlock(); + } else { + //printf("empty."); + Thread::signal_wait(0x1); + } + } +} +ScreenUpdater::ScreenUpdater(uLCD_4DGL *uLCD) { + //printf("ScreenUpdater booting."); + uLCD_Thread_Args args = {uLCD, &commands, &commands_mutex}; + Thread *_thread = new Thread(uLCD_thread_func, &(args), osPriorityHigh); + uLCD_thread = _thread; + //printf("Thread creation complete\n"); + this->uLCD = uLCD; +} +void ScreenUpdater::addCommand(Command* _command) { + //printf("I'm here!"); + commands_mutex.lock(); + commands.push(_command); + //printf("Adding command %d. State %d\n", commands.size(), uLCD_thread->get_state()); + commands_mutex.unlock(); + uLCD_thread->signal_set(0x1); +} +ScreenUpdater::~ScreenUpdater() { + //printf("KILLING THREAD!!!!!!!!!!!!!!\n"); + uLCD_thread->terminate(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/ScreenUpdater.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,35 @@ +#ifndef SCREENUPDATER_H +#define SCREENUPDATER_H +#include <queue> +#include "rtos.h" +#include "uLCD_4DGL.h" +#include "Command.h" +/** + * Attaches a thread to a physical screen and makes it operate on all input instructions. + */ +class ScreenUpdater { + private: + uLCD_4DGL *uLCD; + Thread *uLCD_thread; + std::queue<Command*> commands; + Mutex commands_mutex; + public: + /** + * Attaches an LCD to the updater. + */ + ScreenUpdater(uLCD_4DGL *uLCD); + /** + * Add a command to the queue. + */ + void addCommand(Command *_command); + /** + * Destructor. + */ + ~ScreenUpdater(); +}; +typedef struct uLCD_Thread_Args { + uLCD_4DGL* uLCD; + std::queue<Command*>* commands; + Mutex* commands_mutex; +} uLCD_Thread_Args; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/VirtualScreen.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,120 @@ +#ifndef VIRTUALSCREEN_H +#define VIRTUALSCREEN_H +#include "ScreenUpdater.h" +#include "Command.h" +#include "DrawPixel.h" +#include "ClearScreen.h" +#include "BackgroundColor.h" +#include "Reset.h" +#include "BaudRate.h" +#include "Blit.h" +#include "mbed.h" +/** + * Class represents a virtual screen of arbitrary size. To keep simplicity, screen data should be kept + * in a pixel format where it can be read by physical devices. + */ +template <class pixelType, class screenType> +class VirtualScreen { + private: + std::vector<screenType*> screens; + std::vector<ScreenUpdater*> updaters; + int rows; + int columns; + int screenSize; + public: + /** + * Creates a virtual screen of size rows * columns. This screen is partitioned into different physical + * screens. Writing pixels into this screen will transparently write into + * these separate screens. + * + * @param screens A vector of physical screens to be used for drawing on. + * @param rows The number of rows in the virtual screen. + * @param columns The number of columns in the virtual screen. + */ + VirtualScreen<pixelType, screenType>(std::vector<screenType*> screens, int rows, int columns) { + printf("Virtual Screen Booting."); + this->screens = screens; + for (typename std::vector<screenType*>::iterator scr_iter = screens.begin(); scr_iter != screens.end(); scr_iter++) { + ScreenUpdater *updater = new ScreenUpdater(*scr_iter); + updaters.push_back(updater); + } + this->rows = rows; + this->columns = columns; + this->screenSize = 128; + } + + ~VirtualScreen<pixelType, screenType>() { + for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) { + delete (*updater_iter); + } + } + + /** + * Writes a pixel value into the virtual screen at (row, column) index. + * + * @param x The row to write the pixel to. + * @param y The column to write the pixel to. + * @param value The value to write to the pixel. + */ + void setPixel(int x, int y, pixelType value) { + //printf("Set pixel on row %d, col %d, val %d\n", x, y, value); + int screen_number = x / screenSize; + int x_pixel = x % screenSize; + //printf("Predicting screen %d, at col %d\n", screen_number, x_pixel); + ScreenUpdater* updater = updaters.at(screen_number); + //printf("Updater made.\n"); + Command *command = new DrawPixel(x_pixel, y, value); + //printf("Adding command.\n"); + updater->addCommand(command); + } + /** + * Clears the screens of all attached screens. + */ + void clearScreen() { + for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) { + Command* command = new ClearScreen(); + (*updater_iter)->addCommand(command); + } + } + /** + * Resets the screens of all attached screens. + */ + void resetScreen() { + for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) { + Command* command = new Reset(); + (*updater_iter)->addCommand(command); + } + } + /** + * Sets the baud rate for all screens. + * + * @param rate The desired baud rate. + */ + void setBaudRate(int rate) { + for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) { + Command* command = new BaudRate(rate); + (*updater_iter)->addCommand(command); + } + } + /** + * draw a block of pixels + */ + void BLIT(int x, int y, int w, int h, int *colors) { + for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) { + Command* command = new Blit(x,y,w,h,colors); + (*updater_iter)->addCommand(command); + } + } + /** + * Sets the background color for all screens. + * + * @param color The color of the desired background. + */ + void background_color(int color) { + for (typename std::vector<ScreenUpdater*>::iterator updater_iter = updaters.begin(); updater_iter != updaters.end(); updater_iter++) { + Command* command = new BackgroundColor(color); + (*updater_iter)->addCommand(command); + } + } +}; +#endif
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/uLCD_Multiscreen.cpp Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,121 @@ +#include "uLCD_Multiscreen.h" +#include "mbed.h" +uLCD_Multiscreen::uLCD_Multiscreen(vector<uLCD_4DGL*> screens) : virtualScreen(screens, 128, 128 * screens.size()) +{ + printf("Multiscreen Booting."); +} + +void uLCD_Multiscreen::unfilledRectangle(int x, int y, int w, int h, int color) +{ + for(int i = x; i <= x + w; i++) { + virtualScreen.setPixel(i, y, color); + } + for(int i = x; i <= x + w; i++) { + virtualScreen.setPixel(i, y + h, color); + } + + for(int i = y; i <= y + h; i++) { + virtualScreen.setPixel(x, i, color); + } + for(int i = y; i <= y + h; i++) { + virtualScreen.setPixel(x + w, i, color); + } + +} + +void uLCD_Multiscreen::drawLine(int x1, int y1, int x2, int y2, int color) +{ + int delta_x(x2 - x1); + // if x1 == x2, then it does not matter what we set here + signed char const ix((delta_x > 0) - (delta_x < 0)); + delta_x = std::abs(delta_x) << 1; + + int delta_y(y2 - y1); + // if y1 == y2, then it does not matter what we set here + signed char const iy((delta_y > 0) - (delta_y < 0)); + delta_y = std::abs(delta_y) << 1; + + virtualScreen.setPixel(x1, y1, color); + + if (delta_x >= delta_y) + { + // error may go below zero + int error(delta_y - (delta_x >> 1)); + + while (x1 != x2) + { + if ((error >= 0) && (error || (ix > 0))) + { + error -= delta_x; + y1 += iy; + } + // else do nothing + + error += delta_y; + x1 += ix; + + virtualScreen.setPixel(x1, y1, color); + } + } + else + { + // error may go below zero + int error(delta_x - (delta_y >> 1)); + + while (y1 != y2) + { + if ((error >= 0) && (error || (iy > 0))) + { + error -= delta_y; + x1 += ix; + } + // else do nothing + + error += delta_x; + y1 += iy; + + virtualScreen.setPixel(x1, y1, color); + } + } +} + +void uLCD_Multiscreen::unfilledCirlce(int x0, int y0, int radius, int color) +{ + int x = radius; + int y = 0; + int radiusError = 1-x; + + while(x >= y) + { + virtualScreen.setPixel(x + x0, y + y0, color); + virtualScreen.setPixel(y + x0, x + y0, color); + virtualScreen.setPixel(-x + x0, y + y0, color); + virtualScreen.setPixel(-y + x0, x + y0, color); + virtualScreen.setPixel(-x + x0, -y + y0, color); + virtualScreen.setPixel(-y + x0, -x + y0, color); + virtualScreen.setPixel(x + x0, -y + y0, color); + virtualScreen.setPixel(y + x0, -x + y0, color); + y++; + if (radiusError<0) + { + radiusError += 2 * y + 1; + } + else + { + x--; + radiusError += 2 * (y - x) + 1; + } + } +} + +void uLCD_Multiscreen::cls() { + virtualScreen.clearScreen(); +} + + +void uLCD_Multiscreen::changeBackground(int color) { + virtualScreen.background_color(color); +} +void uLCD_Multiscreen::setBaudRate(int rate) { + virtualScreen.setBaudRate(rate); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uLCD_Multiscreen/uLCD_Multiscreen.h Wed Mar 11 05:00:37 2015 +0000 @@ -0,0 +1,22 @@ +#ifndef ULCD_MULTISCREEN_H +#define ULCD_MULTISCREEN_H +#include "VirtualScreen.h" +#include "uLCD_4DGL.h" +/** + * CLass represents an interface for seemlessly writing to multiple uLCD screens + * in parallel. + */ +class uLCD_Multiscreen { + private: + VirtualScreen<int, uLCD_4DGL> virtualScreen; + int screen_count; + public: + uLCD_Multiscreen(vector<uLCD_4DGL*> screens); + void cls(); + void unfilledRectangle(int x, int y, int w, int h, int color); + void drawLine(int x1,int y1,int x2, int y2, int color); + void unfilledCirlce(int x0, int y0, int radius, int color); + void changeBackground(int color); + void setBaudRate(int rate); +}; +#endif