static ssize_t touch_led_control(struct device *dev,
struct device_attribute *attr, const char *buf,
size_t size)
{
unsigned char data;
if (sscanf(buf, "%d\n", &data) == 1) {
printk(KERN_DEBUG "touch_led_control: %d \n", data);
#ifdef CONFIG_KEYPAD_CYPRESS_TOUCH_USE_BLN
if ((touchkey_enable == 1)) {
if (data == 1)
set_backlight(BACKLIGHT_ON);
if (data == 2) {
/* only disable leds if no notification is enabled*/
if (BacklightNotification_ongoing)
set_backlight(BACKLIGHT_ON);
else
set_backlight(BACKLIGHT_OFF);
}
} else
printk(KERN_DEBUG "touchkey is not enabled.W\n");
#else
i2c_touchkey_write(&data, 1);
touchkey_led_status = data;
#endif
} else
printk("touch_led_control Error\n");
return size;
}
static ssize_t blink_control_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t size)
{
unsigned int data;
if(sscanf(buf, "%u\n", &data) == 1) {
if(data == 0 || data == 1){
if (BacklightNotification_ongoing){
printk(KERN_DEBUG "%s: %u \n", __FUNCTION__, data);
if (data == 1){
BLN_blink_enabled = true;
set_backlight(BACKLIGHT_OFF);
}
if(data == 0){
BLN_blink_enabled = false;
set_backlight(BACKLIGHT_ON);
}
}
} else
printk(KERN_DEBUG "%s: wrong input %u\n", __FUNCTION__, data);
} else
printk("%s: input error\n", __FUNCTION__);
return size;
}
static ssize_t backlight_write(struct file *file, const char *buffer, size_t cnt, loff_t *pos)
{
unsigned char val;
int ret;
#if 1
if (cnt == 0) {
return cnt;
}
ret = copy_from_user(&val, buffer, sizeof val) ? -EFAULT : 0;
if (ret) {
return ret;
}
val &= 0x01;
set_backlight(val);
return cnt;
#else
if(cnt <= 0)
return cnt;
ret = copy_from_user(&val, buffer, sizeof(val));
printk("value = %d, %d\n", val, ret);
val &= 0x1;
set_backlight(val);
return ret;
#endif
}
// Puts the device in a suspended power state, if supported.
// Specific to Verix: Sleep only supported on battery-powered terminals while running on battery.
// Terminal will power off after being in sleep state long enough.
void Platform_powersleep(void) {
set_backlight(0);
read_evt(EVT_CONSOLE | EVT_KBD | EVT_SYSTEM); // Clear the events
// Grab the sleep semaphore and hold onto it until sleep is done.
// When comm thread tries to poll it, this will freeze the communications thread and prevent
// it from waiting on anything else that could wake the terminal during sleep.
// (If it is waiting on anything like a timer or Platform_sleep_ms the terminal will not stay asleep.)
sem_wait(&SleepSemaphore);
Platform_sleep_ms(1200); // Give the comm thread long enough to get stuck waiting on the semaphore,
// which it polls every 1000ms while idle.
SVC_SLEEP(); // The Sleep will not occur right now, but it will occur as soon as all threads are completely idle
// (i.e. waiting on unavailable semaphore or untriggered events)
wait_evt(EVT_CONSOLE | EVT_KBD | EVT_SYSTEM); // Wait for events signaling a wakeup or powerup, which shall be set upon awake due to *GKE=1 (set at startup)
//LastUserActivityTick = read_ticks();
set_backlight(1);
// Release the semaphore, allowing the communications thread to start running.
sem_post(&SleepSemaphore);
}
static int ipod_blank(int blank_mode, const struct fb_info *info)
{
static int backlight_on = -1;
switch (blank_mode) {
case VESA_NO_BLANKING:
/* printk(KERN_ERR "VESA_NO_BLANKING\n"); */
/* start oscillation
* wait 10ms
* cancel standby
* turn on LCD power
*/
lcd_cmd_and_data(0x0, 0x0, 0x1);
udelay(10000);
lcd_cmd_and_data(0x3, 0x15, 0x0);
lcd_cmd_and_data(0x3, 0x15, 0xc);
if (backlight_on != -1) {
set_backlight(backlight_on);
}
backlight_on = -1;
break;
case VESA_VSYNC_SUSPEND:
case VESA_HSYNC_SUSPEND:
/* printk(KERN_ERR "VESA_XSYNC_BLANKING\n"); */
if (backlight_on == -1) {
backlight_on = get_backlight();
set_backlight(0);
}
/* go to SLP = 1 */
/* 10101 00001100 */
lcd_cmd_and_data(0x3, 0x15, 0x0);
lcd_cmd_and_data(0x3, 0x15, 0x2);
break;
case VESA_POWERDOWN:
/* printk(KERN_ERR "VESA_POWERDOWN\n"); */
if (backlight_on == -1) {
backlight_on = get_backlight();
set_backlight(0);
}
/* got to standby */
lcd_cmd_and_data(0x3, 0x15, 0x1);
break;
default:
/* printk(KERN_ERR "unknown blank value %d\n", blank_mode); */
return -EINVAL;
}
return 0;
}
LLDSPEC bool_t gdisp_lld_init(GDisplay* g) {
// Initialize the private structure
g->priv = 0;
g->board = 0;
// Init the board
init_board(g);
// Initialise the LTDC controller
_ltdc_init();
// Initialise DMA2D
#if LTDC_USE_DMA2D
dma2d_init();
#endif
// Finish Init the board
post_init_board(g);
// Turn on the back-light
set_backlight(g, GDISP_INITIAL_BACKLIGHT);
// Initialise the GDISP structure
g->g.Width = driverCfg.bglayer.width;
g->g.Height = driverCfg.bglayer.height;
g->g.Orientation = GDISP_ROTATE_0;
g->g.Powermode = powerOn;
g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
g->g.Contrast = GDISP_INITIAL_CONTRAST;
return TRUE;
}
Display::Display(KeyPanel &kpnl, Scheduler &shd,I2cBus& bus, GpioPort& rst, GpioPort& backlight) : keyPanel(kpnl), scheduler(shd), i2cBus(bus) {
this->write_usleep = 100;
this->address = 0xff;
this->bus = string(i2cBus.getBus());
this->rst = string(rst.getName());
this->backlight = string(backlight.getName());
this->backlight_state = true;
this->key_light_delay = 1000;
timedLightOff.setCallback([&] () { this->set_backlight(false);});
timedLightOff.setInterval(10);
reset_pin = new GpioPin(rst);
reset_pin->pin_export();
reset_pin->set_direction(homerio::OUT);
reset_pin->pin_open();
reset_pin->setState(homerio::STATE_ON);
backlight_pin = new GpioPin(backlight);
backlight_pin->pin_export();
backlight_pin->set_direction(homerio::OUT);
backlight_pin->pin_open();
scheduler.ScheduleAfter(timedLightOff);
keyPanel.keyAttach(keyPanel_reg, [&] ( KeyButton& k ) {
if(!is_backlight_on()) {
set_backlight(true);
}
scheduler.ScheduleRestart(timedLightOff);
});
}
int main(int argc, char** argv) {
fd = wiringPiI2CSetup(I2C_ADDRESS);
init();
init();
set_backlight(true);
print("Please wait...",0);
printf("Done\n");
}
LLDSPEC void gdisp_lld_control(GDisplay* g) {
switch(g->p.x) {
case GDISP_CONTROL_POWER:
if (g->g.Powermode == (powermode_t)g->p.ptr)
return;
switch((powermode_t)g->p.ptr) {
case powerOff: case powerOn: case powerSleep: case powerDeepSleep:
// TODO
break;
default:
return;
}
g->g.Powermode = (powermode_t)g->p.ptr;
return;
case GDISP_CONTROL_ORIENTATION:
if (g->g.Orientation == (orientation_t)g->p.ptr)
return;
switch((orientation_t)g->p.ptr) {
case GDISP_ROTATE_0:
case GDISP_ROTATE_180:
if (g->g.Orientation == GDISP_ROTATE_90 || g->g.Orientation == GDISP_ROTATE_270) {
coord_t tmp;
tmp = g->g.Width;
g->g.Width = g->g.Height;
g->g.Height = tmp;
}
break;
case GDISP_ROTATE_90:
case GDISP_ROTATE_270:
if (g->g.Orientation == GDISP_ROTATE_0 || g->g.Orientation == GDISP_ROTATE_180) {
coord_t tmp;
tmp = g->g.Width;
g->g.Width = g->g.Height;
g->g.Height = tmp;
}
break;
default:
return;
}
g->g.Orientation = (orientation_t)g->p.ptr;
return;
case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
set_backlight(g, (unsigned)g->p.ptr);
g->g.Backlight = (unsigned)g->p.ptr;
return;
case GDISP_CONTROL_CONTRAST:
if ((unsigned)g->p.ptr > 100) g->p.ptr = (void *)100;
// TODO
g->g.Contrast = (unsigned)g->p.ptr;
return;
}
}
static void disable_led_notification(void){
printk(KERN_DEBUG "%s: notification led disabled\n", __FUNCTION__);
/* disable touchkey vdd in sleep mode */
BacklightNotification_enabled = false;
if (touchkey_enable != 1){
/* write to i2cbus, disable backlights */
set_backlight(BACKLIGHT_OFF);
}
}
int WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow)
{
MEMORYSTATUS mem_status1, mem_status2;
unsigned int c = 1000U;
FILE *fp;
GlobalMemoryStatus(&mem_status1);
do {
set_backlight(FALSE);
set_backlight(TRUE);
} while (--c != 0);
GlobalMemoryStatus(&mem_status2);
if ((fp = _wfopen(L"\\Evadeo\\test.txt", L"wt")) != NULL) {
fprintf(fp, "Avant : [%lu] Apres : [%lu]\n",
(unsigned long) mem_status1.dwAvailPhys,
(unsigned long) mem_status2.dwAvailPhys);
fclose(fp);
}
return 0;
}
static int __init backlight_init(void)
{
int ret;
ret = misc_register(&backlight_device);
if(ret){
goto ERR;
}
setup_backlight_io();
set_backlight(1);
return 0;
ERR:
printk("register backlight failed\n");
misc_deregister(&backlight_device);
return ret;
}
static void enable_led_notification(void){
if (backlight_notification_allowed){
if (touchkey_enable != 1){
touchkey_power_on();
mdelay(100);
/* enable touchkey vdd in sleep mode */
BacklightNotification_enabled = true;
/* write to i2cbus, enable backlights */
set_backlight(BACKLIGHT_ON);
printk(KERN_DEBUG "%s: notification led enabled\n", __FUNCTION__);
}
else
printk(KERN_DEBUG "%s: cannot set notification led, touchkeys are enabled\n",__FUNCTION__);
}
}
void main()
{
u16 resultat;
u8 compteur=0;
init_picstar();
init_adc(); // code de l'exercise 2
// initialiser le pwm sur RC2
init_pwm(); // code a développer
// initialise l'écran lcd
init_lcd();
set_backlight(ON);
while(1)
{
u16 tmp;
resultat=get_adc0();
#ifdef ACTIVER_MOTEUR
set_pwm(1,resultat); // pwm duty = potentiometre
lcd_gotoxy(0,0);
fprintf(_H_USER,"HELLO WORLD %3u ", compteur & 0xff);
lcd_gotoxy(0,1);
fprintf(_H_USER,"ADC= %u ",resultat);
#else // si non activer le son
if((resultat+=PLIMITE)>255)resultat=255;
set_freq(1,resultat);
lcd_gotoxy(0,0);
fprintf(_H_USER,"ADC= %u ", resultat);
lcd_gotoxy(0,1);
// calcul de la frequence en 10khz
tmp=120000L/16/resultat;
fprintf(_H_USER,"Freq=%u.%1u khz ",tmp/10 & 0xff, tmp%10 &0xff);
#endif
delay_ms(10);
} // end while
}// fin of program
/* initialise the LCD */
static void
init_lcd(void)
{
if ( read_controller_id() != HD66753_ID ) {
printk(KERN_ERR "Unknown LCD controller ID: 0x%x id?\n", read_controller_id());
}
/* driver output control - 168x128 -> we use 160x128 */
/* CMS=0, SGS=1 */
lcd_cmd_and_data(0x1, 0x1, 0xf);
/* ID=1 -> auto decrement address counter */
/* AM=00 -> data is continuously written in parallel */
/* LG=00 -> no logical operation */
lcd_cmd_and_data(0x5, 0x0, 0x10);
/* backlight off & set grayscale */
set_backlight(0);
}
LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
// No private area for this controller
g->priv = 0;
// Initialise the board interface
init_board(g);
/* Turn on the back-light */
set_backlight(g, GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */
g->g.Width = GDISP_SCREEN_WIDTH;
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Orientation = GDISP_ROTATE_0;
g->g.Powermode = powerOn;
g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
g->g.Contrast = GDISP_INITIAL_CONTRAST;
return TRUE;
}
/**
* @brief Driver Control
* @details Unsupported control codes are ignored.
* @note The value parameter should always be typecast to (void *).
* @note There are some predefined and some specific to the low level driver.
* @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t
* GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t
* GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver
* that only supports off/on anything other
* than zero is on.
* GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100.
* GDISP_CONTROL_LLD - Low level driver control constants start at
* this value.
*
* @param[in] what What to do.
* @param[in] value The value to use (always cast to a void *).
*
* @notapi
*/
void gdisp_lld_control(unsigned what, void *value) {
switch(what) {
case GDISP_CONTROL_POWER:
if (GDISP.Powermode == (gdisp_powermode_t)value)
return;
switch((gdisp_powermode_t)value) {
case powerOff:
display_off();
break;
case powerSleep:
display_off();
break;
case powerDeepSleep:
display_off();
break;
case powerOn:
display_on();
break;
default:
return;
}
GDISP.Powermode = (gdisp_powermode_t)value;
return;
case GDISP_CONTROL_BACKLIGHT:
set_backlight((uint8_t)(size_t)value);
return;
case GDISP_CONTROL_CONTRAST:
if ((unsigned)value > 100) value = (void*)100;
if (GDISP.Contrast == (uint8_t)((float)((size_t)value) * 63.0/100.0))
return;
set_contrast((uint8_t)((float)((size_t)value) * 63.0/100.0) );
GDISP.Contrast = (unsigned)value;
return;
case GDISP_CONTROL_LLD_FLUSH:
gdisp_lld_display();
return;
}
}
LLDSPEC bool_t gdisp_lld_init(GDisplay *g)
{
// No private area for this controller
g->priv = 0;
// Initialise the board interface
init_board(g);
// Hardware reset
setpin_reset(g, TRUE);
delayms(100);
setpin_reset(g, FALSE);
delayms(100);
acquire_bus(g);
const uint16_t *list = &lcd_init_list[0];
uint8_t size = sizeof(lcd_init_list) / sizeof(lcd_init_list[0]);
while(size--) {
write_index(g, *list++);
}
// Finish Init
post_init_board(g);
release_bus(g);
// Turn on the back-light
set_backlight(g, GDISP_INITIAL_BACKLIGHT);
// Initialise the GDISP structure to match
g->g.Width = GDISP_SCREEN_WIDTH;
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Orientation = GDISP_ROTATE_0;
g->g.Powermode = powerOn;
g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
g->g.Contrast = GDISP_INITIAL_CONTRAST;
return TRUE;
}
void main()
{
char LCD_buffer[32];
u8 boutons;
u8 presse;
u8 compteur=0;
init_picstar();
init_lcd();
set_backlight(ON);
// boucle principale ......................................................................
while(1)
{
// nous lisons le port D en entrée pour identifier la position des 4 bouttons
TRISD|=0xf0; // bit du haut en entrée
boutons=PORTD & 0xf0;
TRISD&=0x0f; // remettre les lignes en sortie
if(boutons == 0xe0)presse=3;
else if(boutons == 0xd0)presse=4;
else if(boutons == 0xb0)presse=2;
else if(boutons == 0x70)presse=1;
else presse=0;
lcd_gotoxy(0,0);
fprintf(_H_USER,"HELLO WORLD %3u ", compteur & 0xff);
lcd_gotoxy(0,1);
fprintf(_H_USER,"boutons = %u",presse);
compteur++;
delay_ms(100);
} // end while
}// fin du programme ---------------------------------------------------------------------
static int ipod_fb_ioctl(struct inode *inode, struct file *file, u_int cmd,
u_long arg, int con, struct fb_info *info)
{
int val;
switch (cmd) {
case FBIOGET_CONTRAST:
val = get_contrast();
if (put_user(val, (int *)arg))
return -EFAULT;
break;
case FBIOPUT_CONTRAST:
val = (int)arg;
if (val < IPOD_MIN_CONTRAST || val > IPOD_MAX_CONTRAST)
return -EINVAL;
set_contrast(val);
break;
case FBIOGET_BACKLIGHT:
val = get_backlight();
if (put_user(val, (int *)arg))
return -EFAULT;
break;
case FBIOPUT_BACKLIGHT:
val = (int)arg;
set_backlight(val);
break;
default:
return -EINVAL;
}
return 0;
}
int Dpy::init() {
int ret;
this->backlight_state = true;
this->display_mode = WSTAR_DISPLAY_STATE | WSTAR_DISPLAY_CMD;
this->function_set = WSTAR_FUNCTION_8BIT | WSTAR_FUNCTION_TWO_LINE_5X8 | WSTAR_FUNCTION_CMD;
this->entry_mode = WSTAR_ENTRY_MODE_CMD;
this->cursor_display_shift = WSTAR_CUR_DPY_SHIFT_RIGHT | WSTAR_CUR_DPY_SHIFT_SCREEN | WSTAR_CUR_DPY_SHIFT_CMD;
this->ddram_addr = WSTAR_DDRAM_CMD;
// Extended instruction set (IS=1)
this->bias_osc_frequency_adj = 0x04 | WSTAR_BIAS_OSC_CMD;
this->icon_ram_address = WSTAR_ICON_RAM_ADD_CMD;
this->pow_icon_contrast = WSTAR_POW_ICON_CONTRAST_BOOST | WSTAR_POW_ICON_CONTRAST_CMD;
this->follower = FOLLOWER_DEFAULT | WSTAR_FOLLOWER_ON | WSTAR_FOLLOWER_CMD;
this->contrast_set = CONTRAST_DEFAULT | WSTAR_CONTRAST_LOW_CMD;
set_backlight(backlight_state);
ret = write_cmd(function_set);
ret = set_extended_mode();
ret = write_cmd(bias_osc_frequency_adj);
ret = write_cmd(contrast_set);
ret = write_cmd(pow_icon_contrast);
ret = write_cmd(follower);
ret = write_cmd(display_mode);
return(ret);
}
// #error "SSD1327 - Hardware control is not supported yet"
LLDSPEC void gdisp_lld_control(GDisplay *g) {
switch(g->p.x) {
case GDISP_CONTROL_POWER:
if (g->g.Powermode == (powermode_t)g->p.ptr)
return;
switch((powermode_t)g->p.ptr) {
case powerOff:
acquire_bus(g);
write_cmd(g, SSD1327_SET_DISPLAY_MODE_ALL_OFF);
release_bus();
break;
case powerSleep:
case powerDeepSleep:
acquire_bus(g);
write_cmd(g, SSD1327_SET_SLEEP_ON);
release_bus(g);
break;
case powerOn:
acquire_bus(g);
write_cmd(g, SSD1327_SET_SLEEP_OFF);
write_cmd(g, SSD1327_SET_DISPLAY_MODE_ALL_ON);
release_bus(g);
break;
default:
return;
}
g->g.Powermode = (powermode_t)g->p.ptr;
return;
case GDISP_CONTROL_ORIENTATION:
if (g->g.Orientation == (orientation_t)g->p.ptr)
return;
switch((orientation_t)g->p.ptr) {
case GDISP_ROTATE_0: // correct
acquire_bus(g);
write_reg(g, SSD1327_SET_REMAP, (0b01<<6) | (1<<5) | (1<<4) | (1<<2) | 0b00);
// bits:
// [0] : address increment (0: horizontal, 1: vertical, reset 0)
// [1] : column remap (0: 0..127, 1: 127..0, reset 0)
// [2] : color remap (0: A->B->C, 1: C->B->A, reset 0)
// [3] : reserved
// [4] : column scan direction (0: top->down, 1: bottom->up, reset 0)
// [5] : odd/even split COM (0: disable, 1: enable, reset 1)
// [6..7] : color depth (00,01: 65k, 10: 262k, 11: 262k format 2)
write_cmd(g, SSD1327_WRITE_RAM);
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH;
release_bus(g);
break;
case GDISP_ROTATE_90:
acquire_bus(g);
write_reg(g, SSD1327_SET_REMAP, (0b01<<6) | (1<<5) | (1<<4) | (1<<2) | 0b10);
write_cmd(g, SSD1327_WRITE_RAM);
g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT;
release_bus(g);
break;
case GDISP_ROTATE_180:
acquire_bus(g);
write_reg(g, SSD1327_SET_REMAP, (0b01<<6) | (1<<5) | (0<<4) | (1<<2) | 0b00);
write_reg(g, SSD1327_SET_REMAP, 0b01100110);
write_cmd(g, SSD1327_WRITE_RAM);
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH;
release_bus(g);
break;
case GDISP_ROTATE_270:
acquire_bus(g);
write_reg(g, SSD1327_SET_REMAP, (0b01<<6) | (1<<5) | (0<<4) | (1<<2) | 0b01);
write_cmd(g, SSD1327_WRITE_RAM);
g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT;
release_bus(g);
break;
default:
return;
}
g->g.Orientation = (orientation_t)g->p.ptr;
return;
case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)g->p.ptr > 100)
g->p.ptr = (void *)100;
set_backlight(g, (unsigned)g->p.ptr);
g->g.Backlight = (unsigned)g->p.ptr;
return;
//case GDISP_CONTROL_CONTRAST:
default:
return;
}
}
bool_t GDISP_LLD(init)(void) {
/* initialize the hardware */
init_board();
/* Hardware reset */
setpin_reset(TRUE);
delayms(20);
setpin_reset(TRUE);
delayms(20);
/* Get the bus for the following initialisation commands */
acquire_bus();
write_reg(0x11,0x2004);
write_reg(0x13,0xCC00);
write_reg(0x15,0x2600);
write_reg(0x14,0x252A);
write_reg(0x12,0x0033);
write_reg(0x13,0xCC04);
delayms(1);
write_reg(0x13,0xCC06);
delayms(1);
write_reg(0x13,0xCC4F);
delayms(1);
write_reg(0x13,0x674F);
write_reg(0x11,0x2003);
delayms(1);
// Gamma Setting
write_reg(0x30,0x2609);
write_reg(0x31,0x242C);
write_reg(0x32,0x1F23);
write_reg(0x33,0x2425);
write_reg(0x34,0x2226);
write_reg(0x35,0x2523);
write_reg(0x36,0x1C1A);
write_reg(0x37,0x131D);
write_reg(0x38,0x0B11);
write_reg(0x39,0x1210);
write_reg(0x3A,0x1315);
write_reg(0x3B,0x3619);
write_reg(0x3C,0x0D00);
write_reg(0x3D,0x000D);
write_reg(0x16,0x0007);
write_reg(0x02,0x0013);
write_reg(0x03,0x0003);
write_reg(0x01,0x0127);
delayms(1);
write_reg(0x08,0x0303);
write_reg(0x0A,0x000B);
write_reg(0x0B,0x0003);
write_reg(0x0C,0x0000);
write_reg(0x41,0x0000);
write_reg(0x50,0x0000);
write_reg(0x60,0x0005);
write_reg(0x70,0x000B);
write_reg(0x71,0x0000);
write_reg(0x78,0x0000);
write_reg(0x7A,0x0000);
write_reg(0x79,0x0007);
write_reg(0x07,0x0051);
delayms(1);
write_reg(0x07,0x0053);
write_reg(0x79,0x0000);
reset_viewport();
set_backlight(GDISP_INITIAL_BACKLIGHT);
/* Now initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH;
GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Orientation = GDISP_ROTATE_0;
GDISP.Powermode = powerOn;
GDISP.Backlight = 100;
GDISP.Contrast = 50;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
GDISP.clipx0 = 0;
GDISP.clipy0 = 0;
GDISP.clipx1 = GDISP.Width;
GDISP.clipy1 = GDISP.Height;
#endif
return TRUE;
}
LLDSPEC void gdisp_lld_control(GDisplay *g) {
switch(g->p.x) {
#if 0
case GDISP_CONTROL_POWER:
if (g->g.Powermode == (powermode_t)g->p.ptr)
return;
switch((powermode_t)g->p.ptr) {
case powerOff:
acquire_bus(g);
// TODO
release_bus(g);
break;
case powerOn:
acquire_bus(g);
// TODO
release_bus(g);
break;
case powerSleep:
acquire_bus(g);
// TODO
release_bus(g);
break;
default:
return;
}
g->g.Powermode = (powermode_t)g->p.ptr;
return;
#endif
#if 0
case GDISP_CONTROL_ORIENTATION:
if (g->g.Orientation == (orientation_t)g->p.ptr)
return;
switch((orientation_t)g->p.ptr) {
case GDISP_ROTATE_0:
acquire_bus(g);
// TODO
release_bus(g);
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH;
break;
case GDISP_ROTATE_90:
acquire_bus(g);
// TODO
release_bus(g);
g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT;
break;
case GDISP_ROTATE_180:
acquire_bus(g);
// TODO
release_bus(g);
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH;
break;
case GDISP_ROTATE_270:
acquire_bus(g);
// TODO
release_bus(g);
g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT;
break;
default:
return;
}
g->g.Orientation = (orientation_t)g->p.ptr;
return;
#endif
case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)g->p.ptr > 100)
g->p.ptr = (void *)100;
acquire_bus(g);
set_backlight(g, (unsigned)g->p.ptr);
release_bus(g);
g->g.Backlight = (unsigned)g->p.ptr;
return;
//case GDISP_CONTROL_CONTRAST:
default:
return;
}
}
LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
// No private area for this controller
g->priv = 0;
// Initialise the board interface
init_board(g);
// Hardware reset
setpin_reset(g, TRUE);
gfxSleepMilliseconds(20);
setpin_reset(g, FALSE);
gfxSleepMilliseconds(20);
// Get the bus for the following initialisation commands
acquire_bus(g);
write_cmd(g, SSD1327_MAST_CODE); //Master code
write_data(g, 0x00);
write_cmd(g, SSD1327_SET_SLEEP_ON); // set display off
write_cmd(g, SSD1327_SET_REMAP);
write_data(g, 0x52);
write_cmd(g, SSD1327_SET_DISPLAY_START);
write_data(g, 0x00);
write_cmd(g, SSD1327_SET_DISPLAY_OFFSET);
write_data(g, 0x20);
write_cmd(g, SSD1327_SET_DISPLAY_MODE_RESET);
write_cmd(g, SSD1327_SET_MUX_RATIO);
write_data(g, 0x5F);
write_cmd(g, SSD1327_SET_FUNCTION_SELECT);
write_data(g, 0x01);
write_cmd(g, SSD1327_SET_CONTRAST);
write_data(g, 0x5F);
write_cmd(g, SSD1327_USE_LINEAR_GREY);
write_cmd(g, SSD1327_SET_PHASE_LENGTH);
write_data(g, 0x31);
write_cmd(g, SSD1327_CLOCKDIV_OSCFREQ);
write_data(g, 0x41);
write_cmd(g, SSD1327_DISPLAY_ENHANCEMENT);
write_data(g, 0xB5);
write_cmd(g, SSD1327_SET_SECOND_PRECHARGE);
write_data(g, 0x04);
write_cmd(g, SSD1327_SET_PRECHARGE_VOLTAGE);
write_data(g, 0x05);
write_cmd(g, SSD1327_SET_VCOMH);
write_data(g, 0x07);
write_cmd(g, SSD1327_SET_FUNCTION_SELECT_B);
write_data(g, 0x02);
//i2c restart
write_cmd(g, SSD1327_MAST_CODE); //Master code
write_data(g, 0x00);
write_cmd(g, SSD1327_SET_COLUMN_ADDRESS); //Master code
write_data(g, 0x00); //COLUMN START
write_data(g, 0x3F); //COLUMN END
write_cmd(g, SSD1327_SET_ROW_ADDRESS); //Master code
write_data(g, 0x00); //ROW START
write_data(g, 0x7F); //ROW END
write_cmd(g, SSD1327_MAST_CODE); //Master code
write_data(g, 0x40);
uint16_t i = 0;
for (i = 0; i < 128*128; i++)
{
write_data(g, 0);
}
release_bus(g);
// Finish Init
post_init_board(g);
// Release the bus
// release_bus(g);
/* Turn on the back-light */
set_backlight(g, GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */
g->g.Width = GDISP_SCREEN_WIDTH;
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Orientation = GDISP_ROTATE_0;
g->g.Powermode = powerOn;
g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
g->g.Contrast = GDISP_INITIAL_CONTRAST;
return TRUE;
}
/**
* @brief Low level GDISP driver initialization.
*
* @notapi
*/
bool_t lld_gdisp_init(void) {
/* Initialise your display */
init_board();
// Hardware reset
setpin_reset(TRUE);
delayms(20);
setpin_reset(FALSE);
delayms(20);
// Get the bus for the following initialisation commands
acquire_bus();
write_reg(0x0000,0x0001); delay(5);
write_reg(0x0003,0xA8A4); delay(5);
write_reg(0x000C,0x0000); delay(5);
write_reg(0x000D,0x080C); delay(5);
write_reg(0x000E,0x2B00); delay(5);
write_reg(0x001E,0x00B0); delay(5);
write_reg(0x0001,0x2B3F); delay(5);
write_reg(0x0002,0x0600); delay(5);
write_reg(0x0010,0x0000); delay(5);
write_reg(0x0011,0x6070); delay(5);
write_reg(0x0005,0x0000); delay(5);
write_reg(0x0006,0x0000); delay(5);
write_reg(0x0016,0xEF1C); delay(5);
write_reg(0x0017,0x0003); delay(5);
write_reg(0x0007,0x0133); delay(5);
write_reg(0x000B,0x0000); delay(5);
write_reg(0x000F,0x0000); delay(5);
write_reg(0x0041,0x0000); delay(5);
write_reg(0x0042,0x0000); delay(5);
write_reg(0x0048,0x0000); delay(5);
write_reg(0x0049,0x013F); delay(5);
write_reg(0x004A,0x0000); delay(5);
write_reg(0x004B,0x0000); delay(5);
write_reg(0x0044,0xEF00); delay(5);
write_reg(0x0045,0x0000); delay(5);
write_reg(0x0046,0x013F); delay(5);
write_reg(0x0030,0x0707); delay(5);
write_reg(0x0031,0x0204); delay(5);
write_reg(0x0032,0x0204); delay(5);
write_reg(0x0033,0x0502); delay(5);
write_reg(0x0034,0x0507); delay(5);
write_reg(0x0035,0x0204); delay(5);
write_reg(0x0036,0x0204); delay(5);
write_reg(0x0037,0x0502); delay(5);
write_reg(0x003A,0x0302); delay(5);
write_reg(0x003B,0x0302); delay(5);
write_reg(0x0023,0x0000); delay(5);
write_reg(0x0024,0x0000); delay(5);
write_reg(0x0025,0x8000); delay(5);
write_reg(0x004f,0x0000); delay(5);
write_reg(0x004e,0x0000); delay(5);
// Release the bus
release_bus();
/* Turn on the back-light */
set_backlight(GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */
GDISP.Width = GDISP_SCREEN_WIDTH;
GDISP.Height = GDISP_SCREEN_HEIGHT;
GDISP.Orientation = GDISP_ROTATE_0;
GDISP.Powermode = powerOn;
GDISP.Backlight = GDISP_INITIAL_BACKLIGHT;
GDISP.Contrast = GDISP_INITIAL_CONTRAST;
#if GDISP_NEED_VALIDATION || GDISP_NEED_CLIP
GDISP.clipx0 = 0;
GDISP.clipy0 = 0;
GDISP.clipx1 = GDISP.Width;
GDISP.clipy1 = GDISP.Height;
#endif
return TRUE;
}
void _backlight_set_brightness(int brightness)
{
set_backlight(brightness);
}
LLDSPEC bool_t gdisp_lld_init(GDisplay *g) {
uint16_t cver;
// No private area for this controller
g->priv = 0;
// Initialise the board interface
init_board(g);
/* Hardware reset */
setpin_reset(g, TRUE);
gfxSleepMicroseconds(1000);
setpin_reset(g, FALSE);
gfxSleepMicroseconds(1000);
acquire_bus(g);
write_index(g, 0); // Get controller version
setreadmode(g);
dummy_read(g);
cver = read_data(g);
setwritemode(g);
/* initializing funciton */
write_reg(g, 0xe5,0x8000); /* Set the internal vcore voltage */
write_reg(g, 0x00,0x0001); /* start OSC */
write_reg(g, 0x2b,0x0010); /* Set the frame rate as 80 when the internal resistor is used for oscillator circuit */
write_reg(g, 0x01,0x0100); /* s720 to s1 ; G1 to G320 */
write_reg(g, 0x02,0x0700); /* set the line inversion */
write_reg(g, 0x03,0x1018); /* 65536 colors */
write_reg(g, 0x04,0x0000);
write_reg(g, 0x08,0x0202); /* specify the line number of front and back porch periods respectively */
write_reg(g, 0x09,0x0000);
write_reg(g, 0x0a,0x0000);
write_reg(g, 0x0c,0x0000); /* select internal system clock */
write_reg(g, 0x0d,0x0000);
write_reg(g, 0x0f,0x0000);
write_reg(g, 0x50,0x0000); /* set windows adress */
write_reg(g, 0x51,0x00ef);
write_reg(g, 0x52,0x0000);
write_reg(g, 0x53,0x013f);
write_reg(g, 0x60,0x2700);
write_reg(g, 0x61,0x0001);
write_reg(g, 0x6a,0x0000);
write_reg(g, 0x80,0x0000);
write_reg(g, 0x81,0x0000);
write_reg(g, 0x82,0x0000);
write_reg(g, 0x83,0x0000);
write_reg(g, 0x84,0x0000);
write_reg(g, 0x85,0x0000);
write_reg(g, 0x90,0x0010);
write_reg(g, 0x92,0x0000);
write_reg(g, 0x93,0x0003);
write_reg(g, 0x95,0x0110);
write_reg(g, 0x97,0x0000);
write_reg(g, 0x98,0x0000);
/* power setting function */
write_reg(g, 0x10,0x0000);
write_reg(g, 0x11,0x0000);
write_reg(g, 0x12,0x0000);
write_reg(g, 0x13,0x0000);
gfxSleepMicroseconds(100);
write_reg(g, 0x10,0x17b0);
write_reg(g, 0x11,0x0004);
gfxSleepMicroseconds(50);
write_reg(g, 0x12,0x013e);
gfxSleepMicroseconds(50);
write_reg(g, 0x13,0x1f00);
write_reg(g, 0x29,0x000f);
gfxSleepMicroseconds(50);
write_reg(g, 0x20,0x0000);
write_reg(g, 0x21,0x0000);
/* initializing function */
write_reg(g, 0x30,0x0204);
write_reg(g, 0x31,0x0001);
write_reg(g, 0x32,0x0000);
write_reg(g, 0x35,0x0206);
write_reg(g, 0x36,0x0600);
write_reg(g, 0x37,0x0500);
write_reg(g, 0x38,0x0505);
write_reg(g, 0x39,0x0407);
write_reg(g, 0x3c,0x0500);
write_reg(g, 0x3d,0x0503);
/* display on */
write_reg(g, 0x07,0x0173);
gfxSleepMicroseconds(50);
// Finish Init
post_init_board(g);
// Release the bus
release_bus(g);
// Turn on the backlight
set_backlight(g, GDISP_INITIAL_BACKLIGHT);
/* Initialise the GDISP structure */
g->g.Width = GDISP_SCREEN_WIDTH;
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Orientation = GDISP_ROTATE_0;
g->g.Powermode = powerOn;
g->g.Backlight = GDISP_INITIAL_BACKLIGHT;
g->g.Contrast = GDISP_INITIAL_CONTRAST;
return TRUE;
}
/* sets the brightness of the display backlight */
void tdisp_lld_set_backlight(uint16_t percentage) {
set_backlight(percentage);
}
LLDSPEC void gdisp_lld_control(GDisplay *g) {
switch(g->p.x) {
case GDISP_CONTROL_POWER:
if (g->g.Powermode == (powermode_t)g->p.ptr)
return;
switch((powermode_t)g->p.ptr) {
case powerOff:
acquire_bus(g);
write_reg(g, 0x07, 0x0000);
write_reg(g, 0x10, 0x0000);
write_reg(g, 0x11, 0x0000);
write_reg(g, 0x12, 0x0000);
write_reg(g, 0x13, 0x0000);
release_bus(g);
set_backlight(g, 0);
break;
case powerOn:
//*************Power On sequence ******************//
acquire_bus(g);
write_reg(g, 0x10, 0x0000); /* SAP, BT[3:0], AP, DSTB, SLP, STB */
write_reg(g, 0x11, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */
write_reg(g, 0x12, 0x0000); /* VREG1OUT voltage */
write_reg(g, 0x13, 0x0000); /* VDV[4:0] for VCOM amplitude */
gfxSleepMicroseconds(2000); /* Dis-charge capacitor power voltage */
write_reg(g, 0x10, 0x17B0); /* SAP, BT[3:0], AP, DSTB, SLP, STB */
write_reg(g, 0x11, 0x0147); /* DC1[2:0], DC0[2:0], VC[2:0] */
gfxSleepMicroseconds(500);
write_reg(g, 0x12, 0x013C); /* VREG1OUT voltage */
gfxSleepMicroseconds(500);
write_reg(g, 0x13, 0x0E00); /* VDV[4:0] for VCOM amplitude */
write_reg(g, 0x29, 0x0009); /* VCM[4:0] for VCOMH */
gfxSleepMicroseconds(500);
write_reg(g, 0x07, 0x0173); /* 262K color and display ON */
release_bus(g);
set_backlight(g, g->g.Backlight);
break;
case powerSleep:
acquire_bus(g);
write_reg(g, 0x07, 0x0000); /* display OFF */
write_reg(g, 0x10, 0x0000); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
write_reg(g, 0x11, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */
write_reg(g, 0x12, 0x0000); /* VREG1OUT voltage */
write_reg(g, 0x13, 0x0000); /* VDV[4:0] for VCOM amplitude */
gfxSleepMicroseconds(2000); /* Dis-charge capacitor power voltage */
write_reg(g, 0x10, 0x0002); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
release_bus(g);
set_backlight(g, 0);
break;
case powerDeepSleep:
acquire_bus(g);
write_reg(g, 0x07, 0x0000); /* display OFF */
write_reg(g, 0x10, 0x0000); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
write_reg(g, 0x11, 0x0000); /* DC1[2:0], DC0[2:0], VC[2:0] */
write_reg(g, 0x12, 0x0000); /* VREG1OUT voltage */
write_reg(g, 0x13, 0x0000); /* VDV[4:0] for VCOM amplitude */
gfxSleepMicroseconds(2000); /* Dis-charge capacitor power voltage */
write_reg(g, 0x10, 0x0004); /* SAP, BT[3:0], APE, AP, DSTB, SLP */
release_bus(g);
set_backlight(g, 0);
break;
default:
return;
}
g->g.Powermode = (powermode_t)g->p.ptr;
return;
case GDISP_CONTROL_ORIENTATION:
if (g->g.Orientation == (orientation_t)g->p.ptr)
return;
switch((orientation_t)g->p.ptr) {
case GDISP_ROTATE_0:
acquire_bus(g);
write_reg(g, 0x01, 0x0100);
write_reg(g, 0x03, 0x1038);
write_reg(g, 0x60, 0x2700);
release_bus(g);
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH;
break;
case GDISP_ROTATE_90:
acquire_bus(g);
write_reg(g, 0x01, 0x0000);
write_reg(g, 0x03, 0x1030);
write_reg(g, 0x60, 0x2700);
release_bus(g);
g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT;
break;
case GDISP_ROTATE_180:
acquire_bus(g);
write_reg(g, 0x01, 0x0000);
write_reg(g, 0x03, 0x1030);
write_reg(g, 0x60, 0x2700);
release_bus(g);
g->g.Height = GDISP_SCREEN_HEIGHT;
g->g.Width = GDISP_SCREEN_WIDTH;
break;
case GDISP_ROTATE_270:
acquire_bus(g);
write_reg(g, 0x01, 0x0100);
write_reg(g, 0x03, 0x1038);
write_reg(g, 0x60, 0xA700);
release_bus(g);
g->g.Height = GDISP_SCREEN_WIDTH;
g->g.Width = GDISP_SCREEN_HEIGHT;
break;
default:
return;
}
g->g.Orientation = (orientation_t)g->p.ptr;
return;
case GDISP_CONTROL_BACKLIGHT:
if ((unsigned)g->p.ptr > 100)
g->p.ptr = (void *)100;
set_backlight(g, (unsigned)g->p.ptr);
g->g.Backlight = (unsigned)g->p.ptr;
return;
default:
return;
}
}
