void
analyze_ttydata()
{
static char cmdbuf[33];
static uint8_t cmdlen;
uint8_t idx, ucCommand;
while(USB_Rx_Buffer->nbytes) {
ucCommand = rb_get(USB_Rx_Buffer);
//DC(ucCommand); // echo
if(ucCommand == '\n' || ucCommand == '\r') {
if(!cmdlen) // empty return
continue;
cmdbuf[cmdlen] = 0;
if(!callfn(cmdbuf)) {
DC('?');
for(idx = 0; fntab[idx].name; idx++) {
DC(' ');
DC(fntab[idx].name);
}
DNL();
}
cmdlen = 0;
} else {
if(cmdlen < sizeof(cmdbuf)-1)
cmdbuf[cmdlen++] = ucCommand;
}
}
}
void
p(rb_t *rb)
{
uint8_t c;
while((c = rb_get(rb))) {
putchar(c);
}
putchar('\n');
}
void* consume(void* v){
data_t d;
while (1){
if (rb_numitems(buffer) > 0) {
rb_get(buffer, &d);
printf("*%c\n", d.msg);
}
}
return 0;
}
static rt_size_t telnet_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
rt_size_t result;
/* read from rx ring buffer */
rt_sem_take(telnet->rx_ringbuffer_lock, RT_WAITING_FOREVER);
result = rb_get(&(telnet->rx_ringbuffer), buffer, size);
rt_sem_release(telnet->rx_ringbuffer_lock);
return result;
}
void ring_example() {
rb_ringbuffer * buffer;
uint64_t seq_num = 0;
char * entry;
rb_init(&buffer, 4, 1024);
rb_claim(buffer, &seq_num, 1);
rb_get(buffer, &entry, seq_num);
rb_publish(buffer, seq_num, 1);
rb_release(buffer, seq_num, 1);
rb_free(&buffer);
}
void scsis_error_put(SCSIS* scsis, uint8_t key_sense, uint16_t ascq)
{
unsigned int idx;
if (rb_is_full(&scsis->rb_error))
rb_get(&scsis->rb_error);
idx = rb_put(&scsis->rb_error);
scsis->errors[idx].key_sense = key_sense;
scsis->errors[idx].ascq = ascq;
#if (SCSI_DEBUG_ERRORS)
printf("SCSI error: sense key: %02xh, ASC: %02xh, ASQ: %02xh\n", key_sense, ascq >> 8, ascq & 0xff);
#endif //SCSI_DEBUG_ERRORS
}
static void
rf_router_send(uint8_t addAddr)
{
#ifdef RFR_DEBUG
if(RFR_Buffer.buf[5] == 'T') nr_t++;
else if(RFR_Buffer.buf[5] == 'F') nr_f++;
else if(RFR_Buffer.buf[5] == 'E') nr_e++;
else if(RFR_Buffer.buf[5] == 'K') nr_k++;
else if(RFR_Buffer.buf[5] == 'H') nr_h++;
else nr_r++;
#endif
uint8_t buf[7], l = 1;
buf[0] = RF_ROUTER_PROTO_ID;
if(addAddr) {
tohex(rf_router_target, buf+1);
tohex(rf_router_myid, buf+3),
buf[5] = 'U';
l = 6;
}
rf_router_ping(); // 15ms
ccInitChip(EE_FASTRF_CFG); // 1.6ms
my_delay_ms(3); // 3ms: Found by trial and error
CC1100_ASSERT;
cc1100_sendbyte(CC1100_WRITE_BURST | CC1100_TXFIFO);
#ifdef RFR_USBECHO
uint8_t nbuf = RFR_Buffer.nbytes;
#endif
cc1100_sendbyte(RFR_Buffer.nbytes+l);
for(uint8_t i = 0; i < l; i++)
cc1100_sendbyte(buf[i]);
while(RFR_Buffer.nbytes)
cc1100_sendbyte(rb_get(&RFR_Buffer));
CC1100_DEASSERT;
ccTX();
rb_reset(&RFR_Buffer); // needed by FHT_compress
// Wait for the data to be sent
uint8_t maxwait = 20; // max 20ms
while((cc1100_readReg(CC1100_TXBYTES) & 0x7f) && maxwait--)
my_delay_ms(1);
set_txrestore();
#ifdef RFR_USBECHO
#warning RFR USB DEBUGGING IS ACTIVE
uint8_t odc = display_channel;
display_channel = DISPLAY_USB;
DC('.'); DU(nbuf, 2); DNL();
display_channel = odc;
#endif
}
void* consume(void* v){
data_t d;
int last = 0;
while (1){
if (rb_numitems(buffer) > 0) {
rb_get(buffer, &d);
if (last != 0 && d.t - last != 1){
printf("*error %d %d\r\n", d.t, last);
}
last = d.t;
}
}
return 0;
}
void scsis_error_get(SCSIS* scsis, SCSIS_ERROR *err)
{
unsigned int idx;
if (rb_is_empty(&scsis->rb_error))
{
err->key_sense = SENSE_KEY_NO_SENSE;
err->ascq = ASCQ_NO_ADDITIONAL_SENSE_INFORMATION;
}
else
{
idx = rb_get(&scsis->rb_error);
err->key_sense = scsis->errors[idx].key_sense;
err->ascq = scsis->errors[idx].ascq;
}
}
static IPC* ipc_peek(int index, IPC* ipc)
{
//cmd, process, handle
IPC tmp;
for(; index != __GLOBAL->process->ipcs.tail; index = RB_ROUND_BACK(&__GLOBAL->process->ipcs, index - 1))
{
//swap
memcpy(&tmp, IPC_ITEM(index), sizeof(IPC));
memcpy(IPC_ITEM(index), IPC_ITEM(RB_ROUND_BACK(&__GLOBAL->process->ipcs, index - 1)), sizeof(IPC));
memcpy(IPC_ITEM(RB_ROUND_BACK(&__GLOBAL->process->ipcs, index - 1)), &tmp, sizeof(IPC));
}
memcpy(ipc, IPC_ITEM(__GLOBAL->process->ipcs.tail), sizeof(IPC));
rb_get(&__GLOBAL->process->ipcs);
return ipc;
}
/* process tx data */
void telnet_process_tx(struct telnet_session* telnet, struct netconn *conn)
{
rt_size_t length;
rt_uint8_t tx_buffer[32];
while (1)
{
rt_memset(tx_buffer, 0, sizeof(tx_buffer));
rt_sem_take(telnet->tx_ringbuffer_lock, RT_WAITING_FOREVER);
/* get buffer from ringbuffer */
length = rb_get(&(telnet->tx_ringbuffer), tx_buffer, sizeof(tx_buffer));
rt_sem_release(telnet->tx_ringbuffer_lock);
/* do a tx procedure */
if (length > 0)
{
netconn_write(conn, tx_buffer, length, NETCONN_COPY);
}
else break;
}
}
void
analyze_ttydata(uint8_t channel)
{
static int cmdlen; /* we need int because TTY_BUFSIZE may be >255 */
uint8_t ucCommand;
uint8_t odc = display_channel;
display_channel = channel;
while(TTY_Rx_Buffer.nbytes) {
ucCommand = rb_get(&TTY_Rx_Buffer);
#ifdef RPI_TTY_FIX
// eat RPi rubbish
if (ucCommand == 0xff)
continue;
#endif
if(ucCommand == '\n' || ucCommand == '\r') {
if(!cmdlen) // empty return
continue;
cmdbuf[cmdlen] = 0;
if(!callfn(cmdbuf)) {
DS_P(PSTR("? ("));
display_string(cmdbuf);
DS_P(PSTR(" is unknown) Use one of"));
callfn(0);
DNL();
}
cmdlen = 0;
} else {
if(cmdlen < sizeof(cmdbuf)-1)
cmdbuf[cmdlen++] = ucCommand;
}
}
display_channel = odc;
}
//char text[] = "{\"msg_type\":\"ctr\",\"deviceid\":\"113344\",\"bcm_fun_trunklock\":\"ON\"}";
static void thread_sim900_rx_entry(void *parg)
{
INT8U err;
uint8_t start = 0;
uint8_t thischar = 0;
parg = parg;
printf("Enter: %s\r\n", __func__);
while(1) {
OSSemPend(rx_semaphore, 0, &err);
if(err != OS_NO_ERR)
continue;
while(rb_get(&rx_rb, &thischar, 1) == TRUE) {
printf("%c", thischar);
if(status == STATUS_CONNECTED) {
if(thischar == '{') {
clear_rx_buf();
start = 1;
rx_buffer[rx_offset ++] = thischar;
} else if(thischar == '}') {
rx_buffer[rx_offset ++] = thischar;
start = 0;
if(rx_offset >= 10) {
if(recvFunc != NULL)
recvFunc((uint8_t *)rx_buffer);
}
} else {
if(start)
rx_buffer[rx_offset ++] = thischar;
}
} else // init part
{
rx_buffer[rx_offset ++] = thischar;
}
}
}
}
/* 生产者线程入口 */
static void thread_entry(void* parameter)
{
rt_bool_t result;
rt_uint8_t data_buffer[BUFFER_ITEM + 1];
while (1) {
/* 持有信号量 */
rt_sem_take(sem, RT_WAITING_FOREVER);
/* 从环buffer中获得数据 */
result = rb_get(&working_rb, &data_buffer[0], BUFFER_ITEM);
/* 释放信号量 */
rt_sem_release(sem);
data_buffer[BUFFER_ITEM] = '\0';
if (result == RT_TRUE) {
/* 获取数据成功，打印数据 */
rt_kprintf("%s\n", data_buffer);
}
/* 做一个5 OS Tick的休眠 */
rt_thread_delay(5);
}
}
void
rf_router_task(void)
{
if(rf_router_status == RF_ROUTER_INACTIVE)
return;
uint8_t hsec = (uint8_t)ticks;
if(rf_router_status == RF_ROUTER_GOT_DATA) {
uint8_t len = cc1100_readReg(CC1100_RXFIFO);
uint8_t proto = 0;
if(len > 5) {
rb_reset(&TTY_Rx_Buffer);
CC1100_ASSERT;
cc1100_sendbyte( CC1100_READ_BURST | CC1100_RXFIFO );
proto = cc1100_sendbyte(0);
while(--len)
rb_put(&TTY_Rx_Buffer, cc1100_sendbyte(0));
CC1100_DEASSERT;
}
set_txrestore();
rf_router_status = RF_ROUTER_INACTIVE;
if(proto == RF_ROUTER_PROTO_ID) {
uint8_t id;
if(fromhex(TTY_Rx_Buffer.buf, &id, 1) == 1 && // it is for us
id == rf_router_myid) {
if(TTY_Rx_Buffer.buf[4] == 'U') { // "Display" the data
while(TTY_Rx_Buffer.nbytes) // downlink: RFR->CUL
DC(rb_get(&TTY_Rx_Buffer));
DNL();
} else { // uplink: CUL->RFR
TTY_Rx_Buffer.nbytes -= 4; // Skip dest/src bytes
TTY_Rx_Buffer.getoff = 4;
rb_put(&TTY_Rx_Buffer, '\n');
input_handle_func(DISPLAY_RFROUTER); // execute the command
}
} else {
rb_reset(&TTY_Rx_Buffer);
}
}
} else if(rf_router_status == RF_ROUTER_DATA_WAIT) {
uint8_t diff = hsec - rf_router_hsec;
if(diff > 7) { // 3 (delay above) + 3 ( ((4+64)*8)/250kBaud )
set_txrestore();
rf_router_status = RF_ROUTER_INACTIVE;
}
} else if(rf_router_status == RF_ROUTER_SYNC_RCVD) {
ccInitChip(EE_FASTRF_CFG);
ccRX();
rf_router_status = RF_ROUTER_DATA_WAIT;
rf_router_hsec = hsec;
}
}
////////////////////
// Fill data from USB to the RingBuffer and vice-versa
void
CDC_Task(void)
{
static char inCDC_TASK = 0;
if(!USB_IsConnected)
return;
#ifdef ARM
if(!inCDC_TASK){ // USB -> RingBuffer
inCDC_TASK = 1;
output_flush_func = CDC_Task;
input_handle_func(DISPLAY_USB);
inCDC_TASK = 0;
}
if(TTY_Tx_Buffer.nbytes) {
uint16_t i=0;
while(TTY_Tx_Buffer.nbytes && i<DATABUFFERSIZEOUT) {
usbBufferOut[i++]=rb_get(&TTY_Tx_Buffer);
}
while (CDCDSerialDriver_Write(usbBufferOut,i, 0, 0) != USBD_STATUS_SUCCESS);
}
#else
Endpoint_SelectEndpoint(CDC_RX_EPNUM); // First data in
if(!inCDC_TASK && Endpoint_ReadWriteAllowed()){ // USB -> RingBuffer
while (Endpoint_BytesInEndpoint()) { // Discard data on buffer full
rb_put(&TTY_Rx_Buffer, Endpoint_Read_Byte());
}
Endpoint_ClearCurrentBank();
inCDC_TASK = 1;
output_flush_func = CDC_Task;
input_handle_func(DISPLAY_USB);
inCDC_TASK = 0;
}
Endpoint_SelectEndpoint(CDC_TX_EPNUM); // Then data out
if(TTY_Tx_Buffer.nbytes && Endpoint_ReadWriteAllowed()) {
cli();
while(TTY_Tx_Buffer.nbytes &&
(Endpoint_BytesInEndpoint() < USB_BUFSIZE))
Endpoint_Write_Byte(rb_get(&TTY_Tx_Buffer));
sei();
Endpoint_ClearCurrentBank(); // Send the data
}
#endif
}
