//------------------------------------------------------------------------------
/// Callback invoked when data has been received on the USB.
//------------------------------------------------------------------------------
static void UsbDataReceived(unsigned int unused,
unsigned char status,
unsigned int received,
unsigned int remaining)
{
// Check that data has been received successfully
if (status == USBD_STATUS_SUCCESS) {
for(unsigned int i=0;i<received;i++) {
rb_put(&TTY_Rx_Buffer, usbBuffer[i]);
}
// Check if bytes have been discarded
if ((received == DATABUFFERSIZE) && (remaining > 0)) {
TRACE_WARNING("UsbDataReceived: %u bytes discarded\n\r",remaining);
}
}
else {
TRACE_WARNING( "UsbDataReceived: Transfer error\n\r");
}
// Restart USB read
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
}
/* worker线程入口 */
static void worker_entry(void* parameter)
{
rt_bool_t result;
rt_uint32_t index, setchar;
rt_uint8_t data_buffer[BUFFER_ITEM];
setchar = 0x21;
while (1) {
/* 构造数据 */
for(index = 0; index < BUFFER_ITEM; index++) {
data_buffer[index] = setchar;
if (++setchar == 0x7f)
setchar = 0x21;
}
/* 持有信号量 */
rt_sem_take(sem, RT_WAITING_FOREVER);
/* 把数据放到环形buffer中 */
result = rb_put(&working_rb, &data_buffer[0], BUFFER_ITEM);
/* 释放信号量 */
rt_sem_release(sem);
/* 放入成功，做一个10 OS Tick的休眠 */
rt_thread_delay(10);
}
}
void kipc_post_process(IPC* ipc, KPROCESS* sender)
{
KPROCESS* receiver = (KPROCESS*)ipc->process;
int index = -1;
bool wake = false;
IPC* cur;
CHECK_HANDLE(receiver, sizeof(KPROCESS));
CHECK_MAGIC(receiver, MAGIC_PROCESS);
if (ipc->cmd & HAL_IO_FLAG)
{
KIO* kio = (KIO*)(((IO*)ipc->param2)->kio);
CHECK_HANDLE(kio, sizeof(KIO));
CHECK_MAGIC(kio, MAGIC_KIO);
if (!kio_send(kio, receiver))
return;
}
disable_interrupts();
if ((wake = ((receiver->kipc.wait_process == sender || receiver->kipc.wait_process == (KPROCESS*)ANY_HANDLE) &&
(receiver->kipc.cmd == ipc->cmd || receiver->kipc.cmd == ANY_CMD) &&
((receiver->kipc.param1 == ipc->param1) || (receiver->kipc.param1 == ANY_HANDLE)))) == true)
{
receiver->kipc.wait_process = (KPROCESS*)INVALID_HANDLE;
}
if (!rb_is_full(&receiver->process->ipcs))
index = rb_put(&receiver->process->ipcs);
enable_interrupts();
if (index >= 0)
{
cur = KIPC_ITEM(receiver, index);
cur->cmd = ipc->cmd;
cur->param1 = ipc->param1;
cur->param2 = ipc->param2;
cur->param3 = ipc->param3;
cur->process = (HANDLE)sender;
//already waiting? Wakeup him
if (wake)
kprocess_wakeup(receiver);
}
else
{
kprocess_error(sender, ERROR_OVERFLOW);
#if (KERNEL_IPC_DEBUG)
printk("Error: receiver %s IPC overflow!\n", kprocess_name(receiver));
if (sender == (KPROCESS*)KERNEL_HANDLE)
printk("Sender: kernel\n");
else
printk("Sender: %s\n", kprocess_name((KPROCESS*)sender));
printk("cmd: %#X, p1: %#X, p2: %#X, p3: %#X\n", ipc->cmd, ipc->param1, ipc->param2, ipc->param3);
#if (KERNEL_DEVELOPER_MODE)
HALT();
#endif
#endif
}
}
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
}
void* produce(void *v){
data_t d;
int ch;
while (1){
ch = getchar();
if (rb_numitems(buffer) < BUF_SIZE){
d.msg = ch;
rb_put(buffer, &d);
}
}
return 0;
}
void *timer(void *v){
data_t d;
int i = (int)v;
while (1){
usleep(i);
if (rb_numitems(buffer) < BUF_SIZE){
d.msg = '+';
rb_put(buffer, &d);
}
}
return 0;
}
/* send telnet option to remote */
static void telnet_send_option(struct telnet_session* telnet, rt_uint8_t option, rt_uint8_t value)
{
rt_uint8_t optbuf[4];
optbuf[0] = TELNET_IAC;
optbuf[1] = option;
optbuf[2] = value;
optbuf[3] = 0;
rt_sem_take(telnet->tx_ringbuffer_lock, RT_WAITING_FOREVER);
rb_put(&telnet->tx_ringbuffer, optbuf, 3);
rt_sem_release(telnet->tx_ringbuffer_lock);
/* trigger a tx event */
rt_event_send(telnet->nw_event, NW_TX);
}
void SIM900_USART_IRQHandler(void)
{
uint8_t data = 0;
OS_CPU_SR cpu_sr;
OS_ENTER_CRITICAL();
OSIntNesting ++;
OS_EXIT_CRITICAL();
if(USART_GetITStatus(SIM900_USART, USART_IT_RXNE)
!= RESET) {
data = USART_ReceiveData(SIM900_USART);
rb_put(&rx_rb, &data, 1);
OSSemPost(rx_semaphore);
}
if(USART_GetITStatus(SIM900_USART, USART_IT_TXE)
!= RESET) {
USART_ITConfig(SIM900_USART, USART_IT_TXE, DISABLE);
}
OSIntExit();
}
void
rf_router_func(char *in)
{
if(in[1] == 0) { // u: display id and router
DH2(rf_router_myid);
DH2(rf_router_target);
DNL();
#ifdef RFR_DEBUG
} else if(in[1] == 'd') { // ud: Debug
DH((uint16_t)ticks, 4); DC('.');
DH2(rf_router_sendtime);
DNL();
} else if(in[1] == 's') { // us: Statistics
DH(nr_t,1); DC('.');
DH(nr_f,1); DC('.');
DH(nr_e,1); DC('.');
DH(nr_k,1); DC('.');
DH(nr_h,1); DC('.');
DH(nr_r,1); DC('.');
DH(nr_plus,1);
DNL();
#endif
} else if(in[1] == 'i') { // uiXXYY: set own id to XX and router id to YY
fromhex(in+2, &rf_router_myid, 1);
ewb(EE_RF_ROUTER_ID, rf_router_myid);
fromhex(in+4, &rf_router_target, 1);
ewb(EE_RF_ROUTER_ROUTER, rf_router_target);
} else { // uYYDATA: send data to node with id YY
rb_reset(&RFR_Buffer);
while(*++in)
rb_put(&RFR_Buffer, *in);
rf_router_send(0);
}
}
//------------------------------------------------------------------------------
/// Application entry point. Configures the DBGU, PIT, TC0, LEDs and buttons
/// and makes LED\#1 blink in its infinite loop, using the Wait function.
/// \return Unused (ANSI-C compatibility).
//------------------------------------------------------------------------------
int main(void)
{
// DBGU configuration
TRACE_CONFIGURE(DBGU_STANDARD, 115200, BOARD_MCK);
TRACE_INFO_WP("\n\r");
TRACE_INFO("Getting new Started Project --\n\r");
TRACE_INFO("%s\n\r", BOARD_NAME);
TRACE_INFO("Compiled: %s %s --\n\r", __DATE__, __TIME__);
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR= 0xa5<<24;
// Configure EMAC PINS
PIO_Configure(emacRstPins, PIO_LISTSIZE(emacRstPins));
// Execute reset
RSTC_SetExtResetLength(0xd);
RSTC_ExtReset();
// Wait for end hardware reset
while (!RSTC_GetNrstLevel());
TRACE_INFO("init Flash\n\r");
flash_init();
TRACE_INFO("init Timer\n\r");
// Configure timer 0
ticks=0;
extern void ISR_Timer0();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKDIS;
AT91C_BASE_TC0->TC_IDR = 0xFFFFFFFF;
AT91C_BASE_TC0->TC_SR;
AT91C_BASE_TC0->TC_CMR = AT91C_TC_CLKS_TIMER_DIV5_CLOCK | AT91C_TC_CPCTRG;
AT91C_BASE_TC0->TC_RC = 375;
AT91C_BASE_TC0->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC0, AT91C_AIC_PRIOR_LOWEST, ISR_Timer0);
AIC_EnableIT(AT91C_ID_TC0);
AT91C_BASE_TC0->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
// Configure timer 1
extern void ISR_Timer1();
AT91C_BASE_PMC->PMC_PCER = (1 << AT91C_ID_TC1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKDIS; //Stop clock
AT91C_BASE_TC1->TC_IDR = 0xFFFFFFFF; //Disable Interrupts
AT91C_BASE_TC1->TC_SR; //Read Status register
AT91C_BASE_TC1->TC_CMR = AT91C_TC_CLKS_TIMER_DIV4_CLOCK | AT91C_TC_CPCTRG; // Timer1: 2,666us = 48MHz/128
AT91C_BASE_TC1->TC_RC = 0xffff;
AT91C_BASE_TC1->TC_IER = AT91C_TC_CPCS;
AIC_ConfigureIT(AT91C_ID_TC1, 1, ISR_Timer1);
AT91C_BASE_TC1->TC_CCR = AT91C_TC_CLKEN | AT91C_TC_SWTRG;
led_init();
TRACE_INFO("init EEprom\n\r");
eeprom_init();
rb_reset(&TTY_Rx_Buffer);
rb_reset(&TTY_Tx_Buffer);
input_handle_func = analyze_ttydata;
LED_OFF();
LED2_OFF();
LED3_OFF();
spi_init();
fht_init();
tx_init();
#ifdef HAS_ETHERNET
ethernet_init();
#endif
TRACE_INFO("init USB\n\r");
CDCDSerialDriver_Initialize();
USBD_Connect();
wdt_enable(WDTO_2S);
fastrf_on=0;
display_channel = DISPLAY_USB;
TRACE_INFO("init Complete\n\r");
checkFrequency();
// Main loop
while (1) {
CDC_Task();
Minute_Task();
RfAnalyze_Task();
#ifdef HAS_FASTRF
FastRF_Task();
#endif
#ifdef HAS_RF_ROUTER
rf_router_task();
#endif
#ifdef HAS_ASKSIN
rf_asksin_task();
#endif
#ifdef HAS_MORITZ
rf_moritz_task();
#endif
#ifdef HAS_RWE
rf_rwe_task();
#endif
#ifdef HAS_MBUS
rf_mbus_task();
#endif
#ifdef HAS_MAICO
rf_maico_task();
#endif
#ifdef HAS_ETHERNET
Ethernet_Task();
#endif
#ifdef DBGU_UNIT_IN
if(DBGU_IsRxReady()){
unsigned char volatile * const ram = (unsigned char *) AT91C_ISRAM;
unsigned char x;
x=DBGU_GetChar();
switch(x) {
case 'd':
puts("USB disconnect\n\r");
USBD_Disconnect();
break;
case 'c':
USBD_Connect();
puts("USB Connect\n\r");
break;
case 'r':
//Configure Reset Controller
AT91C_BASE_RSTC->RSTC_RMR=AT91C_RSTC_URSTEN | 0xa5<<24;
break;
case 'S':
USBD_Disconnect();
my_delay_ms(250);
my_delay_ms(250);
//Reset
*ram = 0xaa;
AT91C_BASE_RSTC->RSTC_RCR = AT91C_RSTC_PROCRST | AT91C_RSTC_PERRST | AT91C_RSTC_EXTRST | 0xA5<<24;
while (1);
break;
default:
rb_put(&TTY_Tx_Buffer, x);
}
}
#endif
if (USBD_GetState() == USBD_STATE_CONFIGURED) {
if( USBState == STATE_IDLE ) {
CDCDSerialDriver_Read(usbBuffer,
DATABUFFERSIZE,
(TransferCallback) UsbDataReceived,
0);
LED3_ON();
USBState=STATE_RX;
}
}
if( USBState == STATE_SUSPEND ) {
TRACE_INFO("suspend !\n\r");
USBState = STATE_IDLE;
}
if( USBState == STATE_RESUME ) {
TRACE_INFO("resume !\n\r");
USBState = STATE_IDLE;
}
}
}
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;
}
}
//////////////////////////////////////////////////
// Display routines
void
display_char(char data)
{
#ifdef HAS_USB
if(USB_IsConnected && (output_enabled & OUTPUT_USB)) {
if(USB_Tx_Buffer->nbytes >= USB_Tx_Buffer->size)
CDC_Task();
rb_put(USB_Tx_Buffer, data);
if(data == '\n')
CDC_Task();
}
#endif
#ifdef HAS_LCD
if(output_enabled & OUTPUT_LCD) {
static uint8_t buf[TITLE_LINECHARS+1];
static uint8_t off = 0, cmdmode = 0;
if(data == '\r')
return;
if(data == '\n') {
buf[off] = 0;
off = 0;
if(cmdmode) {
callfn((char *)buf);
} else
lcd_putline(0, (char*)buf);
cmdmode = 0;
} else {
//
if(off < TITLE_LINECHARS) // or cmd: up to 12Byte: F12346448616c6c6f
buf[off++] = data;
if(cmdmode && cmdmode++ == 2) {
off -= 2;
fromhex((char *)buf+off, buf+off, 1); // replace the hexnumber
off++;
cmdmode = 1;
}
}
// Check if its a message for us: F<HC>..., and set cmdmode
if(!cmdmode && off == 5 && buf[0] == 'F') {
uint8_t hb[2];
fromhex((char*)buf+1, hb, 2);
if(hb[0] == fht_hc[0] && hb[1] == fht_hc[1]) {
cmdmode = 1;
off = 0;
}
}
}
#endif
#ifdef HAS_FS
if(output_enabled & OUTPUT_LOG) {
static uint8_t buf[LOG_NETTOLINELEN+1];
static uint8_t off = 0;
if(data == '\r')
return;
if(data == '\n') {
buf[off] = 0;
off = 0;
Log((char*)buf);
} else {
if(off < LOG_NETTOLINELEN)
buf[off++] = data;
}
}
#endif
}
void
d_s(rb_t *rb, char *s)
{
while(*s)
rb_put(rb, *s++);
}
////////////////////
// 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
}
