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; } }