int USBSerial::_getc()
{
if (!attached)
return 0;
uint8_t c = 0;
setled(4, 1); while (rxbuf.isEmpty()); setled(4, 0);
rxbuf.dequeue(&c);
if (rxbuf.free() == MAX_PACKET_SIZE_EPBULK)
{
usb->endpointSetInterrupt(CDC_BulkOut.bEndpointAddress, true);
iprintf("rxbuf has room for another packet, interrupt enabled\n");
}
else if ((rxbuf.free() < MAX_PACKET_SIZE_EPBULK) && (nl_in_rx == 0))
{
// handle potential deadlock where a short line, and the beginning of a very long line are bundled in one usb packet
rxbuf.flush();
flush_to_nl = true;
usb->endpointSetInterrupt(CDC_BulkOut.bEndpointAddress, true);
iprintf("rxbuf has room for another packet, interrupt enabled\n");
}
if (nl_in_rx > 0)
if (c == '\n' || c == '\r')
nl_in_rx--;
return c;
}
void read_frame_buffer(long frame) {
for(int i = 0; i < COLUMNS; i++) {
for(int x = 0; x < ROWS; x++) {
char* pix = getpixel(i, x);
if(frame % FLASH == 0) {
char p[3] = { bckflashred, bckflashgreen, bckflashblue };
setled(i, x, p);
} else {
setled(i, x, pix);
}
}
}
}
int main(void)
{
//initialize Raspberry Pi and pins
wiringPiSetup();
pinMode(0,OUTPUT);
pinMode(1,OUTPUT);
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(5,OUTPUT);
pinMode(21,OUTPUT);
pinMode(22,OUTPUT);
pinMode(23,OUTPUT);
pinMode(24,OUTPUT);
pinMode(25,OUTPUT);
pinMode(26,OUTPUT);
//get time
time_t the_time;
struct tm * tm_ptr;
while(1)
{
the_time = time((time_t *)0);
tm_ptr = localtime(&the_time);
//recode time h_1h_2:m_1m:2 hh:mm
int h_1, h_2, m_1, m_2;
h_1 = tm_ptr->tm_hour / 10;
h_2 = tm_ptr->tm_hour - (tm_ptr->tm_hour / 10) * 10;
m_1 = tm_ptr->tm_min /10;
m_2 = tm_ptr->tm_min - (tm_ptr->tm_min / 10) * 10;
//if them show at the same time, the power is not enough
setled(1,n[h_1]);
delay(DELAY_TIME);
setled(2,n[h_2]);
delay(DELAY_TIME);
setled(3,n[m_1]);
delay(DELAY_TIME);
setled(4,n[m_2]);
delay(DELAY_TIME);
}
}
void inv_state () {
int lstate = 0;
if ((ioctl(fd, TIOCMGET, &lstate)) == -1) {
perror("IOCTL");
exit(0);
}
setled(init_state, OFF, &lstate); // Desliga o atual
init_state = !init_state;
lstate = 0;
setled(init_state, ON, &lstate); // Led no estado invertido
if (DEBUG) fprintf(stderr, "Status invertido %d\n", init_state);
}
void CVFD::setled(void)
{
if(fd < 0) return;
int led1 = -1, led2 = -1;
int select = 0;
if(mode == MODE_MENU_UTF8 || mode == MODE_TVRADIO )
select = g_settings.led_tv_mode;
else if(mode == MODE_STANDBY)
select = g_settings.led_standby_mode;
switch(select){
case 0:
led1 = FP_LED_1_OFF; led2 = FP_LED_2_OFF;
break;
case 1:
led1 = FP_LED_1_ON; led2 = FP_LED_2_ON;
break;
case 2:
led1 = FP_LED_1_ON; led2 = FP_LED_2_OFF;
break;
case 3:
led1 = FP_LED_1_OFF; led2 = FP_LED_2_ON;
break;
default:
break;
}
setled(led1, led2);
}
/*
* function draw_clock()
*
* function for drawing the clock-face
*/
void Background_Menu::draw(void) {
redbox->draw();
greenbox->draw();
bluebox->draw();
done->draw();
u8g->setFont(u8g_font_cu12_67_75);
switch(active_item) {
case 0:
u8g->setPrintPos(5,redbox->get_y()+3);
break;
case 1:
u8g->setPrintPos(5,greenbox->get_y()+3);
break;
case 2:
u8g->setPrintPos(5,bluebox->get_y()+3);
break;
case 3:
u8g->setPrintPos(5,done->get_y()+3);
break;
}
u8g->print( (char) 104 );
red = redbox->get_value() ;
green = greenbox->get_value();
blue = bluebox->get_value();
setled();
}
int main ( int argc, char **argv ) {
// pid_t pid;
int res, status_led, blinks;
// Must be called with 3 arguments
if ( argc != 3 ) usage();
if ( access( argv[2], F_OK|X_OK ) != 0 ) {
fprintf( stderr, "Command does not exist or is not executable!" );
exit( EXIT_FAILURE );
}
// Open the serial port
if ( ( fd = open( argv[1], O_RDWR | O_NDELAY ) ) < 0 ) {
fprintf( stderr, "Failed to open serial port" );
perror( "open" );
exit( EXIT_FAILURE );
}
// Register signal handlers to turn off the LEDs before exiting
signal( SIGINT, cleanup );
signal( SIGTERM, cleanup );
// turn off the red led and turn on the green one
// to indicate that we're working
setled( GREEN_LED, 0 );
setled( RED_LED, 1 );
/*
// fork into the background
if ( ( pid = fork() ) < 0 ) {
perror( "fork failed" );
exit( 1 );
} else if ( pid > 0 ) {
exit( 0 );
}
*/
// daemonize
while( 1 ) {
if ( button_pressed() ) {
setled( GREEN_LED, 0 );
setled( RED_LED, 1 );
res = system( argv[2] );
status_led = ( res == 0 ) ? GREEN_LED : RED_LED;
blinks = 30;
setled( GREEN_LED, 0 );
setled( RED_LED, 0 );
while ( blinks > 0 ) {
setled( status_led, -1 );
sleep( 1 );
}
}
sleep( 1 );
}
return ( 1 );
}
void read_textwall_buffer(long *offset, long frame) {
for(int i = 0; i < COLUMNS; i++) {
for(int x = 0; x < ROWS; x++) {
char pix = gettextpixel(i, x, *offset);
if(pix != 0) {
char p[3] = { txtred, txtgreen, txtblue };
setled(i, x, p);
} else {
if(frame % FLASH == 0) {
char p[3] = { bckflashred, bckflashgreen, bckflashblue };
setled(i, x, p);
} else {
char p[3] = { bckred, bckgreen, bckblue };
setled(i, x, p);
}
}
}
}
}
/*
cmd:led控制命令 0关1开
arg:led选择 led0~3
*/
static int led_ioctl(struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg)
{
switch(cmd)
{
case 0:
case 1:
setled(cmd,arg);//进入设置led状态函数
break;
return 0;
default:
return -EINVAL;
}
return 0;
}
int b_opendev(char *device) {
int lstate = 0;
fd = open(device, O_RDWR | O_NDELAY);
if (fd < 0) {
fprintf(stderr, "ERRO ao abrir \"%s\"\n", device);
exit(2);
}
signal(SIGINT, offandexit);
signal(SIGTERM, offandexit);
signal(SIGUSR2, inv_state);
setled(init_state, ON, &lstate); // Led no estado inicial
return (fd);
}
void CVFD::setled(bool on_off)
{
if(g_settings.led_rec_mode == 0)
return;
int led1 = -1, led2 = -1;
if(on_off){//on
switch(g_settings.led_rec_mode) {
case 1:
led1 = FP_LED_1_ON; led2 = FP_LED_2_ON;
break;
case 2:
led1 = FP_LED_1_ON;
break;
case 3:
led2 = FP_LED_2_ON;
break;
default:
break;
}
}
else {//off
switch(g_settings.led_rec_mode) {
case 1:
led1 = FP_LED_1_OFF; led2 = FP_LED_2_OFF;
break;
case 2:
led1 = FP_LED_1_OFF;
break;
case 3:
led2 = FP_LED_2_OFF;
break;
default:
led1 = FP_LED_1_OFF; led2 = FP_LED_2_OFF;
break;
}
}
setled(led1, led2);
}
Background_Menu::Background_Menu(Widget *parent)
: Widget(parent)
{
pinMode(BACKLIGHT_RED, OUTPUT); // sets the pins as output
pinMode(BACKLIGHT_GREEN, OUTPUT);
pinMode(BACKLIGHT_BLUE, OUTPUT);
period = 1000;
phase_green = 300;
phase_blue = 600;
x = 0;
y = 5;
red = 0;
green = 0;
blue = 0;
active_item = 0;
int i = 0;
redbox = new InputBox(this, "Red", 0, 100, red);
redbox->set_pos(x+20,y+10+i*(redbox->get_height()+4)-2);
i++;
greenbox = new InputBox(this, "Green", 0, 100, green);
greenbox->set_pos(x+20,y+10+i*(greenbox->get_height()+4)-2);
i++;
bluebox = new InputBox(this, "Blue", 0, 100, blue);
bluebox->set_pos(x+20,y+10+i*(bluebox->get_height()+4)-2);
i++;
done = new MenuItem("Done", this);
done->set_pos(x+20,y+10+i*(done->get_height()+4)-2);
analogWrite(BACKLIGHT_RED, red); // Write current values to LED pins
analogWrite(BACKLIGHT_GREEN, green);
analogWrite(BACKLIGHT_BLUE, blue);
setled();
}
static void
rxon(Ether *edev, Wnode *bss)
{
uchar c[Tcmdsize], *p;
int filter, flags, rate;
Ctlr *ctlr;
char *err;
int idx;
ctlr = edev->ctlr;
filter = FilterNoDecrypt | FilterMulticast;
if(ctlr->prom){
filter |= FilterPromisc;
if(bss != nil)
ctlr->channel = bss->channel;
bss = nil;
}
if(bss != nil){
ctlr->channel = bss->channel;
memmove(ctlr->bssid, bss->bssid, Eaddrlen);
ctlr->aid = bss->aid;
if(ctlr->aid != 0){
filter |= FilterBSS;
ctlr->bssnodeid = -1;
}else
ctlr->bcastnodeid = -1;
}else{
memmove(ctlr->bssid, edev->bcast, Eaddrlen);
ctlr->aid = 0;
ctlr->bcastnodeid = -1;
ctlr->bssnodeid = -1;
}
flags = RFlagTSF | RFlag24Ghz | RFlagAuto;
if(ctlr->aid != 0)
setled(ctlr, 2, 0, 1); /* on when associated */
else if(memcmp(ctlr->bssid, edev->bcast, Eaddrlen) != 0)
setled(ctlr, 2, 10, 10); /* slow blink when connecting */
else
setled(ctlr, 2, 5, 5); /* fast blink when scanning */
memset(p = c, 0, sizeof(c));
memmove(p, edev->ea, 6); p += 8; /* myaddr */
memmove(p, ctlr->bssid, 6); p += 16; /* bssid */
*p++ = 3; /* mode (STA) */
p += 3;
*p++ = 0xff; /* ofdm mask (not yet negotiated) */
*p++ = 0x0f; /* cck mask (not yet negotiated) */
put16(p, ctlr->aid & 0x3fff); /* associd */
p += 2;
put32(p, flags);
p += 4;
put32(p, filter);
p += 4;
*p++ = ctlr->channel;
p += 3;
if((err = cmd(ctlr, 16, c, p - c)) != nil){
print("rxon: %s\n", err);
return;
}
/* tx power */
memset(p = c, 0, sizeof(c));
*p++ = 1; /* band (0 = 5ghz) */
p++; /* reserved */
put16(p, ctlr->channel), p += 2;
for(rate = 0; rate < nelem(ratetab); rate++){
idx = pwridx(ctlr, &ctlr->eeprom.pwrgrps[0], ctlr->channel, rate);
*p++ = ratetab[rate].plcp;
*p++ = rfgain_2ghz[idx]; /* rf_gain */
*p++ = dspgain_2ghz[idx]; /* dsp_gain */
p++; /* reservd */
}
cmd(ctlr, 151, c, p - c);
if(ctlr->bcastnodeid == -1){
ctlr->bcastnodeid = 24;
addnode(ctlr, ctlr->bcastnodeid, edev->bcast, ratetab[0].plcp, 3<<6);
}
if(ctlr->bssnodeid == -1 && bss != nil && ctlr->aid != 0){
ctlr->bssnodeid = 0;
addnode(ctlr, ctlr->bssnodeid, bss->bssid, ratetab[0].plcp, 3<<6);
}
}
void CVFD::showTime(bool force)
{
//unsigned int system_rev = cs_get_revision();
static int recstatus = 0;
#if 0
if(!has_lcd)
return;
#endif
if(fd >= 0 && mode == MODE_SHUTDOWN) {
ShowIcon(FP_ICON_CAM1, false);
return;
}
if (fd >= 0 && showclock) {
if (mode == MODE_STANDBY || ( g_settings.lcd_info_line && (MODE_TVRADIO == mode))) {
char timestr[21];
struct timeb tm;
struct tm * t;
static int hour = 0, minute = 0;
ftime(&tm);
t = localtime(&tm.time);
if(force || ( switch_name_time_cnt == 0 && ((hour != t->tm_hour) || (minute != t->tm_min))) ) {
hour = t->tm_hour;
minute = t->tm_min;
#if !defined (BOXMODEL_HS7810A) && !defined (BOXMODEL_HS7819)
#if defined (BOXMODEL_OCTAGON1008)
ShowIcon(ICON_COLON2, true);
#elif defined (BOXMODEL_OCTAGON1008) || defined (BOXMODEL_HS7119) || defined (BOXMODEL_CUBEREVO_250HD)
strftime(timestr, 5, "%H%M", t);
#else
strftime(timestr, 6, "%H:%M", t);
#endif
ShowText(timestr);
#else //HS7810A or HS7819, string should not scroll
strftime(timestr, 6, "%H:%M", t);
struct vfd_ioctl_data data;
memset(data.data, ' ', 6);
memcpy (data.data, timestr, 6);
data.start = 0;
data.length = 5;
write_to_vfd(VFDDISPLAYCHARS, &data);
#endif
if (support_text) {
strftime(timestr, 20, "%H:%M", t);
ShowText(timestr);
} else if (support_numbers && has_led_segment) {
ShowNumber((t->tm_hour*100) + t->tm_min);
#ifdef BOXMODEL_APOLLO
ioctl(fd, IOC_FP_SET_COLON, 0x01);
#endif
}
}
}
}
int tmp_recstatus = CNeutrinoApp::getInstance()->recordingstatus;
if (tmp_recstatus) {
if(clearClock) {
clearClock = 0;
if(has_lcd)
ShowIcon(FP_ICON_CAM1, false);
#if !HAVE_DUCKBOX_HARDWARE
setled(false);//off
#endif
} else {
clearClock = 1;
if(has_lcd)
ShowIcon(FP_ICON_CAM1, true);
#if !HAVE_DUCKBOX_HARDWARE
setled(true);//on
#endif
}
} else if(clearClock || (recstatus != tmp_recstatus)) { // in case icon ON after record stopped
clearClock = 0;
if(has_lcd)
ShowIcon(FP_ICON_CAM1, false);
#if !HAVE_DUCKBOX_HARDWARE
setled();
#endif
}
recstatus = tmp_recstatus;
}
void CVFD::setMode(const MODES m, const char * const title)
{
if(fd < 0) return;
// Clear colon in display if it is still there
#ifdef BOXMODEL_APOLLO
if (support_numbers && has_led_segment)
ioctl(fd, IOC_FP_SET_COLON, 0x00);
#endif
if(mode == MODE_AUDIO)
ShowIcon(FP_ICON_MP3, false);
#if 0
else if(mode == MODE_STANDBY) {
ShowIcon(FP_ICON_COL1, false);
ShowIcon(FP_ICON_COL2, false);
}
#endif
if(strlen(title))
ShowText(title);
mode = m;
setlcdparameter();
switch (m) {
case MODE_TVRADIO:
switch (g_settings.lcd_setting[SNeutrinoSettings::LCD_SHOW_VOLUME])
{
case 0:
showPercentOver(percentOver, false);
break;
case 1:
showVolume(volume, false);
break;
#if 0
case 2:
showVolume(volume, false);
showPercentOver(percentOver, false);
break;
#endif
}
showServicename(servicename);
showclock = true;
if(g_settings.lcd_info_line)
switch_name_time_cnt = g_settings.timing[SNeutrinoSettings::TIMING_INFOBAR] + 10;
break;
case MODE_AUDIO:
{
ShowIcon(FP_ICON_MP3, true);
showAudioPlayMode(AUDIO_MODE_STOP);
showVolume(volume, false);
showclock = true;
//showTime(); /* "showclock = true;" implies that "showTime();" does a "displayUpdate();" */
break;
}
case MODE_SCART:
showVolume(volume, false);
showclock = true;
//showTime(); /* "showclock = true;" implies that "showTime();" does a "displayUpdate();" */
break;
case MODE_MENU_UTF8:
showclock = false;
//fonts.menutitle->RenderString(0,28, 140, title, CLCDDisplay::PIXEL_ON);
break;
case MODE_SHUTDOWN:
showclock = false;
Clear();
break;
case MODE_STANDBY:
#if 0
ShowIcon(FP_ICON_COL1, true);
ShowIcon(FP_ICON_COL2, true);
#endif
ClearIcons();
ShowIcon(FP_ICON_USB, false);
ShowIcon(FP_ICON_HDD, false);
showclock = true;
showTime(true); /* "showclock = true;" implies that "showTime();" does a "displayUpdate();" */
/* "showTime()" clears the whole lcd in MODE_STANDBY */
break;
#ifdef VFD_UPDATE
case MODE_FILEBROWSER:
showclock = true;
display.draw_fill_rect(-1, -1, 120, 64, CLCDDisplay::PIXEL_OFF); // clear lcd
showFilelist();
break;
case MODE_PROGRESSBAR:
showclock = false;
display.load_screen(&(background[BACKGROUND_SETUP]));
showProgressBar();
break;
case MODE_PROGRESSBAR2:
showclock = false;
display.load_screen(&(background[BACKGROUND_SETUP]));
showProgressBar2();
break;
case MODE_INFOBOX:
showclock = false;
showInfoBox();
break;
#endif // VFD_UPDATE
}
wake_up();
#if !HAVE_DUCKBOX_HARDWARE
setled();
#endif
}
void act()
{
volatile char t = 0;
for (;t < 8; t++)
setled(t);
}
void test()
{
setup();
setled(255);
}
void CLCD::showTime(bool force)
{
static bool blink = false;
int red = -1, green = -1;
if (mode == MODE_SHUTDOWN)
{
setled(1, 1);
return;
}
time_t now = time(NULL);
if (upd_display)
{
display(display_text);
upd_display = false;
}
else if (power && (force || (showclock && (now - last_display) > 4)))
{
char timestr[64]; /* todo: change if we have a simple display with 63+ chars ;) */
struct tm *t;
static int hour = 0, minute = 0;
t = localtime(&now);
if (force || last_display || (hour != t->tm_hour) || (minute != t->tm_min)) {
hour = t->tm_hour;
minute = t->tm_min;
int ret = -1;
#if HAVE_SPARK_HARDWARE
now += t->tm_gmtoff;
int fd = dev_open();
#if 0 /* VFDSETTIME is broken and too complicated anyway -> use VFDSETTIME2 */
int mjd = 40587 + now / 86400; /* 1970-01-01 is mjd 40587 */
struct aotom_ioctl_data d;
d.u.time.time[0] = mjd >> 8;
d.u.time.time[1] = mjd & 0xff;
d.u.time.time[2] = hour;
d.u.time.time[3] = minute;
d.u.time.time[4] = t->tm_sec;
int ret = ioctl(fd, VFDSETTIME, &d);
#else
ret = ioctl(fd, VFDSETTIME2, &now);
#endif
close(fd);
#endif
if (ret < 0 && servicename.empty())
{
if (g_info.hw_caps->display_xres < 5)
sprintf(timestr, "%02d%02d", hour, minute);
else /* pad with spaces on the left side to center the time string */
sprintf(timestr, "%*s%02d:%02d",(g_info.hw_caps->display_xres - 5)/2, "", hour, minute);
display(timestr, false);
}
else
{
if (vol_active)
showServicename(servicename);
vol_active = false;
}
last_display = 0;
}
