/*****************************************************
* Function: btn_IntHandler
* Description: Interrupt handler for button press
* Handles mode switching on release
* Hold for 2 seconds -> Override mode
* Input:
* Output:
*****************************************************/
void btn_IntHandler(void)
{
// Clear interrupt
GPIOIntClear(BTN_OVERRIDE_REG, BTN_OVERRIDE);
// Get current button status
ButtonStatus buttonStatus = GPIOPinRead(BTN_OVERRIDE_REG, BTN_OVERRIDE);
// If button is current pressed
if(buttonStatus == BUTTON_PRESSED)
{
hasSeenButtonPress = true; // Flag that we saw a button press
TimerEnable(BTN_OVERRIDE_TIM_BASE, BTN_OVERRIDE_TIM); // Start timer to count how long button is pressed
GPIOPinWrite(LED_REG, LED_BLUE_PIN, LED_BLUE_PIN); // Turn on LED to signal button press
}
// If button is not pressed and we have seen a button press
else if (buttonStatus == BUTTON_RELEASED && hasSeenButtonPress)
{
hasSeenButtonPress = false; // Clear button press flag
TimerDisable(BTN_OVERRIDE_TIM_BASE, BTN_OVERRIDE_TIM); // Disable timer counting button press
GPIOPinWrite(LED_REG, LED_BLUE_PIN, LED_ALL_OFF); // Turn off LED signaling button release
uint32_t elapsedTime = buttonPressTimerTicks / 1000; // Calculate time button was held
buttonPressTimerTicks = 0; // Clear counter
// OVERRIDE - 2 second press
if((elapsedTime) > 1 && (elapsedTime) < 3)
{
switch(mode)
{
case RUN:
mode = OVERRIDE; // If we are in the run state, set to override
flashLED(LED_RED_PIN);
oneSecondCounter = 0; // Clear the 24 hour counter
break;
case OVERRIDE:
mode = RUN; // If we are in the override state, clear the override
clearAllZoneOverrides(); // Clear the zone overrides
flashLED(LED_GREEN_PIN);
break;
default:
// If we are in another state ignore the button press
break;
}
}
}
}
static ssize_t AOTOMdev_read(struct file *filp, char __user *buff, size_t len, loff_t *off)
{
dprintk(5, "%s > (len %d, offs %d)\n", __func__, len, (int) *off);
if (((tFrontPanelOpen*)(filp->private_data))->minor == FRONTPANEL_MINOR_RC)
{
while (receiveCount == 0)
{
if (wait_event_interruptible(wq, receiveCount > 0))
return -ERESTARTSYS;
}
flashLED(LED_GREEN, 100);
/* 0. claim semaphore */
if (down_interruptible(&receive_sem))
return -ERESTARTSYS;
/* 1. copy data to user */
copy_to_user(buff, receive[0].buffer, receive[0].len);
/* 2. copy all entries to start and decrease receiveCount */
receiveCount--;
memmove(&receive[0], &receive[1], (cMaxReceiveQueue - 1) * sizeof(struct receive_s));
/* 3. free semaphore */
up(&receive_sem);
return receive[0].len;
}
return -EOPNOTSUPP;
}
void ButtonMachine::setSignature()
{
int res;
// grow region, create model, save
res = cc_setSigPoint(0, m_index, CAM_RES2_WIDTH/2, CAM_RES2_HEIGHT/2);
if (res<0)
return;
exec_sendEvent(g_chirpUsb, EVT_PARAM_CHANGE);
flashLED(4);
}
void sendSignal(void){
W_buffer[0]=sensorID;
W_buffer[1]=piezoValue;
W_buffer[2]=potValue;
transmit_payload(W_buffer);
reset();
flashLED();
//USARTPrint();
}
static void button_bad_polling(struct work_struct *work)
{
int btn_pressed = 0;
int report_key = 0;
while(bad_polling == 1)
{
int button_value;
msleep(50);
button_value = AOTOMfp_Get_Key_Value();
if (button_value != INVALID_KEY) {
dprintk(5, "got button: %X\n", button_value);
flashLED(LED_GREEN, 100);
//VFD_Show_Ico(DOT2,LOG_ON);
//YWPANEL_VFD_SetLed(1, LOG_ON);
if (1 == btn_pressed) {
if (report_key == button_value)
continue;
input_report_key(button_dev, report_key, 0);
input_sync(button_dev);
}
report_key = button_value;
btn_pressed = 1;
switch(button_value) {
case KEY_LEFT:
case KEY_RIGHT:
case KEY_UP:
case KEY_DOWN:
case KEY_OK:
case KEY_MENU:
case KEY_EXIT:
case KEY_POWER:
input_report_key(button_dev, button_value, 1);
input_sync(button_dev);
break;
default:
dprintk(5, "[BTN] unknown button_value %d\n", button_value);
}
}
else {
if(btn_pressed) {
btn_pressed = 0;
//msleep(80);
//VFD_Show_Ico(DOT2,LOG_OFF);
//YWPANEL_VFD_SetLed(1, LOG_OFF);
input_report_key(button_dev, report_key, 0);
input_sync(button_dev);
}
}
}
bad_polling = 2;
}
static int symbol_circle_write(struct file *file, const char __user *buf, unsigned long count, void *data)
{
char* page;
ssize_t ret = -ENOMEM;
char* myString;
page = (char*)__get_free_page(GFP_KERNEL);
if (page)
{
ret = -EFAULT;
if (copy_from_user(page, buf, count))
{
goto out;
}
myString = (char*) kmalloc(count + 1, GFP_KERNEL);
strncpy(myString, page, count);
myString[count - 1] = '\0';
sscanf(myString, "%d", &symbol_circle);
kfree(myString);
if (fp_type == FP_VFD) //VFD display
{
if (symbol_circle > 255)
{
symbol_circle = 255;
}
led_state[LED_SPINNER].state = ((symbol_circle < 1) ? 0 : 1);
if (symbol_circle != 0)
{
flashLED(LED_SPINNER, symbol_circle); // start spinner thread
// aotomSetIcon(ICON_SPINNER, symbol_circle);
}
}
if (ret >= 0)
{
ret = count;
}
/* always return count to avoid endless loop */
ret = count;
}
out:
free_page((unsigned long)page);
return ret;
}
void ButtonMachine::setSignature()
{
uint32_t current, saveCurrent;
int goodness;
// grow region, create model, save
goodness = cc_setSigPoint(0, m_index, CAM_RES2_WIDTH/2, CAM_RES2_HEIGHT/2, g_chirpUsb);
if (goodness>0)
{
cprintf("goodness=%d\n", goodness);
saveCurrent = led_getMaxCurrent(); // save off value
current = (float)LED_MAX_CURRENT/100.0f*goodness;
led_setMaxCurrent(current);
flashLED(4);
led_setMaxCurrent(saveCurrent);
}
}
int main(void)
{
initSPI();
initNRF24L01();
//initUSART();
//Init LEDs and flash once to show script running
LED_DDR|=(1 << LED_RED)|(1 << LED_GREEN); // set LED pins for output
LED_DDR2|=(1 << LED_BLUE); // set blue LED pin for output
flashLED(); //Flash to show initiated
initADC();
ADCSRA |= (1<<ADSC); // Start conversion - didn't do earlier as not all bits set
//Reduce power
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
//Sleep modes
set_sleep_mode(SLEEP_MODE_ADC);
sleep_enable();
sleep_bod_disable();
sleep_cpu();
sleep_mode();
//Power down nrf24
// Mainloop - use asm to stop empty infinite loop being optimised out.
while(1)
{
asm("");
}
return 0;
}
void initUART(unsigned long baudrate)
{
//setBaudRate(baudrate);
//writeRegister(0x03, 0xBF); // access EFR register
//writeRegister(0x02, 0xD0); // enable enhanced registers
//writeRegister(0x03, 0x07); // 8 data bit, 2 stop bit, no parity
//writeRegister(0x02, 0x06); // reset TXFIFO, reset RXFIFO, non FIFO mode
//writeRegister(0x02, 0x01); // enable FIFO mode
//if(!uartConnected()) {SET_BIT(PORTB, 1); while(1);}
//Line Control Register: Enable Writing DLH & DLL
//& set no Parity, 2 stop bit, and 8 bit word length
writeRegister(LCR,0x83);
//Division registers DLL & DLH
// Write '96' to get 9600 baud rate
//Assumes you have the version with the ~14MHz crystal
// (16x9600 = 153600 = 14.7456Mhz/96)
// (16x38400 = 614400 = 14.7456Mhz/24)
// (16x115200 = 1843200 = 14.7456Mhz/8)
writeRegister(DLL,baudrate);
writeRegister(DLH,0x00);
//Line Control Register: Disnable Writing DLH & DLL
//Same setup
writeRegister(LCR,0x03);
//Modem Control Register
//Normal Operating Mode
writeRegister(MCR,0x00);
//FIFO Control Register: Enable the FIFO and no other features
writeRegister(FCR,0x07);
if (!uartConnected()) flashLED(RED);
}
bool ButtonMachine::selectProgram(uint8_t progs, uint8_t *selectedProg)
{
uint32_t bt;
if (progs<=1)
return 0;
while(1)
{
bt = button();
periodic();
switch(m_goto)
{
case 0: // wait for nothing
setTimer(&m_timer);
m_goto = 1;
setLED();
break;
case 1: // wait for button down
if (bt)
{
setTimer(&m_timer);
m_index=0;
setLED();
m_goto = 2;
}
else if (getTimer(m_timer)>BT_PROG_TIMEOUT)
{
m_index = *selectedProg;
flashLED(4);
reset();
return false;
}
break;
case 2: // cycle through choices, wait for button up
if (!bt)
{
*selectedProg = m_index; // save m_index
flashLED(4);
reset(); // resets m_index
return true;
}
else if (getTimer(m_timer)>BT_INDEX_CYCLE_TIMEOUT)
{
setTimer(&m_timer);
m_index++;
if (m_index==progs)
m_index = 0;
setLED();
}
break;
default:
reset();
}
}
}
bool ButtonMachine::handleSignature()
{
uint32_t bt;
bt = button();
if (m_ledPipe) // if ledpipe, grab frame, but don't flush
{
cam_getFrameChirpFlags(CAM_GRAB_M1R2, 0, 0, CAM_RES2_WIDTH, CAM_RES2_HEIGHT, g_chirpUsb, 0);
ledPipe();
}
else if (m_goto!=0) // else grab frame and flush
cam_getFrameChirpFlags(CAM_GRAB_M1R2, 0, 0, CAM_RES2_WIDTH, CAM_RES2_HEIGHT, g_chirpUsb);
switch(m_goto)
{
case 0: // wait for button press
if (bt)
{
setTimer(&m_timer);
led_setMaxCurrent(g_ledBrightness); // restore default brightness
m_goto = 1;
led_set(0);
}
break;
case 1: // wait for button timeout
if (!bt)
m_goto = 0;
else if (getTimer(m_timer)>BT_INITIAL_BUTTON_TIMEOUT)
{
if (cam_getAWB())
m_index = 1;
else
m_index = 0;
setTimer(&m_timer);
setLED();
m_goto = 2;
}
break;
case 2: // wait and increment index
if (!bt)
{
flashLED(3);
setTimer(&m_timer);
if (m_index==0)
cam_setAWB(1);
else
m_ledPipe = true;
m_goto = 3;
}
else if (getTimer(m_timer)>BT_INDEX_CYCLE_TIMEOUT)
{
setTimer(&m_timer);
m_index++;
if (m_index==CL_NUM_SIGNATURES+1)
m_index = 0;
setLED();
}
break;
case 3: // wait for button down
if (bt)
{
setTimer(&m_timer);
m_goto = 4;
}
else if (getTimer(m_timer)>BT_LIGHTPIPE_TIMEOUT) // abort
reset();
break;
case 4: // wait for button up
if (!bt)
{
if (m_index==0)
{
cam_setAWB(0);
flashLED(4);
}
else
setSignature();
reset(); // done
}
else if (getTimer(m_timer)>BT_INITIAL_BUTTON_TIMEOUT)
{
if (m_index==0)
cam_setAWB(0);
reset();
m_goto = 5;
}
break;
case 5: // wait for button up only
if (!bt)
reset();
break;
default:
reset();
}
return m_goto!=0;
}
static int AOTOMdev_ioctl(struct inode *Inode, struct file *File, unsigned int cmd, unsigned long arg)
{
static int mode = 0;
int res = -EINVAL;
dprintk(5, "%s > 0x%.8x\n", __func__, cmd);
if(down_interruptible (&write_sem))
return -ERESTARTSYS;
switch(cmd) {
case VFDSETMODE:
case VFDSETLED:
case VFDICONDISPLAYONOFF:
case VFDSETTIME:
case VFDBRIGHTNESS:
case VFDGETSTBYKEY:
case VFDSETSTBYKEY:
case VFDGETBLUEKEY:
case VFDSETBLUEKEY:
if (copy_from_user(&aotom_data, (void *) arg, sizeof(aotom_data)))
return -EFAULT;
}
switch(cmd) {
case VFDSETMODE:
mode = aotom_data.u.mode.compat;
break;
case VFDSETLED:
if (aotom_data.u.led.led_nr > -1 && aotom_data.u.led.led_nr < LED_MAX) {
switch (aotom_data.u.led.on) {
case LOG_OFF:
case LOG_ON:
res = YWPANEL_VFD_SetLed(aotom_data.u.led.led_nr, aotom_data.u.led.on);
led_state[aotom_data.u.led.led_nr].state = aotom_data.u.led.on;
break;
default: // toggle for aotom_data.u.led.on * 10 ms
flashLED(aotom_data.u.led.led_nr, aotom_data.u.led.on * 10);
res = 0;
}
}
break;
case VFDBRIGHTNESS:
if (aotom_data.u.brightness.level < 0)
aotom_data.u.brightness.level = 0;
else if (aotom_data.u.brightness.level > 7)
aotom_data.u.brightness.level = 7;
res = YWPANEL_VFD_SetBrightness(aotom_data.u.brightness.level);
break;
case VFDICONDISPLAYONOFF:
switch (panel_version.DisplayInfo) {
case YWPANEL_FP_DISPTYPE_LED:
switch (aotom_data.u.icon.icon_nr) {
case 0:
res = YWPANEL_VFD_SetLed(LED_RED, aotom_data.u.icon.on);
led_state[LED_RED].state = aotom_data.u.icon.on;
break;
case 35:
res = YWPANEL_VFD_SetLed(LED_GREEN, aotom_data.u.icon.on);
led_state[LED_GREEN].state = aotom_data.u.icon.on;
break;
case 46:
led_state[LED_RED].state = aotom_data.u.icon.on;
led_state[LED_GREEN].state = aotom_data.u.icon.on;
YWPANEL_VFD_SetLed(LED_RED, aotom_data.u.icon.on);
res = YWPANEL_VFD_SetLed(LED_GREEN, aotom_data.u.icon.on);
break;
}
break;
default:
{
int icon_nr = aotom_data.u.icon.icon_nr;
if(icon_nr & ~0xff)
{
icon_nr >>= 8;
switch (icon_nr)
{
case 0x11:
icon_nr = 0x0E; //widescreen
break;
case 0x13:
icon_nr = 0x0B; //CA
break;
case 0x15:
icon_nr = 0x19; //mp3
break;
case 0x17:
icon_nr = 0x1A; //ac3
break;
case 0x1A:
icon_nr = 0x03; //play
break;
case 0x1e:
icon_nr = 0x07; //record
break;
case 38:
break; //cd part1
case 39:
break; //cd part2
case 40:
break; //cd part3
case 41:
break; //cd part4
default:
icon_nr = -1; //no additional symbols at the moment
break;
}
}
switch (icon_nr)
{
case 46:
VFD_set_all_icons(aotom_data.u.icon.on);
res = 0;
case -1:
break;
default:
res = aotomSetIcon(icon_nr, aotom_data.u.icon.on);
}
}
mode = 0;
break;
}
break;
case VFDSETPOWERONTIME:
{
u32 uTime = 0;
get_user(uTime, (int *) arg);
YWPANEL_FP_SetPowerOnTime(uTime);
res = 0;
break;
}
case VFDPOWEROFF:
clear_display();
YWPANEL_FP_ControlTimer(true);
YWPANEL_FP_SetCpuStatus(YWPANEL_CPUSTATE_STANDBY);
res = 0;
break;
case VFDSTANDBY:
{
u32 uTime = 0;
get_user(uTime, (int *) arg);
YWPANEL_FP_SetPowerOnTime(uTime);
clear_display();
YWPANEL_FP_ControlTimer(true);
YWPANEL_FP_SetCpuStatus(YWPANEL_CPUSTATE_STANDBY);
res = 0;
break;
}
case VFDSETTIME2:
{
u32 uTime = 0;
res = get_user(uTime, (int *)arg);
if (! res)
{
res = YWPANEL_FP_SetTime(uTime);
YWPANEL_FP_ControlTimer(true);
}
break;
}
case VFDSETTIME:
res = aotomSetTime(aotom_data.u.time.time);
break;
case VFDGETTIME:
{
u32 uTime = 0;
uTime = YWPANEL_FP_GetTime();
//printk("uTime = %d\n", uTime);
res = put_user(uTime, (int *) arg);
break;
}
case VFDDISPLAYCHARS:
if (mode == 0)
{
if (copy_from_user(&vfd_data, (void *) arg, sizeof(vfd_data)))
return -EFAULT;
if (vfd_data.length > sizeof(vfd_data.data))
vfd_data.length = sizeof(vfd_data.data);
while ((vfd_data.length > 0) && (vfd_data.data[vfd_data.length - 1 ] == '\n'))
vfd_data.length--;
res = run_draw_thread(&vfd_data);
} else
mode = 0;
break;
case VFDDISPLAYCLR:
vfd_data.length = 0;
res = run_draw_thread(&vfd_data);
break;
case VFDGETWAKEUPMODE:
case VFDDISPLAYWRITEONOFF:
res = 0;
break;
case VFDGETSTARTUPSTATE:
{
YWPANEL_STARTUPSTATE_t State;
if (YWPANEL_FP_GetStartUpState(&State))
res = put_user(State, (int *) arg);
break;
}
case VFDSETLOOPSTATE:
{
YWPANEL_LOOPSTATE_t State = YWPANEL_LOOPSTATE_UNKNOWN;
res = get_user(State, (int *)arg);
if (!res)
res = YWPANEL_FP_SetLoopState(State);
break;
}
case VFDGETLOOPSTATE:
{
YWPANEL_LOOPSTATE_t State;
if (YWPANEL_FP_GetLoopState(&State))
res = put_user(State, (int *) arg);
break;
}
case VFDGETVERSION:
{
YWPANEL_Version_t panel_version;
memset(&panel_version, 0, sizeof(YWPANEL_Version_t));
if (YWPANEL_FP_GetVersion(&panel_version))
res = put_user (panel_version.DisplayInfo, (int *)arg);
break;
}
case VFDGETBLUEKEY:
case VFDGETSTBYKEY:
{
if (YWPANEL_FP_GetKey(cmd == VFDGETBLUEKEY, aotom_data.u.key.key_nr, &aotom_data.u.key.key))
res = copy_to_user((void *) arg, &aotom_data, sizeof(aotom_data));
break;
}
case VFDSETBLUEKEY:
case VFDSETSTBYKEY:
res = !YWPANEL_FP_SetKey(cmd == VFDSETBLUEKEY, aotom_data.u.key.key_nr, aotom_data.u.key.key);
break;
default:
printk("VFD/AOTOM: unknown IOCTL 0x%x\n", cmd);
case 0x5305:
case 0x5401:
mode = 0;
break;
}
int main(void){
int setup = 0;
int result;
char str[100],str0[50],str1[50];
char tmp[100];
int i, n=0;
int pos = NOT_FOUND;
unsigned int maxMillis=1000;
int tx=0;
a=1;
b=1;
p_a=0;
p_b=0;
num=0;num2=0;
strcpy(path,home);
strcat(path,scripts);
setup = wiringPiSetup();
pinMode(rRED,OUTPUT);
pinMode(rGREEN,OUTPUT);
pinMode(rSW,INPUT);
/* read main menu */
printf("Main menu:%s\n",Mname);
Mmax=read_file(Mname, Mbuf);
/* read level menu */
Lmax=read_file(Lname, Lbuf);
/* read date&time menu */
Dmax=read_file(Dname, Dbuf);
/* Get current menu item */
/* char *menu_name, *file_name, *freq, *s_rate */
strcpy(tmp,Mbuf[num]);
menu_name=strtok(tmp,",");
file_name=strtok(NULL,",");
freq=strtok(NULL,",");
s_rate=strtok(NULL,",");
date_time="2016/04/15,00:00:00";
printf("%s %s %s %s %s\n",menu_name,file_name,freq,s_rate,date_time);
/* menue Line1 */
strcpy(str,cmd);
strcat(str, menu_name);
printf("%s",menu_name);
system(str); // Display 1st line //
/* menue Line 2 */
strcpy(str,cmd2);
strcat(str,Lbuf[num2]);
system(str); // Display 2nd line //
/* indicate boot finish */
flashLED(rRED,2);
flashLED(rGREEN,2);
pullUpDnControl(rSW, PUD_UP);
pullUpDnControl(rA, PUD_UP);
pullUpDnControl(rB, PUD_UP);
wiringPiISR(rA, INT_EDGE_BOTH, click_a);
wiringPiISR(rB, INT_EDGE_BOTH, click_b);
while(setup != -1){
usleep(10000);
if(digitalRead(rSW)==0) { // Push SW pressed
// printf("[%s %s %s %s %s]\n",menu_name,file_name,freq,s_rate,date_time);
// printf("SW_level_stat:%d\n",SW_level_stat);
n = 0;
digitalWrite(rGREEN,1); // light GREEN LED
switch (SW_level_stat){
case 1: // Level setting
SW_level_stat=0;
num=last_tx;
proc(0);
break;
case 2: // Level setting
SW_level_stat=0;
num=last_tx;
proc(0);
break;
case 0: // Main menu selection
switch (num){
case 0: // Power level setting
SW_level_stat=1;
// proc(0);
break;
case 1: // Date&Time setteing
SW_level_stat=2;
// proc(0);
break;
case 2: // Fixed Latitude & Longtude setting
break;
default:
;
}
proc(0);
strcpy(str,file_name);
for(i=0;i<100;i++){
str[i]=0x00;
}
if(atoi(s_rate) !=0){ // sample
strcpy(str,path);
if(strpos(file_name,".txt")>0 || strpos(file_name,".csv")>0){
strcat(str,"sim_start.sh ");// generate rela-time I/Q data
} else {
strcat(str,"transmit2.sh "); // Use pre-generated I/Q data
// Trim(str);
// strcat(str,file_name); // Replay file name
}
Trim(str); strcat(str,file_name); // Replay file name
Trim(str); strcat(str," ");
strcpy(str1,Lbuf[num2]); // Replay POWER
Trim(str1);
strcat(str,str1); // transmit2.sh file_name POWER
strcat(str," "); strcat(str,freq);
strcat(str," ");
Trim(s_rate); strcat(str,s_rate);
strcat(str," ");strcat(str,Dbuf[num3]);
strcat(str,"&"); // transmit2.sh file_name POWER&
Trim(str); last_tx=num;
// printf("\n[Tx shell cmd:%s]\n",str);
system(str); // 実行
} else {
system(file_name); // 単純なshell実行
}
break;
}
while (digitalRead(rSW)==0) { // Waite until SW pressed
usleep(1000);
n++;
if ( n > SW_long ) digitalWrite(rRED,1);
}
usleep(200000); // Avoid chattering
} else {
digitalWrite(rGREEN,0); // Now SW released, put off LED
}
if (n > SW_long ){ // KILL process when SW pushed long duration
if(SW_level_stat==0){
system("/home/pi/kill_proc.sh");
digitalWrite(rRED,1);
usleep(500000);
digitalWrite(rRED,0);
n=0;
} else {
SW_level_stat=0;
proc(0);
}
}
now = millis();
if(( now - prev ) > 1000){ // LED update while Tx working
tx=tx_blink(tx);
prev = now;
}
}
}
static int AOTOMdev_ioctl(struct inode *Inode, struct file *File, unsigned int cmd, unsigned long arg)
{
int icon_nr = 0;
static int mode = 0;
int res = -EINVAL;
dprintk(5, "%s > 0x%.8x\n", __func__, cmd);
if(down_interruptible (&write_sem))
return -ERESTARTSYS;
switch(cmd) {
case VFDSETMODE:
case VFDSETLED:
case VFDICONDISPLAYONOFF:
case VFDSETTIME:
case VFDBRIGHTNESS:
if (copy_from_user(&aotom_data, (void *) arg, sizeof(aotom_data)))
return -EFAULT;
}
switch(cmd) {
case VFDSETMODE:
mode = aotom_data.u.mode.compat;
break;
case VFDSETLED:
#if defined(SPARK) || defined(SPARK7162)
if (aotom_data.u.led.led_nr > -1 && aotom_data.u.led.led_nr < LED_MAX) {
switch (aotom_data.u.led.on) {
case LOG_OFF:
case LOG_ON:
res = YWPANEL_VFD_SetLed(aotom_data.u.led.led_nr, aotom_data.u.led.on);
led_state[aotom_data.u.led.led_nr].state = aotom_data.u.led.on;
break;
default: // toggle (for aotom_data.u.led.on * 10) ms
flashLED(aotom_data.u.led.led_nr, aotom_data.u.led.on * 10);
}
}
#endif
break;
case VFDBRIGHTNESS:
if (aotom_data.u.brightness.level < 0)
aotom_data.u.brightness.level = 0;
else if (aotom_data.u.brightness.level > 7)
aotom_data.u.brightness.level = 7;
res = YWPANEL_VFD_SetBrightness(aotom_data.u.brightness.level);
break;
case VFDICONDISPLAYONOFF:
{
#if defined(SPARK)
switch (aotom_data.u.icon.icon_nr) {
case 0:
res = YWPANEL_VFD_SetLed(LED_RED, aotom_data.u.icon.on);
led_state[LED_RED].state = aotom_data.u.icon.on;
break;
case 35:
res = YWPANEL_VFD_SetLed(LED_GREEN, aotom_data.u.icon.on);
led_state[LED_GREEN].state = aotom_data.u.icon.on;
break;
default:
break;
}
#endif
#if defined(SPARK7162)
icon_nr = aotom_data.u.icon.icon_nr;
//e2 icons workarround
//printk("icon_nr = %d\n", icon_nr);
if (icon_nr >= 256) {
icon_nr = icon_nr / 256;
switch (icon_nr) {
case 0x11:
icon_nr = 0x0E; //widescreen
break;
case 0x13:
icon_nr = 0x0B; //CA
break;
case 0x15:
icon_nr = 0x19; //mp3
break;
case 0x17:
icon_nr = 0x1A; //ac3
break;
case 0x1A:
icon_nr = 0x03; //play
break;
case 0x1e:
icon_nr = 0x07; //record
break;
case 38:
break; //cd part1
case 39:
break; //cd part2
case 40:
break; //cd part3
case 41:
break; //cd part4
default:
icon_nr = 0; //no additional symbols at the moment
break;
}
}
if (aotom_data.u.icon.on != 0)
aotom_data.u.icon.on = 1;
if (icon_nr > 0 && icon_nr <= 45 )
res = aotomSetIcon(icon_nr, aotom_data.u.icon.on);
if (icon_nr == 46){
switch (aotom_data.u.icon.on){
case 1:
VFD_set_all_icons();
res = 0;
break;
case 0:
VFD_clear_all_icons();
res = 0;
break;
default:
break;
}
}
#endif
mode = 0;
break;
}
case VFDSTANDBY:
{
#if defined(SPARK) || defined(SPARK7162)
u32 uTime = 0;
get_user(uTime, (int *) arg);
YWPANEL_FP_SetPowerOnTime(uTime);
clear_display();
YWPANEL_FP_ControlTimer(true);
YWPANEL_FP_SetCpuStatus(YWPANEL_CPUSTATE_STANDBY);
res = 0;
#endif
break;
}
case VFDSETTIME2:
{
u32 uTime = 0;
res = get_user(uTime, (int *)arg);
if (! res)
{
res = YWPANEL_FP_SetTime(uTime);
YWPANEL_FP_ControlTimer(true);
}
break;
}
case VFDSETTIME:
res = aotomSetTime(aotom_data.u.time.time);
break;
case VFDGETTIME:
{
#if defined(SPARK) || defined(SPARK7162)
u32 uTime = 0;
uTime = YWPANEL_FP_GetTime();
//printk("uTime = %d\n", uTime);
res = put_user(uTime, (int *) arg);
#endif
break;
}
case VFDGETWAKEUPMODE:
break;
case VFDDISPLAYCHARS:
if (mode == 0)
{
if (copy_from_user(&vfd_data, (void *) arg, sizeof(vfd_data)))
return -EFAULT;
if (vfd_data.length > sizeof(vfd_data.data))
vfd_data.length = sizeof(vfd_data.data);
while ((vfd_data.length > 0) && (vfd_data.data[vfd_data.length - 1 ] == '\n'))
vfd_data.length--;
res = run_draw_thread(&vfd_data);
} else
mode = 0;
break;
case VFDDISPLAYWRITEONOFF:
break;
case VFDDISPLAYCLR:
vfd_data.length = 0;
res = run_draw_thread(&vfd_data);
break;
#if defined(SPARK)
case 0x5305:
res = 0;
break;
#endif
case 0x5401:
res = 0;
break;
case VFDGETSTARTUPSTATE:
{
YWPANEL_STARTUPSTATE_t State;
if (YWPANEL_FP_GetStartUpState(&State))
res = put_user(State, (int *) arg);
break;
}
case VFDGETVERSION:
{
YWPANEL_Version_t panel_version;
memset(&panel_version, 0, sizeof(YWPANEL_Version_t));
if (YWPANEL_FP_GetVersion(&panel_version))
res = put_user (panel_version.DisplayInfo, (int *)arg);
break;
}
default:
printk("VFD/AOTOM: unknown IOCTL 0x%x\n", cmd);
mode = 0;
break;
}
up(&write_sem);
dprintk(5, "%s <\n", __func__);
return res;
}
static int progress_write(struct file *file, const char __user *buf, unsigned long count, void *data)
{
char* page;
ssize_t ret = -ENOMEM;
char* myString;
page = (char*)__get_free_page(GFP_KERNEL);
if (page)
{
ret = -EFAULT;
if (copy_from_user(page, buf, count))
{
goto out;
}
myString = (char*) kmalloc(count + 1, GFP_KERNEL);
strncpy(myString, page, count);
myString[count - 1] = '\0';
sscanf(myString, "%d", &progress);
kfree(myString);
#if 0
if (progress > 98 && progress_done == 0)
{
progress_done = 1;
clear_display();
if (fp_type == FP_VFD) //VFD display
{
led_state[LED_SPINNER].state = 0;
// aotomSetIcon(ICON_SPINNER, 0);
}
ret = YWPANEL_width;
goto out;
}
if (progress_done == 0 && fp_type == FP_VFD && led_state[LED_SPINNER].state == 0) //VFD display
{
led_state[LED_SPINNER].state = 1;
flashLED(LED_SPINNER, 200); // start spinner thread
// aotomSetIcon(ICON_SPINNER, 1);
}
if (progress > 19 && progress < 99 && progress_done == 0)
{
if (fp_type == FP_LED) //LED display
{
ret = aotomWriteText(page, count);
}
else
{
myString = (char*)kmalloc(count + ((fp_type == FP_VFD) ? 6 : 8), GFP_KERNEL);
if (myString)
{
if (fp_type == FP_VFD) //VFD display
{
strcpy(myString, "Start ");
strncat(myString, page, count);
ret = aotomWriteText(myString, (count + 6) < 8 ? (count + 6) : 8);
}
else
{
strcpy(myString, "Start: ");
strncat(myString, page, count - 2);
strcat(myString, "%");
ret = aotomWriteText(myString, (count + 8) < 10 ? (count + 8) : 10);
}
kfree(myString);
}
}
}
// else
// {
// clear_display();
// ret = YWPANEL_width;
// }
if (ret >= 0)
{
ret = count;
}
#else
/* always return count to avoid endless loop */
ret = count;
#endif
}
out:
free_page((unsigned long)page);
return ret;
}
