//uart job reads the base station state from bluetooth
void handle_bluetooth(void * pointer){
struct remote_state * rstate = (struct remote_state *)pointer;
pin_outputable(PIN_26);
for (;;) {
for (;;) {
pin_low(PIN_26);
//read from uart
unsigned char b;
size_t num;
if (uart_recv(rstate->bluetooth_uart, &b, 1, &num, 0)!=0) error();
if (num !=1 ) continue;
//try to find the framing byte (uint 255)
if (b != 255U) continue;
break;
}
pin_high(PIN_26);
unsigned char buffer [4];
size_t num;
if (uart_recv(rstate->bluetooth_uart, buffer, sizeof(buffer), &num, 0)!=0) error();
if (num != sizeof(buffer)) continue;
uint8_t x;
memcpy(&x, buffer, 1);
uint8_t y;
memcpy(&y, buffer+1, 1);
uint8_t button;
memcpy(&button, buffer+2, 1);
uint8_t is_automatic_mode;
memcpy(&is_automatic_mode, buffer+3, 1);
if (mutex_lock(rstate->mutex) != 0) error();
if (rstate->is_dead) {
rstate->joy_x = 127;
rstate->joy_y = 127;
rstate->button_pressed = 0;
rstate->is_automatic_mode = 0;
} else {
rstate->joy_x = x;
rstate->joy_y = y;
rstate->button_pressed = button;
rstate->is_automatic_mode = is_automatic_mode;
}
if (mutex_unlock(rstate->mutex) != 0) error();
}
}
void TRACEUART_ISR(void)
{
uint32_t flush = uart_is_interrupt_source(TRACEUART, UART_INT_RT);
while (!uart_is_rx_fifo_empty(TRACEUART)) {
uint32_t c = uart_recv(TRACEUART);
/* If the next increment of rx_in would put it at the same point
* as rx_out, the FIFO is considered full.
*/
if (((buf_rx_in + 1) % FIFO_SIZE) != buf_rx_out)
{
/* insert into FIFO */
buf_rx[buf_rx_in++] = c;
/* wrap out pointer */
if (buf_rx_in >= FIFO_SIZE)
{
buf_rx_in = 0;
}
} else {
flush = 1;
break;
}
}
if (flush) {
/* advance fifo out pointer by amount written */
trace_buf_push();
}
}
static int8_t bootloader_query_hex(uint32_t *val)
{
uint32_t tmp = 0;
int c;
while (1) {
c = uart_recv();
echo(c);
if (c == '\n' || c == '\r') {
*val = tmp;
return 0;
}
else if (c >= '0' && c <= '9') {
tmp <<= 4;
tmp += (c - '0');
}
else if (c >= 'a' && c <= 'f') {
tmp <<= 4;
tmp += (c - 'a' + 10);
}
else if (c >= 'A' && c <= 'F') {
tmp <<= 4;
tmp += (c - 'A' + 10);
}
else
return -1;
}
return 0;
}
/*
* Read a character from the UART RX and stuff it in a software FIFO.
* Allowed to read from FIFO out pointer, but not write to it.
* Allowed to write to FIFO in pointer.
*/
void USBUART_ISR(void)
{
int flush = uart_is_interrupt_source(USBUART, UART_INT_RT);
while (!uart_is_rx_fifo_empty(USBUART)) {
char c = uart_recv(USBUART);
/* If the next increment of rx_in would put it at the same point
* as rx_out, the FIFO is considered full.
*/
if (((buf_rx_in + 1) % FIFO_SIZE) != buf_rx_out)
{
/* insert into FIFO */
buf_rx[buf_rx_in++] = c;
/* wrap out pointer */
if (buf_rx_in >= FIFO_SIZE)
{
buf_rx_in = 0;
}
} else {
flush = 1;
}
}
if (flush) {
/* forcibly empty fifo if no USB endpoint */
if (cdcacm_get_config() != 1)
{
buf_rx_out = buf_rx_in;
return;
}
uint8_t packet_buf[CDCACM_PACKET_SIZE];
uint8_t packet_size = 0;
uint8_t buf_out = buf_rx_out;
/* copy from uart FIFO into local usb packet buffer */
while (buf_rx_in != buf_out && packet_size < CDCACM_PACKET_SIZE)
{
packet_buf[packet_size++] = buf_rx[buf_out++];
/* wrap out pointer */
if (buf_out >= FIFO_SIZE)
{
buf_out = 0;
}
}
/* advance fifo out pointer by amount written */
buf_rx_out += usbd_ep_write_packet(usbdev,
CDCACM_UART_ENDPOINT, packet_buf, packet_size);
buf_rx_out %= FIFO_SIZE;
}
}
static unsigned char getbyte(void) {
unsigned t0 = timer_tick();
// while uart not ready, just keep going; nak every 4 sec
while(((uart_lcr() & 0x01) == 0)) {
unsigned t = timer_tick();
if ((t - t0) >= 4000000) {
uart_send(NAK);
t0 = t;
}
}
return uart_recv();
}
/*
* uart0_isr is declared as a weak function. When we override it here, the
* libopencm3 build system takes care that it becomes our UART0 ISR.
*/
void uart0_isr(void)
{
uint8_t rx;
uint32_t irq_clear = 0;
if (uart_is_interrupt_source(UART0, UART_INT_RX)) {
rx = uart_recv(UART0);
uart_send(UART0, rx);
irq_clear |= UART_INT_RX;
}
uart_clear_interrupt_flag(UART0, irq_clear);
}
void kernel_main(void)
{
uart_init();
init_printf(0, putc);
irq_vector_init();
timer_init();
enable_interrupt_controller();
enable_irq();
while (1){
uart_send(uart_recv());
}
}
/*
* Poll for data. If RXNE, receive the packet. If TXE, see if there's another
* packet to transmit.
*/
void uart_platform_poll(void)
{
u8 *dr;
if (GP_USART->SR & USART_SR_RXNE) {
uart_recv(GP_USART->DR & 0xff);
}
if (GP_USART->SR & USART_SR_TXE) {
dr = uart_tx();
if (dr != NULL) {
GP_USART->DR = *dr & 0xff;
}
}
}
//------------------------------------------------------------------------
void notmain ( void )
{
unsigned int ra;
uart_init();
hexstring(0x87654321);
switch_to_mosc();
hexstring(0x12345678);
while(1)
{
ra=uart_recv();
if(ra==0x0D) uart_send(0x0A);
uart_send(ra);
}
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
clock_init();
uart_init();
hexstrings(0x1234); hexstring(0xABCD);
hexstring(GET32(0x1FFFF7AC));
hexstring(GET32(0x1FFFF7B0));
hexstring(GET32(0x1FFFF7CC));
hexstring(GET32(0x40015800));
while(1)
{
ra=uart_recv();
uart_send(ra);
if(ra==0x0D) uart_send(0x0A);
}
return(0);
}
void USART1_IRQHandler(void)
{
int ch=-1;
char dat;
if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
{
while (1)
{
ch = uart_recv(&dat);
if (ch == 0xff)
{
uart_send(dat);
break;
}
}
/* clear interrupt */
USART_ClearITPendingBit(USART1, USART_IT_RXNE);
}
if (USART_GetITStatus(USART1, USART_IT_TC) != RESET)
{
/* clear interrupt */
USART_ClearITPendingBit(USART1, USART_IT_TC);
}
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
//unsigned int rb;
unsigned int rx;
unsigned int addr;
unsigned int block;
unsigned int crc;
PUT32(AUX_ENABLES,1);
PUT32(AUX_MU_IER_REG,0);
PUT32(AUX_MU_CNTL_REG,0);
PUT32(AUX_MU_LCR_REG,3);
PUT32(AUX_MU_MCR_REG,0);
PUT32(AUX_MU_IER_REG,0);
PUT32(AUX_MU_IIR_REG,0xC6);
PUT32(AUX_MU_BAUD_REG,270);
ra=GET32(GPFSEL1);
ra&=~(7<<12); //gpio14
ra|=2<<12; //alt5
ra&=~(7<<15); //gpio15
ra|=2<<15; //alt5
PUT32(GPFSEL1,ra);
PUT32(GPPUD,0);
for(ra=0;ra<150;ra++) dummy(ra);
PUT32(GPPUDCLK0,(1<<14)|(1<<15));
for(ra=0;ra<150;ra++) dummy(ra);
PUT32(GPPUDCLK0,0);
PUT32(AUX_MU_CNTL_REG,3);
PUT32(ARM_TIMER_CTL,0x00F90000);
PUT32(ARM_TIMER_CTL,0x00F90200);
hexstring(0x12345678);
//SOH 0x01
//ACK 0x06
//NAK 0x15
//EOT 0x04
//block numbers start with 1
//132 byte packet
//starts with SOH
//block number byte
//255-block number
//128 bytes of data
//checksum byte (whole packet)
//a single EOT instead of SOH when done, send an ACK on it too
//this is a very crude solution, worked for a small test program though
//if it slips one byte it is all over. Need to make a more robust
//solution.
rx=GET32(ARM_TIMER_CNT);
while(1)
{
ra=GET32(ARM_TIMER_CNT);
if((ra-rx)>=4000000)
{
uart_send(0x15);
rx+=4000000;
}
if(GET32(AUX_MU_LSR_REG)&0x01) break;
}
block=1;
addr=ARMBASE;
while(1)
{
xstring[0]=uart_recv();
if(xstring[0]==0x04)
{
uart_send(0x06);
break;
}
if(xstring[0]!=0x01) break;
crc=0x01;
for(ra=1;ra<132;ra++)
{
xstring[ra]=uart_recv();
crc+=xstring[ra];
}
if(xstring[2]!=(255-xstring[1])) break;
crc-=xstring[131];
crc&=0xFF;
if(xstring[131]!=crc)
{
uart_send(0x15);
}
for(ra=0;ra<128;ra++)
{
PUT8(addr++,xstring[ra+3]);
}
if(addr>0x200000)
{
uart_send(0x15);
break;
}
uart_send(0x06);
block=(block+1)&0xFF;
}
if(xstring[0]==0x04)
{
BRANCHTO(ARMBASE);
}
return(0);
}
int uart_dev_recv(FILE *fp)
{
return uart_recv(fdev_get_udata(fp));
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
//unsigned int rb;
unsigned int rx;
unsigned int addr;
unsigned int block;
unsigned int state;
unsigned int crc;
uart_init();
hexstring(0x12345678);
hexstring(GETPC());
timer_init();
//SOH 0x01
//ACK 0x06
//NAK 0x15
//EOT 0x04
//block numbers start with 1
//132 byte packet
//starts with SOH
//block number byte
//255-block number
//128 bytes of data
//checksum byte (whole packet)
//a single EOT instead of SOH when done, send an ACK on it too
block=1;
addr=ARMBASE;
state=0;
crc=0;
rx=timer_tick();
while(1)
{
ra=timer_tick();
if((ra-rx)>=4000000)
{
uart_send(0x15);
rx+=4000000;
}
if((uart_lcr()&0x01)==0) continue;
xstring[state]=uart_recv();
rx=timer_tick();
if(state==0)
{
if(xstring[state]==0x04)
{
uart_send(0x06);
BRANCHTO(ARMBASE);
break;
}
}
switch(state)
{
case 0:
{
if(xstring[state]==0x01)
{
crc=xstring[state];
state++;
}
else
{
//state=0;
uart_send(0x15);
}
break;
}
case 1:
{
if(xstring[state]==block)
{
crc+=xstring[state];
state++;
}
else
{
state=0;
uart_send(0x15);
}
break;
}
case 2:
{
if(xstring[state]==(0xFF-xstring[state-1]))
{
crc+=xstring[state];
state++;
}
else
{
uart_send(0x15);
state=0;
}
break;
}
case 131:
{
crc&=0xFF;
if(xstring[state]==crc)
{
for(ra=0;ra<128;ra++)
{
PUT8(addr++,xstring[ra+3]);
}
uart_send(0x06);
block=(block+1)&0xFF;
}
else
{
uart_send(0x15);
}
state=0;
break;
}
default:
{
crc+=xstring[state];
state++;
break;
}
}
}
return(0);
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int state;
unsigned int byte_count;
unsigned int address;
unsigned int record_type;
unsigned int segment;
unsigned int data;
unsigned int sum;
unsigned int ra;
leds_off();
uart_init();
hexstring(0x12345678);
hexstring(GETPC());
uart_send('I');
uart_send('H');
uart_send('E');
uart_send('X');
uart_send(0x0D);
uart_send(0x0A);
state=0;
segment=0;
sum=0;
data=0;
record_type=0;
address=0;
byte_count=0;
while(1)
{
ra=uart_recv();
if(ra==':')
{
state=1;
continue;
}
if(ra==0x0D)
{
state=0;
continue;
}
if(ra==0x0A)
{
state=0;
continue;
}
if((ra=='g')||(ra=='G'))
{
uart_send(0x0D);
uart_send('-');
uart_send('-');
uart_send(0x0D);
uart_send(0x0A);
uart_send(0x0A);
BRANCHTO(0x8000);
state=0;
break;
}
switch(state)
{
case 0:
{
break;
}
case 1:
case 2:
{
byte_count<<=4;
if(ra>0x39) ra-=7;
byte_count|=(ra&0xF);
byte_count&=0xFF;
state++;
break;
}
case 3:
case 4:
case 5:
case 6:
{
address<<=4;
if(ra>0x39) ra-=7;
address|=(ra&0xF);
address&=0xFFFF;
address|=segment;
state++;
break;
}
case 7:
{
record_type<<=4;
if(ra>0x39) ra-=7;
record_type|=(ra&0xF);
record_type&=0xFF;
state++;
break;
}
case 8:
{
record_type<<=4;
if(ra>0x39) ra-=7;
record_type|=(ra&0xF);
record_type&=0xFF;
switch(record_type)
{
case 0x00:
{
state=14;
break;
}
case 0x01:
{
hexstring(sum);
state=0;
break;
}
case 0x02:
{
state=9;
break;
}
default:
{
state=0;
break;
}
}
break;
}
case 9:
case 10:
case 11:
case 12:
{
segment<<=4;
if(ra>0x39) ra-=7;
segment|=(ra&0xF);
segment&=0xFFFF;
state++;
break;
}
case 13:
{
segment<<=4;
state=0;
break;
}
case 14:
case 15:
case 16:
case 17:
case 18:
case 19:
case 20:
case 21:
{
data<<=4;
if(ra>0x39) ra-=7;
data|=(ra&0xF);
if(state==21)
{
ra=(data>>24)|(data<<24);
ra|=(data>>8)&0x0000FF00;
ra|=(data<<8)&0x00FF0000;
data=ra;
PUT32(address,data);
sum+=address;
sum+=data;
address+=4;
state=14;
}
else
{
state++;
}
break;
}
}
int main(void)
{
#ifndef HOST_VERSION
/* brake */
BRAKE_DDR();
BRAKE_OFF();
/* CPLD reset on PG3 */
DDRG |= 1<<3;
PORTG &= ~(1<<3); /* implicit */
/* LEDS */
DDRJ |= 0x0c;
DDRL = 0xc0;
LED1_OFF();
LED2_OFF();
LED3_OFF();
LED4_OFF();
#endif
memset(&gen, 0, sizeof(gen));
memset(&mainboard, 0, sizeof(mainboard));
mainboard.flags = DO_ENCODERS | DO_CS | DO_RS |
DO_POS | DO_POWER | DO_BD | DO_ERRBLOCKING;
ballboard.lcob = I2C_COB_NONE;
ballboard.rcob = I2C_COB_NONE;
/* UART */
uart_init();
uart_register_rx_event(CMDLINE_UART, emergency);
#ifndef HOST_VERSION
#if CMDLINE_UART == 3
fdevopen(uart3_dev_send, uart3_dev_recv);
#elif CMDLINE_UART == 1
fdevopen(uart1_dev_send, uart1_dev_recv);
#endif
/* check eeprom to avoid to run the bad program */
if (eeprom_read_byte(EEPROM_MAGIC_ADDRESS) !=
EEPROM_MAGIC_MAINBOARD) {
int c;
sei();
printf_P(PSTR("Bad eeprom value ('f' to force)\r\n"));
c = uart_recv(CMDLINE_UART);
if (c == 'f')
eeprom_write_byte(EEPROM_MAGIC_ADDRESS, EEPROM_MAGIC_MAINBOARD);
wait_ms(100);
bootloader();
}
#endif /* ! HOST_VERSION */
/* LOGS */
error_register_emerg(mylog);
error_register_error(mylog);
error_register_warning(mylog);
error_register_notice(mylog);
error_register_debug(mylog);
#ifndef HOST_VERSION
/* SPI + ENCODERS */
encoders_spi_init(); /* this will also init spi hardware */
/* I2C */
i2c_init(I2C_MODE_MASTER, I2C_MAINBOARD_ADDR);
i2c_protocol_init();
i2c_register_recv_event(i2c_recvevent);
i2c_register_send_event(i2c_sendevent);
/* TIMER */
timer_init();
timer0_register_OV_intr(main_timer_interrupt);
/* PWM */
PWM_NG_TIMER_16BITS_INIT(1, TIMER_16_MODE_PWM_10,
TIMER1_PRESCALER_DIV_1);
PWM_NG_TIMER_16BITS_INIT(4, TIMER_16_MODE_PWM_10,
TIMER4_PRESCALER_DIV_1);
PWM_NG_INIT16(&gen.pwm1_4A, 4, A, 10, PWM_NG_MODE_SIGNED,
&PORTD, 4);
PWM_NG_INIT16(&gen.pwm2_4B, 4, B, 10, PWM_NG_MODE_SIGNED |
PWM_NG_MODE_SIGN_INVERTED, &PORTD, 5);
PWM_NG_INIT16(&gen.pwm3_1A, 1, A, 10, PWM_NG_MODE_SIGNED,
&PORTD, 6);
PWM_NG_INIT16(&gen.pwm4_1B, 1, B, 10, PWM_NG_MODE_SIGNED,
&PORTD, 7);
/* servos */
PWM_NG_TIMER_16BITS_INIT(3, TIMER_16_MODE_PWM_10,
TIMER1_PRESCALER_DIV_256);
PWM_NG_INIT16(&gen.servo1, 3, C, 10, PWM_NG_MODE_NORMAL,
NULL, 0);
PWM_NG_TIMER_16BITS_INIT(5, TIMER_16_MODE_PWM_10,
TIMER1_PRESCALER_DIV_256);
PWM_NG_INIT16(&gen.servo2, 5, A, 10, PWM_NG_MODE_NORMAL,
NULL, 0);
PWM_NG_INIT16(&gen.servo3, 5, B, 10, PWM_NG_MODE_NORMAL,
NULL, 0);
PWM_NG_INIT16(&gen.servo4, 5, C, 10, PWM_NG_MODE_NORMAL,
NULL, 0);
support_balls_deploy(); /* init pwm for servos */
#endif /* !HOST_VERSION */
/* SCHEDULER */
scheduler_init();
#ifdef HOST_VERSION
hostsim_init();
robotsim_init();
#endif
#ifndef HOST_VERSION
scheduler_add_periodical_event_priority(do_led_blink, NULL,
100000L / SCHEDULER_UNIT,
LED_PRIO);
#endif /* !HOST_VERSION */
/* all cs management */
microb_cs_init();
/* TIME */
time_init(TIME_PRIO);
/* sensors, will also init hardware adc */
sensor_init();
#ifndef HOST_VERSION
/* start i2c slave polling */
scheduler_add_periodical_event_priority(i2c_poll_slaves, NULL,
8000L / SCHEDULER_UNIT, I2C_POLL_PRIO);
#endif /* !HOST_VERSION */
/* strat */
gen.logs[0] = E_USER_STRAT;
gen.log_level = 5;
/* strat-related event */
scheduler_add_periodical_event_priority(strat_event, NULL,
25000L / SCHEDULER_UNIT,
STRAT_PRIO);
#ifndef HOST_VERSION
/* eeprom time monitor */
scheduler_add_periodical_event_priority(do_time_monitor, NULL,
1000000L / SCHEDULER_UNIT,
EEPROM_TIME_PRIO);
#endif /* !HOST_VERSION */
sei();
strat_db_init();
printf_P(PSTR("\r\n"));
printf_P(PSTR("Respect et robustesse.\r\n"));
#ifndef HOST_VERSION
{
uint16_t seconds;
seconds = eeprom_read_word(EEPROM_TIME_ADDRESS);
printf_P(PSTR("Running since %d mn %d\r\n"), seconds/60, seconds%60);
}
#endif
#ifdef HOST_VERSION
strat_reset_pos(400, COLOR_Y(400), COLOR_A(-90));
#endif
cmdline_interact();
return 0;
}
//------------------------------------------------------------------------
int do_nmea ( void )
{
unsigned int ra;
unsigned int rb;
unsigned int rc;
unsigned int state;
unsigned int off;
//unsigned char toggle_seconds;
//toggle_seconds=0;
state=0;
off=0;
//$GPRMC,054033.00,V,
while(1)
{
ra=uart_recv();
//**/ uart_putc(ra);
//uart_putc(0x30+state);
switch(state)
{
case 0:
{
if(ra=='$') state++;
else state=0;
break;
}
case 1:
{
if(ra=='G') state++;
else state=0;
break;
}
case 2:
{
if(ra=='P') state++;
else state=0;
break;
}
case 3:
{
if(ra=='R') state++;
else state=0;
break;
}
case 4:
{
if(ra=='M') state++;
else state=0;
break;
}
case 5:
{
if(ra=='C') state++;
else state=0;
break;
}
case 6:
{
off=0;
if(ra==',') state++;
else state=0;
break;
}
case 7:
{
if(ra==',')
{
if(off>7)
{
rb=xstring[0]&0xF;
rc=xstring[1]&0xF;
//1010
rb=/*rb*10*/(rb<<3)+(rb<<1); //times 10
rb+=rc;
if(rb>12) rb-=12;
ra=5; //time zone adjustment
if(rb<=ra) rb+=12;
rb-=ra;
if(rb>9)
{
xstring[0]='1';
rb-=10;
}
else
{
xstring[0]='0';
}
rb&=0xF;
xstring[1]=0x30+rb;
rb=0;
//zstring[rb++]=0x77;
//toggle_seconds^=0x10;
//zstring[rb++]=toggle_seconds;
//zstring[rb++]=xstring[0];
//zstring[rb++]=xstring[1];
//zstring[rb++]=xstring[2];
//zstring[rb++]=xstring[3];
//xstring[rb++]=0x0D;
//zstring[rb++]=0;
tim[0]=xstring[0]&0xF;
tim[1]=xstring[1]&0xF;
tim[2]=xstring[2]&0xF;
tim[3]=xstring[3]&0xF;
}
else
{
//zstring[0]=0x33;
//zstring[1]=0x33;
//zstring[2]=0x33;
//zstring[3]=0x33;
//xstring[4]=0x0D;
//zstring[5]=0;
tim[0]=0;
tim[1]=0;
tim[2]=0;
tim[3]=0;
}
off=0;
state++;
}
else
{
if(off<16)
{
xstring[off++]=ra;
}
}
break;
}
case 8:
{
//if(zstring[off]==0)
//{
//state=0;
//}
//else
//{
//uart_send(zstring[off++]);
//}
show_time();
state=0;
break;
}
}
}
return(0);
}
void log_event(struct error * e, ...)
{
PGM_P txt_sev;
uint16_t flags;
va_list ap;
time_h tv;
if( e->severity > log_level)
return;
// save flags
flags = stdout->flags;
va_start(ap, e);
tv = time_get_time();
// print timestamp
printf_P(PSTR("%ld.%3.3ld | "), tv.s, (tv.us/1000UL));
// print severity
switch(e->severity)
{
case ERROR_SEVERITY_EMERG : txt_sev = PSTR(ERROR_SEVTEXT_EMERG); break;
case ERROR_SEVERITY_ERROR : txt_sev = PSTR(ERROR_SEVTEXT_ERROR); break;
case ERROR_SEVERITY_WARNING : txt_sev = PSTR(ERROR_SEVTEXT_WARNING); break;
case ERROR_SEVERITY_NOTICE : txt_sev = PSTR(ERROR_SEVTEXT_NOTICE); break;
case ERROR_SEVERITY_DEBUG : txt_sev = PSTR(ERROR_SEVTEXT_DEBUG); break;
default : txt_sev = PSTR("XXX"); break;
}
printf_P(txt_sev);
printf_P(PSTR(": "));
// print message
vfprintf_P(stdout,e->text,ap);
printf_P(PSTR("\n"));
va_end(ap);
// restore flags
stdout->flags = flags;
// dead end
if( (e->severity == ERROR_SEVERITY_ERROR)
||(e->severity == ERROR_SEVERITY_EMERG) )
{
printf_P(PSTR("\nprogram stopped, strike a key other than 'x' to reset\n"));
#if 0 //TODO:temp
//XXX Add shutdown procedures here XXX
// breaking motors
motor_cs_break(1);
// killing cs & position tasks
scheduler_del_event(event_cs);
// wait for key
uint8_t key;
while(1)
{
key = cli_getkey();
if( (key == -1)||(key == 'x'))
continue;
break;
}
#endif
uart_recv(1);
// reset MCU
reset();
}
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
unsigned int command;
clock_init();
uart_init();
hexstrings(0x1234); hexstring(0xABCD);
hexstring(GET32(0x1FFFF7AC));
hexstring(GET32(0x1FFFF7B0));
hexstring(GET32(0x1FFFF7CC));
hexstring(GET32(0x40015800));
ra=GET32(RCC_AHBENR);
ra|=1<<19; //enable port C
PUT32(RCC_AHBENR,ra);
//moder
ra=GET32(GPIOC_MODER);
ra&=~(3<<26); //PC13
//ra|=0<<26; //PC13
PUT32(GPIOC_MODER,ra);
//pupdr
ra=GET32(GPIOC_PUPDR);
ra&=~(3<<26); //PC13
PUT32(GPIOC_PUPDR,ra);
//leds/drive
ra=GET32(RCCBASE+0x14);
ra|=1<<19; //enable port C
PUT32(RCCBASE+0x14,ra);
//moder
ra=GET32(GPIOCBASE+0x00);
ra&=~(3<<16); //PC8
ra&=~(3<<18); //PC9
ra|=1<<16; //PC8
ra|=1<<18; //PC9
PUT32(GPIOCBASE+0x00,ra);
//OTYPER
ra=GET32(GPIOCBASE+0x04);
ra&=~(1<<8); //PC8
ra&=~(1<<9); //PC9
PUT32(GPIOCBASE+0x04,ra);
//ospeedr
ra=GET32(GPIOCBASE+0x08);
ra|=3<<16; //PC8
ra|=3<<18; //PC8
PUT32(GPIOCBASE+0x08,ra);
//pupdr
ra=GET32(GPIOCBASE+0x0C);
ra&=~(3<<16); //PC8
ra&=~(3<<18); //PC9
PUT32(GPIOCBASE+0x0C,ra);
PUT32(STK_CSR,0x00000004);
PUT32(STK_RVR,0xFFFFFFFF);
PUT32(STK_CSR,0x00000005);
//timer counts down, 24 bit
command=4000;
do_command(command);
while(1)
{
ra=uart_recv();
switch(ra)
{
case 'z':
case 'Z':
{
command-=1000;
if(command<LOWER) command=LOWER;
break;
}
case 'x':
case 'X':
{
command+=1000;
if(command>UPPER) command=UPPER;
break;
}
case 'a':
case 'A':
{
command-=100;
if(command>UPPER) command=UPPER;
break;
}
case 's':
case 'S':
{
command+=100;
if(command>UPPER) command=UPPER;
break;
}
case 'q':
case 'Q':
{
command-=10;
if(command>UPPER) command=UPPER;
break;
}
case 'w':
case 'W':
{
command+=10;
if(command>UPPER) command=UPPER;
break;
}
case '1':
{
command-=1;
if(command>UPPER) command=UPPER;
break;
}
case '2':
{
command+=1;
if(command>UPPER) command=UPPER;
break;
}
}
hexstring(command);
do_command(command);
}
return(0);
}
static uint8_t uart_recv_one_byte(void)
{
rx_chars++;
return uart_recv(UART0);
}
int uart_get(FILE *f) {
return uart_recv();
}