static void LCDFN(putsxyofs_style)(int xpos, int ypos,
const unsigned char *str, int style,
int w, int h, int offset)
{
int lastmode = current_vp->drawmode;
int xrect = xpos + MAX(w - offset, 0);
int x = VP_IS_RTL(current_vp) ? xpos : xrect;
#if defined(MAIN_LCD) && defined(HAVE_LCD_COLOR)
int oldfgcolor = current_vp->fg_pattern;
int oldbgcolor = current_vp->bg_pattern;
current_vp->drawmode = DRMODE_SOLID | ((style & STYLE_INVERT) ?
DRMODE_INVERSEVID : 0);
if (style & STYLE_COLORED) {
if (current_vp->drawmode == DRMODE_SOLID)
current_vp->fg_pattern = style & STYLE_COLOR_MASK;
else
current_vp->bg_pattern = style & STYLE_COLOR_MASK;
}
current_vp->drawmode ^= DRMODE_INVERSEVID;
if (style & STYLE_GRADIENT) {
current_vp->drawmode = DRMODE_FG;
lcd_gradient_rect(xpos, current_vp->width, ypos, h,
NUMLN_UNPACK(style), CURLN_UNPACK(style));
current_vp->fg_pattern = current_vp->lst_pattern;
}
else if (style & STYLE_COLORBAR) {
current_vp->drawmode = DRMODE_FG;
current_vp->fg_pattern = current_vp->lss_pattern;
lcd_fillrect(xpos, ypos, current_vp->width - xpos, h);
current_vp->fg_pattern = current_vp->lst_pattern;
}
else {
lcd_fillrect(x, ypos, current_vp->width - xrect, h);
current_vp->drawmode = (style & STYLE_INVERT) ?
(DRMODE_SOLID|DRMODE_INVERSEVID) : DRMODE_SOLID;
}
if (str[0])
lcd_putsxyofs(xpos, ypos, offset, str);
current_vp->fg_pattern = oldfgcolor;
current_vp->bg_pattern = oldbgcolor;
#else
current_vp->drawmode = DRMODE_SOLID | ((style & STYLE_INVERT) ?
0 : DRMODE_INVERSEVID);
LCDFN(fillrect)(x, ypos, current_vp->width - xrect, h);
current_vp->drawmode ^= DRMODE_INVERSEVID;
if (str[0])
LCDFN(putsxyofs)(xpos, ypos, offset, str);
#endif
current_vp->drawmode = lastmode;
}
void lcd_init(unsigned char color)
{
P5DIR |= CSX + SDA + SCLK + RESX;
P5OUT |= CSX;
P5OUT &= ~SDA;
P5OUT &= ~SCLK;
P5OUT &= ~RESX;
delayms(20);
P5OUT |= RESX;
delayms(20);
// Sleep out...
n6100_send(0x11,2);
// Ajusta o contraste...
n6100_sendcom1(0x25, 0x50);
// Liga o display e o booster...
n6100_send(0x29,2);
n6100_send(0x03,2);
delayms(10);
// Color Format... (8bits/pixel)
n6100_sendcom1(0x3a, 0x02);
// Inicializa a tabela de cores 8bits/pixel
n6100_send(0x2d,2);
// red
n6100_send(0x00,0);
n6100_send(0x02,0);
n6100_send(0x05,0);
n6100_send(0x07,0);
n6100_send(0x09,0);
n6100_send(0x0b,0);
n6100_send(0x0d,0);
n6100_send(0x0f,0);
// green
n6100_send(0x00,0);
n6100_send(0x02,0);
n6100_send(0x05,0);
n6100_send(0x07,0);
n6100_send(0x09,0);
n6100_send(0x0b,0);
n6100_send(0x0d,0);
n6100_send(0x0f,0);
// blue
n6100_send(0x00,0);
n6100_send(0x05,0);
n6100_send(0x0b,0);
n6100_send(0x0f,0);
// Memory Access Control...
n6100_sendcom1(0x36, invertido);
// Agradecimentos...
lcd_fillrect(0, 0, 132, 132, color);
//n6100_putlogo(2, 2, 128, 128, (unsigned char *)Matrix);
//delayms(4000);
}
/*lint -save -e970 Disable MISRA rule (6.3) checking. */
int main(void)
/*lint -restore Enable MISRA rule (6.3) checking. */
{
/* Write your local variable definition here */
enum logics{false, true};
uint16_t rotation = 0;
/*** Processor Expert internal initialization. DON'T REMOVE THIS CODE!!! ***/
PE_low_level_init();
/*** End of Processor Expert internal initialization. ***/
/* Write your code here */
lcd_init(Background);
add2display((unsigned char *)"University of Nairobi",0);
add2display((unsigned char *)" Physics Department ",0);
add2display((unsigned char *)" another string for ",0);
add2display((unsigned char *)" another string menu ",0);
selected=0;
while(1){
if(rotation>3)
rotation = 0;
if(selected>3)
selected=0;
lcd_setOrientation(rotation);
lcd_clear(Background);
display();
//lcd_invert(rotation);
lcd_fillrect(10,50,40,60, blue);
lcd_drawrect(10,50,40,60, red);
lcd_drawline(11,51,39,59, green);
lcd_drawcircle(30, 100,10, red);
lcd_fillcircle(30, 100,10, crimson);
WAIT1_Waitms(1000);
selected++;
rotation++;
}
/*** Don't write any code pass this line, or it will be deleted during code generation. ***/
/*** RTOS startup code. Macro PEX_RTOS_START is defined by the RTOS component. DON'T MODIFY THIS CODE!!! ***/
#ifdef PEX_RTOS_START
PEX_RTOS_START(); /* Startup of the selected RTOS. Macro is defined by the RTOS component. */
#endif
/*** End of RTOS startup code. ***/
/*** Processor Expert end of main routine. DON'T MODIFY THIS CODE!!! ***/
for(;;){}
/*** Processor Expert end of main routine. DON'T WRITE CODE BELOW!!! ***/
} /*** End of main routine. DO NOT MODIFY THIS TEXT!!! ***/
/* Clear the current viewport */
void lcd_clear_viewport(void)
{
int lastmode;
if (current_vp == &default_vp)
{
lcd_clear_display();
}
else
{
lastmode = current_vp->drawmode;
/* Invert the INVERSEVID bit and set basic mode to SOLID */
current_vp->drawmode = (~lastmode & DRMODE_INVERSEVID) |
DRMODE_SOLID;
lcd_fillrect(0, 0, current_vp->width, current_vp->height);
current_vp->drawmode = lastmode;
lcd_scroll_stop_viewport(current_vp);
}
}
/* count in letter positions, NOT pixels */
void put_cursorxy(int x, int y, bool on)
{
#ifdef HAVE_LCD_BITMAP
int fh, fw;
int xpos, ypos;
/* check here instead of at every call (ugly, but cheap) */
if (global_settings.invert_cursor)
return;
lcd_getstringsize("A", &fw, &fh);
xpos = x*6;
ypos = y*fh + lcd_getymargin();
if ( fh > 8 )
ypos += (fh - 8) / 2;
#endif
/* place the cursor */
if(on) {
#ifdef HAVE_LCD_BITMAP
lcd_mono_bitmap(bitmap_icons_6x8[Icon_Cursor], xpos, ypos, 4, 8);
#else
lcd_putc(x, y, CURSOR_CHAR);
#endif
}
else {
#if defined(HAVE_LCD_BITMAP)
/* I use xy here since it needs to disregard the margins */
lcd_set_drawmode(DRMODE_SOLID|DRMODE_INVERSEVID);
lcd_fillrect (xpos, ypos, 4, 8);
lcd_set_drawmode(DRMODE_SOLID);
#else
lcd_putc(x, y, ' ');
#endif
}
}
void button_debug_screen(void)
{
char product_id[RMI_PRODUCT_ID_LEN];
rmi_read(RMI_PRODUCT_ID, RMI_PRODUCT_ID_LEN, product_id);
int x_max = rmi_read_single(RMI_2D_SENSOR_XMAX_MSB(0)) << 8 | rmi_read_single(RMI_2D_SENSOR_XMAX_LSB(0));
int y_max = rmi_read_single(RMI_2D_SENSOR_YMAX_MSB(0)) << 8 | rmi_read_single(RMI_2D_SENSOR_YMAX_LSB(0));
int func_presence = rmi_read_single(RMI_FUNCTION_PRESENCE(RMI_2D_TOUCHPAD_FUNCTION));
int sensor_prop = rmi_read_single(RMI_2D_SENSOR_PROP2(0));
int sensor_resol = rmi_read_single(RMI_2D_SENSOR_RESOLUTION(0));
int min_dist = rmi_read_single(RMI_2D_MIN_DIST);
int gesture_settings = rmi_read_single(RMI_2D_GESTURE_SETTINGS);
union
{
unsigned char data;
signed char value;
}sensitivity;
rmi_read(RMI_2D_SENSITIVITY_ADJ, 1, &sensitivity.data);
/* Device to screen */
int zone_w = LCD_WIDTH;
int zone_h = (zone_w * y_max + x_max - 1) / x_max;
int zone_x = 0;
int zone_y = LCD_HEIGHT - zone_h;
#define DX2SX(x) (((x) * zone_w ) / x_max)
#define DY2SY(y) (zone_h - ((y) * zone_h ) / y_max)
struct viewport report_vp;
memset(&report_vp, 0, sizeof(report_vp));
report_vp.x = zone_x;
report_vp.y = zone_y;
report_vp.width = zone_w;
report_vp.height = zone_h;
struct viewport gesture_vp;
memset(&gesture_vp, 0, sizeof(gesture_vp));
gesture_vp.x = 0;
gesture_vp.y = zone_y - 80;
gesture_vp.width = LCD_WIDTH;
gesture_vp.height = 80;
while(1)
{
lcd_set_viewport(NULL);
lcd_clear_display();
int btns = button_read_device();
lcd_putsf(0, 0, "button bitmap: %x", btns);
lcd_putsf(0, 1, "RMI: id=%s p=%x s=%x", product_id, func_presence, sensor_prop);
lcd_putsf(0, 2, "xmax=%d ymax=%d res=%d", x_max, y_max, sensor_resol);
lcd_putsf(0, 3, "attn=%d ctl=%x int=%x",
imx233_get_gpio_input_mask(0, 0x08000000) ? 0 : 1,
rmi_read_single(RMI_DEVICE_CONTROL),
rmi_read_single(RMI_INTERRUPT_REQUEST));
lcd_putsf(0, 4, "sensi: %d min_dist: %d", (int)sensitivity.value, min_dist);
lcd_putsf(0, 5, "gesture: %x", gesture_settings);
union
{
unsigned char data[10];
struct
{
struct rmi_2d_absolute_data_t absolute;
struct rmi_2d_relative_data_t relative;
struct rmi_2d_gesture_data_t gesture;
}s;
}u;
int absolute_x = u.s.absolute.x_msb << 8 | u.s.absolute.x_lsb;
int absolute_y = u.s.absolute.y_msb << 8 | u.s.absolute.y_lsb;
int nr_fingers = u.s.absolute.misc & 7;
bool gesture = (u.s.absolute.misc & 8) == 8;
int palm_width = u.s.absolute.misc >> 4;
rmi_read(RMI_DATA_REGISTER(0), 10, u.data);
lcd_putsf(0, 6, "abs: %d %d %d", absolute_x, absolute_y, (int)u.s.absolute.z);
lcd_putsf(0, 7, "rel: %d %d", (int)u.s.relative.x, (int)u.s.relative.y);
lcd_putsf(0, 8, "gesture: %x %x", u.s.gesture.misc, u.s.gesture.flick);
lcd_putsf(0, 9, "misc: w=%d g=%d f=%d", palm_width, gesture, nr_fingers);
lcd_set_viewport(&report_vp);
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0xff, 0, 0), LCD_BLACK);
lcd_drawrect(0, 0, zone_w, zone_h);
if(nr_fingers == 1)
{
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0, 0, 0xff), LCD_BLACK);
lcd_drawline(DX2SX(absolute_x) - u.s.relative.x,
DY2SY(absolute_y) + u.s.relative.y,
DX2SX(absolute_x), DY2SY(absolute_y));
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0, 0xff, 0), LCD_BLACK);
lcd_fillrect(DX2SX(absolute_x) - 1, DY2SY(absolute_y) - 1, 3, 3);
}
lcd_set_viewport(&gesture_vp);
lcd_set_drawinfo(DRMODE_SOLID, LCD_RGBPACK(0xff, 0xff, 0), LCD_BLACK);
if(u.s.gesture.misc & RMI_2D_GEST_MISC_CONFIRMED)
{
switch(u.s.gesture.misc & RMI_2D_GEST_MISC_TAP_CODE_BM)
{
case RMI_2D_GEST_MISC_NO_TAP: break;
case RMI_2D_GEST_MISC_SINGLE_TAP:
lcd_putsf(0, 0, "TAP!");
break;
case RMI_2D_GEST_MISC_DOUBLE_TAP:
lcd_putsf(0, 0, "DOUBLE TAP!");
break;
case RMI_2D_GEST_MISC_TAP_AND_HOLD:
lcd_putsf(0, 0, "TAP & HOLD!");
break;
default: break;
}
if(u.s.gesture.misc & RMI_2D_GEST_MISC_FLICK)
{
lcd_putsf(0, 1, "FLICK!");
int flick_x = u.s.gesture.flick & RMI_2D_GEST_FLICK_X_BM;
int flick_y = (u.s.gesture.flick & RMI_2D_GEST_FLICK_Y_BM) >> RMI_2D_GEST_FLICK_Y_BP;
#define SIGN4EXT(a) \
if(a & 8) a = -((a ^ 0xf) + 1);
SIGN4EXT(flick_x);
SIGN4EXT(flick_y);
int center_x = (LCD_WIDTH * 2) / 3;
int center_y = 40;
lcd_drawline(center_x, center_y, center_x + flick_x * 5, center_y - flick_y * 5);
}
}
lcd_update();
if(btns & BUTTON_POWER)
break;
if(btns & BUTTON_VOL_DOWN || btns & BUTTON_VOL_UP)
{
if(btns & BUTTON_VOL_UP)
sensitivity.value++;
if(btns & BUTTON_VOL_DOWN)
sensitivity.value--;
rmi_write(RMI_2D_SENSITIVITY_ADJ, 1, &sensitivity.data);
}
yield();
}
void cmd_lcd_test(uint_least16_t fgcolor, uint_least16_t bgcolor)
{
uint_least8_t c=1, f_save=features;
char tmp[32];
#ifdef TP_SUPPORT
uint_least16_t x, y, z, last_x=0, last_y=0;
uint_least32_t ms=0;
tp_init();
ldr_init();
features = FEATURE_TP | FEATURE_LDR; //FEATURE_TP | FEATURE_LDR
#else
uint_least8_t sw;
int_least8_t pos=0, hpos=0, vpos=0;
enc_init();
features = FEATURE_ENC;
#endif
lcd_fillrect(0, 0, (LCD_WIDTH-1)/3, LCD_HEIGHT-1, RGB(255,0,0));
lcd_fillrect((LCD_WIDTH-1)/3, 0, ((LCD_WIDTH-1)/3)*2, LCD_HEIGHT-1, RGB(0,255,0));
lcd_fillrect(((LCD_WIDTH-1)/3)*2, 0, LCD_WIDTH-1, LCD_HEIGHT-1, RGB(0,0,255));
/*
delay_ms(1500);
lcd_clear(bgcolor);
lcd_setorientation( 0); lcd_drawrect(10, 20, 40, 40, RGB(200, 0, 0)); lcd_drawtext(15, 25, "0 ", 0, RGB(200, 0, 0), 0, 0);
lcd_setorientation( 90); lcd_drawrect(10, 20, 40, 40, RGB( 0,200, 0)); lcd_drawtext(15, 25, "90 ", 0, RGB( 0,200, 0), 0, 0);
lcd_setorientation(180); lcd_drawrect(10, 20, 40, 40, RGB( 0, 0,200)); lcd_drawtext(15, 25, "180", 0, RGB( 0, 0,200), 0, 0);
lcd_setorientation(270); lcd_drawrect(10, 20, 40, 40, RGB(200, 0,200)); lcd_drawtext(15, 25, "270", 0, RGB(200, 0,200), 0, 0);
lcd_setorientation(0);
lcd_drawline(0, LCD_WIDTH/4*1, LCD_WIDTH-1, LCD_WIDTH/4*1, RGB(120,120,120));
lcd_drawline(0, LCD_WIDTH/4*2, LCD_WIDTH-1, LCD_WIDTH/4*2, RGB(120,120,120));
lcd_drawline(0, LCD_WIDTH/4*3, LCD_WIDTH-1, LCD_WIDTH/4*3, RGB(120,120,120));
lcd_drawline(LCD_WIDTH/4*1, 0, LCD_WIDTH/4*1, LCD_HEIGHT-1, RGB(120,120,120));
lcd_drawline(LCD_WIDTH/4*2, 0, LCD_WIDTH/4*2, LCD_HEIGHT-1, RGB(120,120,120));
lcd_drawline(LCD_WIDTH/4*3, 0, LCD_WIDTH/4*3, LCD_HEIGHT-1, RGB(120,120,120));
lcd_drawcircle(LCD_WIDTH/2, LCD_HEIGHT/2, 40, RGB(120,120,120));
*/
lcd_drawtext(LCD_CENTER, LCD_HEIGHT/2-5, "v"VERSION, 0, 0, 0, 0);
lcd_drawtext(LCD_CENTER, LCD_HEIGHT/2+5, "("__DATE__")", 0, 0, 0, 0);
lcd_drawtext(LCD_CENTER, LCD_HEIGHT-10, "watterott.com", 1, 0, 0, 0);
do
{
#ifdef TP_SUPPORT
tp_read();
z = tp_getz();
if(z)
{
x = tp_getx();
y = tp_gety();
if((x!=last_x) || (y!=last_y))
{
last_x = x;
last_y = y;
lcd_fillcircle(x, y, 4, fgcolor); //lcd_drawpixel(x, y);
sprintf(tmp, "X%03i Y%03i Z%03i", x, x, z);
lcd_drawtext(5, 5, tmp, 0, fgcolor, bgcolor, 1);
}
GPIO_SETPIN(LED_PORT, LED_PIN); //LED on
}
else
{
GPIO_CLRPIN(LED_PORT, LED_PIN); //LED off
}
if(features & FEATURE_LDR)
{
if((get_ms() - ms) >= 100)
{
ms = get_ms();
x = ldr_service(100);
sprintf(tmp, "LDR %03i", x);
lcd_drawtext(5, 15, tmp, 0, fgcolor, bgcolor, 1);
}
}
#else //TP_SUPPORT
pos += enc_getdelta();
hpos += nav_gethdelta();
vpos += nav_getvdelta();
sprintf(tmp, "P%03i H%03i V%03i", pos, hpos, vpos);
lcd_drawtext(5, 5, tmp, 0, fgcolor, bgcolor, 1);
sw = enc_getsw();
sw |= nav_getsw();
if(sw)
{
GPIO_SETPIN(LED_PORT, LED_PIN); //LED on
if(sw & 0x02)
{
if(features == FEATURE_ENC)
{
sprintf(tmp, "NAV");
nav_init();
features = FEATURE_NAV;
}
else //if(features == FEATURE_NAV)
{
sprintf(tmp, "ENC");
enc_init();
features = FEATURE_ENC;
}
lcd_drawtext(5, 25, tmp, 0, fgcolor, bgcolor, 1);
delay_ms(500);
while(enc_getsw() || nav_getsw());
}
else if(sw & 0x01)
{
lcd_drawtext(5, 15, "press", 0, fgcolor, bgcolor, 1);
}
}
else
{
GPIO_CLRPIN(LED_PORT, LED_PIN); //LED off
}
#endif
if(if_available())
{
c = if_read8();
}
}while(c != 0);
GPIO_CLRPIN(LED_PORT, LED_PIN); //LED off
lcd_clear(bgcolor);
features = f_save;
return;
}
void lcd_drawcircle(unsigned int x0, unsigned int y0, unsigned int radius, unsigned char color, int width){
int f = 1 - radius;
int ddF_x = 0;
int ddF_y = -2 * radius;
int x = 0;
int y = radius;
lcd_fillrect(x0, y0 + radius,width,width, color);
lcd_fillrect(x0, y0 - radius,width,width, color);
lcd_fillrect(x0 + radius, y0,width,width, color);
lcd_fillrect(x0 - radius, y0,width,width, color);
while (x < y) {
if (f >= 0) {
y--;
ddF_y += 2;
f += ddF_y;
}
x++;
ddF_x += 2;
f += ddF_x + 1;
lcd_fillrect(x0 + x, y0 + y,width,width, color);
lcd_fillrect(x0 - x, y0 + y,width,width, color);
lcd_fillrect(x0 + x, y0 - y,width,width, color);
lcd_fillrect(x0 - x, y0 - y,width,width, color);
lcd_fillrect(x0 + y, y0 + x,width,width, color);
lcd_fillrect(x0 - y, y0 + x,width,width, color);
lcd_fillrect(x0 + y, y0 - x,width,width, color);
lcd_fillrect(x0 - y,y0 - x,width,width, color);
}
}
void lcd_clear(unsigned char color)
{
lcd_fillrect(0, 0, 132, 132, color);
}
