void stm32f_usart2_isr(void)
{
struct capture_drv * drv = &uart2_capture_drv;
struct stm32_usart * uart = STM32_USART2;
uint32_t sr;
int c;
sr = uart->sr;
if (sr & USART_RXNE) {
struct packet * pkt;
uint32_t head;
uint32_t clk;
uint32_t diff;
uint32_t cnt;
int free;
clk = profclk_get();
diff = clk - drv->rx_fifo.clk;
drv->rx_fifo.clk = clk;
c = uart->dr;
DCC_LOG1(LOG_TRACE, "%d", profclk_us(diff));
head = drv->rx_fifo.head;
pkt = &drv->rx_fifo.buf[head & (RX_FIFO_LEN - 1)];
cnt = pkt->cnt;
if ((cnt == PACKET_DATA_MAX) || (diff > drv->byte_time_max)) {
/* end of packet */
head++;
free = RX_FIFO_LEN - (uint8_t)(head - drv->rx_fifo.tail);
if (free != 0) {
drv->rx_fifo.head = head;
thinkos_sem_post_i(RX_SEM);
pkt = &drv->rx_fifo.buf[head & (RX_FIFO_LEN - 1)];
} else {
#if SERIAL_STATS_ENABLE
drv->err_cnt++;
#endif
}
pkt->seq = ++drv->rx_fifo.seq;
pkt->clk = clk - drv->byte_time;
cnt = 0;
}
pkt->data[cnt++] = c;
pkt->cnt = cnt;
} else if (sr & USART_ORE) {
#if SERIAL_STATS_ENABLE
drv->ore_cnt++;
#endif
} else if (sr & USART_FE) {
#if SERIAL_STATS_ENABLE
drv->fe_cnt++;
#endif
}
}
void capture_init(void)
{
struct capture_drv * drv = &uart2_capture_drv;
struct stm32_usart * uart = STM32_USART2;
uint32_t clk;
DCC_LOG2(LOG_TRACE, "drv=%p uart=%p...", drv, uart);
clk = profclk_get();
drv->rx_fifo.head = drv->rx_fifo.tail = 0;
drv->rx_fifo.seq = 0;
drv->rx_fifo.buf[0].clk = clk;
drv->rx_fifo.buf[0].cnt = 0;
drv->rx_fifo.buf[0].seq = 0;
drv->rx_fifo.clk = clk;
#if SERIAL_STATS_ENABLE
drv->err_cnt = 0;
drv->ore_cnt = 0;
drv->fe_cnt = 0;
#endif
drv->idle_bits = 2;
/* clock enable */
stm32_clk_enable(STM32_RCC, STM32_CLK_USART2);
/* UART --------------------------------------------------------------- */
/* Disable UART */
uart->cr1 = 0;
/* Clear pending TC and BRK interrupts */
uart->sr = 0;
uart->gtpr = 1;
capture_baudrate_set(SERIAL_BAUDRATE);
/* configure the UART */
uart->cr3 = USART_ONEBIT;
/* Configure 8N1 */
uart->cr2 = USART_STOP_1;
/* enable UART, RX and IDLE interrupts */
uart->cr1 = USART_UE | USART_RXNEIE;
/* Errors interrupt */
uart->cr3 |= USART_EIE;
/* configure interrupts */
cm3_irq_pri_set(STM32_IRQ_USART2, IRQ_PRIORITY_HIGHEST);
/* enable interrupts */
cm3_irq_enable(STM32_IRQ_USART2);
}
int js(FILE * f, char * script, unsigned int len)
{
struct symtab * symtab = (struct symtab *)slcdev_symbuf; /* symbols */
uint8_t code[512]; /* compiled code */
uint32_t sdtbuf[64]; /* compiler buffer */
int32_t stack[16]; /* exec stack */
struct microjs_sdt * microjs;
struct microjs_rt * rt;
struct microjs_vm vm;
struct symstat symstat;
uint32_t start_clk;
uint32_t stop_clk;
int code_sz;
int ret;
profclk_init();
/* initialize compiler */
if ((microjs = microjs_sdt_init(sdtbuf, sizeof(sdtbuf),
symtab, &slcdev_lib)) == NULL) {
fprintf(f, "# internal error\n");
return -1;
}
symstat = symtab_state_save(symtab);
microjs_sdt_begin(microjs, code, sizeof(code));
start_clk = profclk_get();
if ((ret = microjs_compile(microjs, script, len)) < 0) {
symtab_state_rollback(symtab, symstat);
fprintf(f, "# compile error: %d\n", -ret);
DCC_LOG1(LOG_WARNING, "compile error: %d", ret);
microjs_sdt_error(f, microjs, ret);
DCC_LOG(LOG_TRACE, "...");
return -1;
}
if ((ret = microjs_sdt_end(microjs)) < 0) {
symtab_state_rollback(symtab, symstat);
fprintf(f, "# compile error: %d\n", -ret);
DCC_LOG1(LOG_WARNING, "compile error: %d", ret);
microjs_sdt_error(f, microjs, ret);
DCC_LOG(LOG_TRACE, "...");
return -1;
}
stop_clk = profclk_get();
code_sz = ret;
rt = symtab_rt_get(symtab);
if (SLCDEV_VERBOSE()) {
fprintf(f, " - Compile time: %d us.\n",
profclk_us(stop_clk - start_clk));
fprintf(f, " - code: %d\n", code_sz);
fprintf(f, " - data: %d of %d\n", rt->data_sz, sizeof(slcdev_vm_data));
fprintf(f, " - stack: %d of %d\n", rt->stack_sz, sizeof(stack));
}
if (rt->data_sz > sizeof(slcdev_vm_data)) {
fprintf(f, "# data overlow. %d bytes required\n", rt->data_sz);
return -1;
}
if (rt->stack_sz > sizeof(stack)) {
fprintf(f, "# stack overflow. %d bytes required\n", rt->stack_sz);
return -1;
}
#if MICROJS_TRACE_ENABLED
microjs_vm_tracef = f;
#endif
/* initialize virtual machine instance */
microjs_vm_init(&vm, rt, NULL, slcdev_vm_data, stack);
start_clk = profclk_get();
if ((ret = microjs_exec(&vm, code)) != 0){
fprintf(f, "# exec error: %d\n", ret);
return -1;
}
if (SLCDEV_VERBOSE()) {
stop_clk = profclk_get();
fprintf(f, "Exec time: %d us.\n", profclk_us(stop_clk - start_clk));
}
return 0;
}
