void fill_in_message1(void) {
int i = 0;
uint8_t c;
for(i = 0; i < MESSAGE1_PRODUCT_KEY_LENGTH; ++i) {
messages[messages_index].board_product_key[i] = uart_getchar();
}
for(i = 0; i < MESSAGE1_OUTLET_NUMBER_LENGTH; ++i) {
messages[messages_index].board_outlet_number[i] = uart_getchar();
}
for(i = 0; i < MESSAGE1_STATE_LENGTH; ++i) {
messages[messages_index].state[i] = uart_getchar();
}
for(i = 0; i < MESSAGE1_OUTLET_ID_LENGTH; ++i) {
messages[messages_index].outlet_id[i] = uart_getchar();
}
c = uart_getchar();
if (c != '\0') {
print("Characte ending message was NOT a null... Possible Error! (message_index NOT incremented)\n");
} else {
messages_index++;
if(messages_index >= MESSAGES_QUEUE_LENGTH) {
messages_index = 0;
}
}
return;
}
/*-----------------------------------------------------------------------------
* SER_GetChar: Read a character from the Serial Port
*----------------------------------------------------------------------------*/
int32_t SER_GetChar (void) {
#ifdef __DBG_ITM
if (ITM_CheckChar())
return ITM_ReceiveChar();
#else
// if (UART1_S1 & UART_S1_RDRF_MASK) {
//while (!(UART1_S1 & UART_S1_RDRF_MASK));
//return (UART1_D);
// Wait until character has been received //
//while (!(UART_S1_REG(TERM_PORT) & UART_S1_RDRF_MASK));
// Return the 8-bit data from the receiver //
//return UART_D_REG(TERM_PORT);
if (TERM_PORT_NUM == 0)
return uart0_getchar(UART0_BASE_PTR);
else if (TERM_PORT_NUM == 1)
return uart_getchar(UART1_BASE_PTR);
else
return uart_getchar(UART2_BASE_PTR);
#endif
return (-1);
}
int main(void)
{
ioinit();
for(;;)
{
unsigned char c = uart_getchar();
uart_putchar(c);
switch(c) {
case 0xfe:
c = uart_getchar();
switch(c) {
case 0x01:
sbi(PORTB, OUT_RELAY);
uart_putchar(0x11);
break;
case 0x02:
cbi(PORTB, OUT_RELAY);
uart_putchar(0x11);
break;
default:
uart_putchar(0xee);
}
break;
default:
uart_putchar(0xee);
}
}
return 0;
}
// Read a max of 2 digits from the serial line
// return value of -1 means no change (user just hit return)
signed char terminalmode_readnum(unsigned char chr_nl){
unsigned char ch;
unsigned char lineendcnt=1;
unsigned char digits=2; // you can enter max 2 digits
signed char rval=-1;
if (chr_nl){
// we expect \r\n as line end
lineendcnt=2;
}
ch=uart_getchar(1);
while(ch != '\r' && ch !='\n' && digits){
if ((ch >= '0') && (ch <= '9')){
if (rval==-1){
rval=0;
}
uart_sendchar(ch); // echo number back to terminal
rval=rval*10 + (ch - (unsigned char)'0');
digits--;
}
ch=uart_getchar(1);
}
// user just pressed return or enter just 1 digit
if (ch == '\r' || ch == '\n'){
lineendcnt--;
}
// get \n or \r\n after a number was entered:
while(lineendcnt){
ch=uart_getchar(1);
lineendcnt--;
}
return(rval);
}
int main(int argc, char **argv)
{
int8_t *p;
uint8_t c;
// Initialize UART
c = '*'; // print msg on first iteration
for(;;) {
uint32_t start, size;
switch (c) {
case 'u': // upload
start = read_uint32();
size = read_uint32();
for (p = (int8_t *) start; p < (int8_t *) (start+size); p++)
*p = uart_getchar();
break;
case 'd': // download
start = read_uint32();
size = read_uint32();
for (p = (int8_t *) start; p < (int8_t *) (start+size); p++)
uart_putchar( *p );
break;
case 'g': // goto
start = read_uint32();
jump(start);
break;
default:
uart_putstr("**SAKC/bootloader** > \r\n");
break;
};
c = uart_getchar();
}
}
void uart_get_pwms(uint8_t *pwms)
{
char c;
while((c = uart_getchar()));
pwms[0] = uart_getchar();
pwms[1] = uart_getchar();
pwms[2] = uart_getchar();
}
int main(void)
{
DynamixelPacket dpacketIn;
DynamixelPacketInit(&dpacketIn);
int c;
int ret;
uint8_t id;
uint8_t type;
uint8_t * data;
uart_init();
uart_setbaud(115200);
//enable global interrupts
sei ();
//uart_printf("hello\n\r");
DDRC |= _BV(PINC0);
LaserOff();
while(1)
{
c= uart_getchar();
if (c != EOF)
uart_putchar(c);
}
while(1)
{
c= uart_getchar();
if (c != EOF)
{
ret = DynamixelPacketProcessChar(c,&dpacketIn);
if (ret > 0)
{
id = DynamixelPacketGetId(&dpacketIn);
if (id == LASER_POINTER_ID)
{
type = DynamixelPacketGetType(&dpacketIn);
if (type == INSTRUCTION_WRITE_DATA)
{
data = DynamixelPacketGetData(&dpacketIn);
if (data[0] == 0)
LaserOff();
else
LaserOn();
}
}
}
}
}
return 0;
}
int uart_get(void){
int output;
while(1){
if(uart_getchar() == '\n')
break;
else
output = uart_getchar();
}
return output;
}
char
in_char (void)
{
if (TERM_PORT_NUM == 0)
return uart0_getchar(UART0_BASE_PTR);
else if (TERM_PORT_NUM == 1)
return uart_getchar(UART1_BASE_PTR);
else
return uart_getchar(UART2_BASE_PTR);
}
void main ( void ) {
xdata unsigned char ram_buffer[128];
uint8_t i,k ;
uint16_t addr;
addr = 0x0000;
i=0;
uart_config(BR_9600_6MHZ);
printf("\r 8051s UART Test Program \n\r") ;
while(1) {
for ( i =0; i< 20; i++) {
k = uart_getchar();
ram_buffer[i] = k;
uart_putchar(k);
printf("\n\r");
}
printf("Captured 20 data in RAM ");
printf("\r\n");
k = uart_getchar();
printf(" Buffer COntents : ");
for ( k=0 ; k < i ; k++) {
uart_putchar(ram_buffer[k]);
}
printf("\n\r");
printf(" Completed ");
while(1)
{
;
}
}
}
/**
* \brief Read an unsigned integer from the menu prompt
* \param[in] prompt - the text to display
* \return the unsigned integer read
*/
unsigned int menu_read_uint(const char *prompt)
{
unsigned int value = 0;
uart_puts(prompt);
while (1) {
int c = uart_getchar();
watchdog_pet();
if ((c >= '0') && (c <= '9')) {
value *= 10;
value += c - '0';
uart_putchar(c);
} else if ((c == '\n') || (c == '\r')) {
uart_puts("\n");
break;
} else {
/* Not a valid character */
}
}
return value;
}
int main(void)
{
uart_init();
i2c_init();
i2c_start(0x74);
i2c_send(0x00);
i2c_send(0x25);
i2c_send(0x06);
i2c_send(0x24);
i2c_send(0x0F);
i2c_stop();
uart_getchar();
i2c_start(0x74);
i2c_send(0x40);
i2c_send(0xC1);
i2c_send(0xC2);
i2c_stop();
while(1 > 0) {
}
return 0;
}
int c_entry(void)
{
uart_init();
myprintf("hello, world!\n");
myprintf("hello, %c%c%c\n", 'a', 'k', 'a');
myprintf("hello, %s\n", "edu");
myprintf("hello, %x\n", 0x43110);
myprintf("hello, %d\n", 0x0);
myprintf("hello, %d\n", 12345678);
myprintf("s5pv210 chip id = 0x%x\n", *(int *)0xE0000000);
while (1)
{
char c = 'a';
c = uart_getchar();
//for (c = 'a'; c <= 'z'; c++)
uart_putchar(c);
}
return 0;
}
int mymain(void)
{
int * p = (int *)0x7f005000;
int i = 0;
char c;
led_init();
// clear all uart0 regs
for (i = 0; i < 12; i++)
*(p+i) = 0x0;
// uart init
uart_init();
for (c = 'a'; c <= 'z'; c++)
uart_putchar(c);
while(1)
{
c = uart_getchar();
uart_putchar(c);
#if 0
led_on();
delay();
led_off();
delay();
#endif
}
return 0;
}
char * gets(char * s)
{
char c;
char * buf = s;
while ((c = uart_getchar()) != '\r')
{
if (c != '\b')
{
*buf++ = c;
uart_putchar(c);
}
else // '\b'
{
if (buf > s)
{
buf--;
*buf = '\0';
uart_putchar('\b');
uart_putchar(' ');
uart_putchar('\b');
}
}
}
*buf = '\0';
uart_putchar('\r');
uart_putchar('\n');
return s;
}
void main(void) {
welcome();
while (1) {
UARTCHAR(uart_getchar());
}
}
/**
* \brief The main application
*
* This application will initialize the UART, send a character and then receive
* it and check if it is the same character as was sent.
*
* \note The RX and TX pins should be externally connected in order to pass the
* test.
*/
int main(void)
{
uint8_t data;
uint8_t cnt;
cli();
uart_init();
sei();
// Send the test string
for (cnt = 0; cnt < strlen(test_string); cnt++) {
uart_putchar(test_string[cnt]);
}
// Check if we have received the string we sent
cnt = 0;
do {
// Wait for next character
while (!uart_char_waiting());
data = uart_getchar();
// Compare to what we sent
Assert (data == test_string[cnt++]);
} while (cnt < strlen(test_string));
while (true);
}
intx uart_read( TiUartAdapter * uart, char * buf, intx size, uint8 opt )
{
#ifdef CONFIG_UART_INTERRUPT_DRIVEN
intx copied=0;
int8 count =0;
hal_enter_critical();
copied = min( uart->rxlen, size );
if (copied > 0)
{
memmove( (void *)buf, (void *)&(uart->rxbuf[0]), copied );
uart->rxlen -= copied;
if (uart->rxlen > 0)
memmove( (void *)&(uart->rxbuf[0]), (void *)&(uart->rxbuf[copied]), uart->rxlen );
}
hal_leave_critical();
return copied;
#endif
#ifndef CONFIG_UART_INTERRUPT_DRIVEN
intx ret=0;
if (size > 0)
{
ret = uart_getchar( uart, buf );
}
return ret;
#endif
}
int main (void)
{
uint32_t now, led_ms; // ms
unsigned char c;
DDRB |= 1 << 7; // Arduino pin 13
uart0_init();
tmr_init();
sei();
printf("hello world\n");
led_ms = tmr_count_ms();
while (1) {
now = tmr_count_ms();
if ((now - led_ms) >= 1000) {
led_ms = now;
PORTB ^= 1 << 7; // Arduino pin 13
printf("%ld ms\n", now);
}
c = uart_getchar();
if (c) {
uart_putchar(c);
}
}
return 0;
}
void console_poll()
{
int ch = 0;
if(!uart_getchar)
return;
ch = uart_getchar();
if (ch == -1)
return;
console_putc((unsigned int)ch);
if (console_buf_loc + 1 >= MAX_CONSOLE_BUF
|| ch == '\r'
|| ch == '\n') {
console_buf[console_buf_loc++] = (char)ch;
console_buf[console_buf_loc] = 0;
console_putc('\n');
console_rx_cmd_complete(console_buf);
console_buf_loc = 0;
console_buf[console_buf_loc] = 0;
}
else {
console_buf[console_buf_loc++] = (char)ch;
}
}
int main(void)
{
led_init(); /* 设置对应管脚为输出 */
clock_init(); /* 初始化时钟 */
uart_init(); /* 初始化UART0 */
wy_printf("\n********************************\n");
wy_printf(" wy_bootloader\n");
wy_printf(" vars: %d \n",2012);
wy_printf("********************************\n");
while (1)
{
char c = 'x';
putchar('\n');
c = uart_getchar();
putchar(c);
for (c = 'a'; c <= 'z'; c++)
putchar(c);
break;
}
while(1)
{
led_water();
}
return 0;
}
void load(int argc, char * argv[])
{
int size = 180;
int addr = 0x51000000;
char * p;
int i;
puts("load usage: load 0x51000000 size\n");
if (argc > 2)
{
addr = atoi(argv[1]);
size = atoi(argv[2]);
}
puts("Ready for binary download to 0x");
putx(addr);
puts(" at 115200 bps...\n");
// get user load addr
p = (char *)addr;
for (i = 0; i < size; i++)
{
*p++ = uart_getchar();
}
puts("load to addr 0x");
putx(addr);
puts("\ntotal size 0x");
putx(size);
puts("\nload finished \n");
}
/**
* \brief Read user input and execute menu selection
*/
void menu_run(void)
{
static unsigned int value = 0;
int c = uart_getchar();
if ((c >= '0') && (c <= '9')) {
value *= 10;
value += c - '0';
uart_putchar(c);
} else if ((c == '\n') || (c == '\r')) {
if ((value > 0) && (value <= _current_menu_size)) {
/* Invoke the callback */
if (_current_menu[value - 1].handler != NULL) {
uart_puts("\n");
if (_current_menu[value - 1].handler() != 0) {
uart_puts("\nError\n");
}
}
} else {
uart_puts("\nInvalid selection\n");
}
display_menu();
value = 0;
} else {
/* Not a valid character */
}
}
int main( void )
{
int i;
uart_init(9600);
init_gpio();
init_PWM();
tss_init();
__enable_interrupts();
for( i=0; i<DELAY; i++) ;
uart_putstr( "Initialization Complete\r\n" );
// wait for user to press a key
uart_putstr( "Press any key:" );
uart_getchar();
TSI0_DATA |= TSI_DATA_SWTS_MASK;
while( 1 )
{
uart_putnum( tss_pin9, 5 ); // 2^16 = 65536 = 5 digits
uart_putstr( "\t" );
uart_putnum( tss_pin10, 5 ); // 2^16 = 65536 = 5 digits
uart_putstr( "\r\n" );
for( i=0; i<DELAY; i++);
}
return 0;
}
int main(int argc, char **argv)
{
int8_t *p;
uint8_t c;
unsigned int key, len, autoboot = 1, dispmenu = 1;
// Initialize UART
uart_init();
while(1){ /* loop forever until u-boot gets booted or the board is reset */
if(dispmenu){
uart_putstr("\n1: Upload program to RAM\r\n");
// uart_putstr("2: Upload u-boot to Dataflash\r\n");
// uart_putstr("3: Upload Kernel to Dataflash\r\n");
// uart_putstr("4: Start u-boot\r\n");
// uart_putstr("5: Upload Filesystem image\r\n");
// uart_putstr("6: Memory test\r\n");
dispmenu = 0;
}
key = uart_getchar();
autoboot = 0;
if(key == '1'){
len = rxmodem((unsigned char *)0x800);
uart_putstr("Received ");
hexprint(len);
uart_putstr(" bytes\r\n");
// jump(0x1000);
dispmenu = 1;
}
else{
uart_putstr("Invalid input\r\n");
dispmenu = 1;
}
}
}
void auto_raw(void)
{
//while there is not a button pressed
while(!(UCSR0A & (1 << RXC0)))
{
//prints the raw vaues with a '$,' start and ',#' end
printf("$,");
printf("%d,", x_accel());
printf("%d,", y_accel());
printf("%d,", z_accel());
printf("%d,", x_gyro());
printf("%d,", y_gyro());
printf("%d,", z_gyro());
magnetometer();
printf("%d,", x_mag);
printf("%d,", y_mag);
printf("%d,", z_mag);
printf("#\n\r");
}
//if a button is pressed and that button is ctrl-z, reset autorun, display menu
if(uart_getchar() == 0x1A)
{
write_to_EEPROM(10,0);
config_menu();
}
auto_raw();
}
void PDMA_Example()
{
uint8_t unItem;
/* Init System, IP clock and multi-function I/O */
SYS_Init(); //In the end of SYS_Init() will issue SYS_LockReg() to lock protected register. If user want to write protected register, please issue SYS_UnlockReg() to unlock protected register.
/* Init UART0 for printf */
UART0_Init();
/* Init UART1 for PDMA test */
UART1_Init();
do
{
/* PDMA Sample Code: UART1 Tx/Rx Loopback */
// printf("\n\n");
printf("+------------------------------------------------------------------------+\n");
printf("| PDMA Driver Sample Code |\n");
printf("| |\n");
printf("+------------------------------------------------------------------------+\n");
printf("| [1] Using TWO PDMA channel to test. < TX1(CH1)-->RX1(CH0) > |\n");
printf("| [2] Using ONE PDMA channel to test. < TX1-->RX1(CH0) > |\n");
printf("+------------------------------------------------------------------------+\n");
unItem = uart_getchar();
IsTestOver =FALSE;
if((unItem=='1') || (unItem == '2'))
{
PDMA_UART(unItem);
// printf("\n\n PDMA sample code is complete.\n");
}
}while(unItem!=0x27);
// return 0;
}
int mymain(void)
{
// beep off
GPBCON = 0x1; // output
GPBDAT = 0x0; // Tout = 0;
// watchdog timer off
WTCON = 0;
uart_init();
uart_putchar('a');
sdram_init();
*(int *)TEST = 0x12345678;
print_addr(TEST);
while (1)
{
char c;
c = uart_getchar();
uart_putchar(c);
}
while (1);
return 0;
}
int uart_gets(char *s)
{
int cnt = 0;
while((*s++ = uart_getchar()) != UART_TCHAR) cnt++;
*s = '\0';
return cnt;
}
/*
* シリアルI/Oポートからの文字受信
*/
INT
uart_rcv_chr(SIOPCB *siopcb)
{
if (uart_getready(siopcb)) {
return((INT)(UB) uart_getchar(siopcb));
}
return(-1);
}
