int main(void) {
int i;
WDTCTL = WDTPW | WDTHOLD; // Disable watchdog timer
// enable fifo
iowrite16(STAT_FIFO_EN, BASE_UART0+SER_STATUS);
iowrite16(BAUD_115200, BASE_UART0+SER_BAUD);
iowrite16(STAT_FIFO_EN, BASE_UART1+SER_STATUS);
iowrite16(BAUD_115200, BASE_UART1+SER_BAUD);
printf("\r\n====== UART loopback example ======\r\n");
iowrite16(0xFF, BASE_GPIO0+GPIO_DIR);
iowrite16(0x80, BASE_GPIO0+GPIO_OUT);
while(1) {
/* echo loop */
if ( serial_getchar_check(BASE_UART0) ) {
i = serial_getchar(BASE_UART0);
serial_putchar(BASE_UART0, i);
iowrite16( (ioread16(BASE_GPIO0+GPIO_OUT) ^ 0x1), BASE_GPIO0+GPIO_OUT);
}
if ( serial_getchar_check(BASE_UART1) ) {
i = serial_getchar(BASE_UART1);
serial_putchar(BASE_UART1, i);
iowrite16( (ioread16(BASE_GPIO0+GPIO_OUT) ^ 0x2), BASE_GPIO0+GPIO_OUT);
}
}
}
int
main ()
{
pl2303_init ();
led_init ();
disp_init ();
serial_init (9600);
while (1)
{
int c;
switch ((c = serial_getchar ()))
{
case '!':
led_all_off ();
break;
case '&':
switch (serial_getchar ())
{
case 'R': led_on (LED_R); break;
case 'G': led_on (LED_G); break;
case 'B': led_on (LED_B); break;
case 'r': led_off (LED_R); break;
case 'g': led_off (LED_G); break;
case 'b': led_off (LED_B); break;
case 'i':
serial_puts ("Pripravek PIC24f Starter Kit;");
break;
case 's':
disp_clear ();
disp_at (1, 1);
while ((c = serial_getchar ()) != ';')
disp_char (c);
break;
default:
disp_clear ();
disp_at (1, 1);
disp_str ("unrecognized '");
disp_char (c);
disp_char ('\'');
}
}
}
return 0;
}
int main()
{
u32 depth = 16;
//u32 depth = 24; // true color doesn't work?
struct fb_info *fb;
/* initialize early so we can use it for debugging */
serial_init();
mem_init();
fb = fb_init(depth);
if (fb) {
printk("hello world\n");
printk("resolution: %dx%d\n", fb->width, fb->height);
}
printk("firmware revision: 0x%x\n", get_firmware_revision());
printk("board model: 0x%x\n", get_board_model());
printk("board revision: 0x%x\n", get_board_revision());
exception_init();
init();
while (1) {
int c;
serial_printk("$ ");
c = serial_getchar();
serial_printk("got this char: %c (%d) (0x%x)\n", c, c, c);
}
while(1) ;
return 0;
}
int
main(void)
{
watchdog_off();
clock_init_1MHz();
/* set all pins to output high */
port1_direction = 0xFF;
port1_output = 0xFF;
/* initialize serial clock, tx and rx parts */
serial_init_clock();
serial_init_tx();
serial_init_rx();
/* enable interrupts */
__eint();
pin_low(LED1);
pin_high(LED2);
while (1) {
unsigned char c;
pin_toggle(LED1);
pin_toggle(LED2);
c = serial_getchar();
serial_putchar(c);
if (c == '\r')
serial_putchar('\n');
}
}
int main(void)
{
char ch;
serial_init(51);
LED_init();
while(1)
{
//print messages on the screen
printf("Press 1 to turn LED on. \r");
printf("Press 0 to turn LED off. \r\r");
//get the input char from keyboard
ch = serial_getchar();
switch(ch)
{
case '0':
//turn off LED
printf("LED off!\r");
LED_off();
break;
case '1':
//turn on LED
printf("LED on!\r");
LED_on();
break;
default:
printf("Wrong key!\r");
break;
}
}
}
static void
handle_serial_input(void)
{
while (1) {
switch (serial_getchar()) {
case '\0':
cli();
if (!serial_available())
events &= ~EV_SERIAL;
sei();
return;
case 'O': /* open */
pin_low(PIN_GREEN_LED);
pin_low(PIN_OPEN_LOCK);
_delay_ms(500);
pin_high(PIN_OPEN_LOCK);
serial_print("OPENAKCK\n");
pin_high(PIN_GREEN_LED);
break;
case 'D': /* day */
pin_low(PIN_GREEN_LED);
pin_low(PIN_DAYMODE); /* day mode */
pin_high(PIN_STATUS_LED); /* status on */
break;
case 'N': /* night */
pin_high(PIN_GREEN_LED);
pin_high(PIN_DAYMODE); /* nightmode */
pin_low(PIN_STATUS_LED); /* status off */
break;
case 'R': /* rejected */
pin_low(PIN_YELLOW_LED);
_delay_ms(200);
pin_high(PIN_YELLOW_LED);
_delay_ms(200);
pin_low(PIN_YELLOW_LED);
_delay_ms(200);
pin_high(PIN_YELLOW_LED);
break;
case 'V': /* validated */
pin_low(PIN_GREEN_LED);
_delay_ms(300);
pin_high(PIN_GREEN_LED);
_delay_ms(200);
pin_low(PIN_GREEN_LED);
_delay_ms(300);
pin_high(PIN_GREEN_LED);
_delay_ms(200);
pin_low(PIN_GREEN_LED);
_delay_ms(300);
pin_high(PIN_GREEN_LED);
break;
}
}
}
static void poll_dials ( int id )
{
int data;
static int dial_state = DIAL_NEW;
static int dial_which;
static int dial_value;
static int dials[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
if ( !dialbox_port ) return;
while ( (data=serial_getchar(dialbox_port)) != EOF )
{
if ( ( dial_state > DIAL_WHICH_DEVICE ) || IS_DIAL_EVENT ( data ) )
{
switch ( dial_state )
{
case DIAL_WHICH_DEVICE:
dial_which = data - DIAL_BASE;
dial_state++;
break;
case DIAL_VALUE_HIGH:
dial_value = ( data << 8 );
dial_state++;
break;
case DIAL_VALUE_LOW:
dial_value |= data;
if ( dial_value & 0x8000 ) dial_value -= 0x10000;
dials[dial_which] = dial_value;
send_dial_event ( dial_which + 1, dial_value * 360 / 256 );
dial_state = DIAL_WHICH_DEVICE;
break;
default:
/* error: Impossible state value! */
break;
}
}
else if ( data == DIAL_INITIALIZED )
{
fgState.InputDevsInitialised = GL_TRUE;
dial_state = DIAL_WHICH_DEVICE;
serial_putchar(dialbox_port,DIAL_SET_AUTO_DIALS);
serial_putchar(dialbox_port,0xff);
serial_putchar(dialbox_port,0xff);
}
else /* Unknown data; try flushing. */
serial_flush(dialbox_port);
}
glutTimerFunc ( 2, poll_dials, 0 );
}
int getkey()
{
while (!kbhit())
;
// return the next character from the console input device
// return usb_serial_getchar();
if(USB_SERIAL_ON && (usb_serial_available() != 0)) {
return usb_serial_getchar();
}
#ifdef USE_UART
return serial_getchar();
#endif
return 0;
}
int main ()
{
serial_init(51) ;
LM20_init();
timer_init();
lcd_init(LCD_DISP_ON);
sei();
while(1)
{
unsigned char ch = serial_getchar();
LM20_setTemperature(ch);
}
return 0;
}
void game_frame()
{
// if button pressed, send 'a' quickly
if (button_state())
serial_putchar('a'); // low level output
if (vga_frame%16) return;
led=1-led;
set_led(led);
// echo input first character
if (serial_rx_ready())
serial_putchar(serial_getchar()); // could block
}
/*
* serial_getline
* --------------------------------------
* receive chars from the serial port until
* \n, then return a string.
* Maximum length of line is 120 chars.
* copy string from pointer to new variable,
* static declaration here is to avoid global declaration.
* HOWEVER, the pointer is globally accessed too...shrug.
*/
char* serial_getline (void) {
char current=' ';
U16 index=0;
static char _LINEBUFFER[MAXBUFFER];
while((current != '\n' && current != '\r') && index < MAXBUFFER-1) {
current=serial_getchar();
_LINEBUFFER[index]=current;
++index;
}
_LINEBUFFER[index]='\0';
return (_LINEBUFFER);
}
static int curses_getchar(int _delay)
{
#if CONFIG(LP_USB_HID) || CONFIG(LP_PC_KEYBOARD) || \
CONFIG(LP_SERIAL_CONSOLE)
unsigned short c;
#endif
do {
#if CONFIG(LP_USB_HID)
usb_poll();
if ((curses_flags & F_ENABLE_CONSOLE) &&
usbhid_havechar()) {
c = usbhid_getchar();
if (c != 0) return c;
}
#endif
#if CONFIG(LP_PC_KEYBOARD)
if ((curses_flags & F_ENABLE_CONSOLE) &&
keyboard_havechar()) {
c = keyboard_getchar();
if (c != 0) return c;
}
#endif
#if CONFIG(LP_SERIAL_CONSOLE)
if ((curses_flags & F_ENABLE_SERIAL) &&
serial_havechar()) {
c = serial_getchar();
return cook_serial(c);
}
#endif
if (_delay == 0) {
break;
} else if (_delay >= 10) {
mdelay(10);
_delay -= 10;
} else if (_delay > 0) {
mdelay(_delay);
_delay = 0;
}
} while (1);
return ERR;
}
static int curses_getchar(int _delay)
{
#if defined(CONFIG_USB_HID) || defined(CONFIG_PC_KEYBOARD) || defined(CONFIG_SERIAL_CONSOLE)
unsigned short c;
#endif
do {
#ifdef CONFIG_USB_HID
usb_poll();
if ((curses_flags & F_ENABLE_CONSOLE) &&
usbhid_havechar()) {
c = usbhid_getchar();
if (c != 0) return c;
}
#endif
#ifdef CONFIG_PC_KEYBOARD
if ((curses_flags & F_ENABLE_CONSOLE) &&
keyboard_havechar()) {
c = keyboard_getchar();
if (c != 0) return c;
}
#endif
#ifdef CONFIG_SERIAL_CONSOLE
if ((curses_flags & F_ENABLE_SERIAL) &&
serial_havechar()) {
c = serial_getchar();
return cook_serial(c);
}
#endif
if (_delay == 0)
break;
if (_delay > 0) {
mdelay(1);
_delay--;
}
} while (1);
return ERR;
}
static int getkeyseq(char *buffer, int len, int max)
{
int i;
while (1) {
for(i = 0; i < 75; i++) {
if (serial_havechar())
break;
mdelay(1);
}
if (i == 75)
return len;
buffer[len++] = serial_getchar();
if (len == max)
return len;
}
}
static bool event(void* data) {
int ch;
if(serial_enabled) {
while(serial_havechar()) {
ch = serial_getchar();
// TODO: process other special keys
if(ch == '\r') {
// Serial mode of QEMU is cooked mode.
// Line feed('\r') expected for new line('\n')
stdio_putchar((const char)'\n');
} else {
stdio_putchar((const char)ch);
}
}
}
if(callback)
callback();
return true;
}
int PDC_get_key(void)
{
int c = 0;
#ifdef CONFIG_USB_HID
usb_poll();
if ((curses_flags & F_ENABLE_CONSOLE) &&
usbhid_havechar()) {
c = usbhid_getchar();
}
#endif
#ifdef CONFIG_PC_KEYBOARD
if ((curses_flags & F_ENABLE_CONSOLE) &&
keyboard_havechar() && (c==0)) {
c = keyboard_getchar();
}
#endif
#ifdef CONFIG_SERIAL_CONSOLE
if ((curses_flags & F_ENABLE_SERIAL) &&
serial_havechar() && (c==0)) {
c = cook_serial(serial_getchar());
}
#endif
SP->key_code = FALSE;
if (c == 0) {
c = ERR;
}
if (c >= KEY_MIN) {
SP->key_code = TRUE;
}
return c;
}
short console_getline(console_color_t color, char *str, unsigned short *len) {
unsigned short i=0;
char c;
unsigned char c233 = vga_color233(vga_console_color(color));
while (i < *len-1) {
if ((sysio[0] & 0x2) == 0x2)
c = keyboard_getchar();
else
c = serial_getchar(0);
if (c >= ' ' && c <= '~') {
if ((sysio[0] & 0x2) == 0x2)
vga_putchar(c233,c);
else
serial_putchar(0, c);
str[i++] = c;
}
if (c == '\r' || c == '\n') {
str[i] = '\0';
return i;
}
if (c == 0x03) {
str[0] = '\0';
return -1;
}
if ((c == 0x7f || c == 0x08) && i > 0) {
if ((sysio[0] & 0x2) == 0x2)
vga_putchar(c233, c);
else
serial_putchar(0, c);
i--;
}
}
str[i+1] = '\0';
return i;
}
char readcmd(char** argv, char maxargs)
{
static char cmdbuf[256] = {0, 0};
static unsigned char current = 0;
unsigned char history = 0;
unsigned char pos = current + 1;
unsigned char end = current + 2;
unsigned char arg;
while(1)
{
int c = serial_getchar();
if(c == -1)
continue;
switch(c)
{
case 0x1B:
while((c = serial_getchar()) == -1)
;
if(c == '[')
{
while((c = serial_getchar()) == -1)
;
switch(c)
{
case 'A': goto UP;
case 'B': goto DOWN;
case 'C': goto RIGHT;
case 'D': goto LEFT;
}
}
break;
LEFT:
case 0x02: // left
if(pos - 1 != current)
{
--pos;
printf("\x1B[D"); // move left
}
else
serial_putchar(BELL);
break;
case 0x08: // backspace
case 0x7f:
if(pos > 0)
{
memmove(cmdbuf + pos - 1, cmdbuf + pos, end - pos);
--pos; --end;
printf("\x1B[D%s \x1B[%dD", cmdbuf + pos, end - pos); // move left
}
else
serial_putchar(BELL);
break;
RIGHT:
case 0x06: // right
if(pos + 1 != end)
{
++pos;
printf("\x1B[C"); // move right
}
else
serial_putchar(BELL);
break;
case '\n':
case '\r':
goto DONE;
UP:
case 0x10:
if(1)
{
unsigned char p = current;
unsigned char len = 0;
unsigned char i;
for(i = 0; i < history + 1; ++i)
{
len = cmdbuf[p];
if(len == 0)
break;
p -= len;
}
if(i == history + 1)
{
++history;
for(i = 0; i < len - 1; ++i)
cmdbuf[current + 1 + i] = (cmdbuf[p + 1 + i] == '\0' ?
' ' : cmdbuf[p + 1 + i]);
cmdbuf[current + len - 1] = '\0';
printf(" \x1B[%dD%s", pos - current, cmdbuf + current + 1);
if(end - (current + len) > 0)
printf("%*s\x1B[%dD", end - (current + len), "", end - (current + len));
end = current + len;
pos = end - 1;
}
else
serial_putchar(BELL);
}
break;
DOWN:
case 0x0E:
if(history > 1)
{
unsigned char p = current;
unsigned char len;
unsigned char i;
--history;
for(i = 0; i < history; ++i)
{
len = cmdbuf[p];
if(len == 0)
break;
p -= len;
}
for(i = 0; i < len - 1; ++i)
cmdbuf[current + 1 + i] = (cmdbuf[p + 1 + i] == '\0' ?
' ' : cmdbuf[p + 1 + i]);
cmdbuf[current + len - 1] = '\0';
printf(" \x1B[%dD%s", pos - current, cmdbuf + current + 1);
if(end - (current + len) > 0)
printf("%*s\x1B[%dD", end - (current + len), "", end - (current + len));
end = current + len;
pos = end - 1;
}
else if(history == 1)
{
}
else
serial_putchar(BELL);
break;
default:
if(end + 1 != current)
{
int i;
for(i = end; i > pos; --i)
cmdbuf[i] = cmdbuf[i - 1];
cmdbuf[pos] = c;
printf("%s \x1B[%dD", cmdbuf + pos, end - pos);
++pos;
++end;
}
else
serial_putchar(BELL);
break;
}
}
DONE:
pos = current + 1;
for(arg = 0; arg < maxargs; ++arg)
{
if(cmdbuf[pos] == '\0')
break;
while(cmdbuf[pos] == ' ')
cmdbuf[pos++] = '\0';
argv[arg] = cmdbuf + pos;
while(cmdbuf[pos] != ' ' && cmdbuf[pos] != '\0')
++pos;
}
cmdbuf[end] = end - current;
cmdbuf[end + 1] = '\0';
current = end;
return arg;
}
int ubreadline_into_buffer(const char *const prompt, char *buffer, int timeout)
{
char *p = buffer;
unsigned int len = CONFIG_SYS_CBSIZE;
int rc;
static int initted = 0;
/*
* History uses a global array which is not
* writable until after relocation to RAM.
* Revert to non-history version if still
* running from flash.
*/
if (0) {
if (!initted) {
hist_init();
initted = 1;
}
if (prompt)
printf (prompt);
rc = cread_line(prompt, p, &len, timeout);
return rc < 0 ? rc : len;
} else {
char * p_buf = p;
int n = 0; /* buffer index */
int plen = 0; /* prompt length */
int col; /* output column cnt */
char c;
/* print prompt */
if (prompt) {
plen = strlen (prompt);
printf (prompt);
}
col = plen;
for (;;) {
c = serial_getchar();
/*
* Special character handling
*/
switch (c) {
case '\r': /* Enter */
case '\n':
*p = '\0';
printf ("\r\n");
return p - p_buf;
case '\0': /* nul */
continue;
case 0x03: /* ^C - break */
p_buf[0] = '\0'; /* discard input */
return -1;
case 0x15: /* ^U - erase line */
while (col > plen) {
printf (erase_seq);
--col;
}
p = p_buf;
n = 0;
continue;
case 0x17: /* ^W - erase word */
p=delete_char(p_buf, p, &col, &n, plen);
while ((n > 0) && (*p != ' ')) {
p=delete_char(p_buf, p, &col, &n, plen);
}
continue;
case 0x08: /* ^H - backspace */
case 0x7F: /* DEL - backspace */
p=delete_char(p_buf, p, &col, &n, plen);
continue;
default:
/*
* Must be a normal character then
*/
if (n < CONFIG_SYS_CBSIZE-2) {
if (c == '\t') { /* expand TABs */
/* if auto completion triggered just continue */
*p = '\0';
if (cmd_auto_complete(prompt, console_buffer, &n, &col)) {
p = p_buf + n; /* reset */
continue;
}
printf (tab_seq+(col&07));
col += 8 - (col&07);
} else {
char buf[2];
/*
* Echo input using printf() to force an
* LCD flush if we are using an LCD
*/
++col;
buf[0] = c;
buf[1] = '\0';
printf(buf);
}
*p++ = c;
++n;
} else { /* Buffer full */
serial_putchar('\a');
}
}
}
}
}
int
main(void)
{
watchdog_off();
clock_init_1MHz();
port1_direction = 0xFC; // 1111 1011 --> p1.2 is Rx
port2_direction = 0xFF; // 1111 1111
port1_output &= 0x00; // turn off motors or it'll heat up!
port2_output &= 0x00; // turn off motors or it'll heat up!
delay(0xffff); // wait for initialization or something
/* initialize serial clock, tx and rx parts */
serial_init_clock();
serial_init_tx();
serial_init_rx();
/* enable interrupts */
__eint();
while (1) {
unsigned int i;
unsigned char c;
c = serial_getchar();
//debug_char(c);
if (c == 'o') { // open
flash();
for (i=0; i<ROTATE_AMOUNT; i++) {
port1_output = 0x20; // 0010 0000
port2_output = 0x05; // 0000 0101
delay(DELAY);
port1_output = 0x28; // 0010 1000
port2_output = 0x04; // 0000 0100
delay(DELAY);
port1_output = 0x20; // 0010 0000
port2_output = 0x06; // 0000 0110
delay(DELAY);
port1_output = 0x30; // 0011 0000
port2_output = 0x04; // 0000 0100
delay(DELAY);
}
port1_output &= 0x00; // turn off motors!
port2_output &= 0x00; // turn off motors!
}
else if (c == 'c') { // close
flash();
flash();
for (i=0; i<ROTATE_AMOUNT; i++) {
port1_output = 0x30; // 0011 0000
port2_output = 0x04; // 0000 0100
delay(DELAY);
port1_output = 0x20; // 0010 0000
port2_output = 0x06; // 0000 0110
delay(DELAY);
port1_output = 0x28; // 0010 1000
port2_output = 0x04; // 0000 0100
delay(DELAY);
port1_output = 0x20; // 0010 0000
port2_output = 0x05; // 0000 0101
delay(DELAY);
}
port1_output &= 0x00; // turn off motors!
port2_output &= 0x00; // turn off motors!
}
}
}
