void server_non_blocking_rx (int fd)
{
int i;
n = recvfrom (sock, buf, 1024, 0, (struct sockaddr *) &from, &fromlen);
if (n > 0) {
if(reply_mode==STATIC_CLIENT)
{
if(from.sin_addr.s_addr != client.sin_addr.s_addr)
{
printf( "Reject packet\r\n" );
return;
}
}
bcopy(&from,&client,sizeof(struct sockaddr));
got_connection = 1;
if (debug==1) {
printf ("\nRX: %d [",n);
for (i = 0; i < n; i++)
printf ("%x ", buf[i]);
printf ("]\n");
}
slip_tx (fd, buf, n);
}
}
uint8_t dprot_master_send_ping ( void )
{
uint8_t ret = 0;
uint8_t retry = DPROT_MASTER_NUM_RETRIES;
uint8_t buffer[3] = { DROPT_TYPE_ARP, 0, 0 };
// advance the parity and embed it
master_last_parity = !master_last_parity;
buffer[0] |= master_last_parity;
// calculate checking
DPROT_CHECKING(buffer[2],buffer[0]);
DPROT_CHECKING(buffer[2],buffer[1]);
while (retry--)
{
slip_tx(&master_channel, buffer, 3, SLIP_MSG_REG);
// wait for response
ret = dprot_master_wait_for_ack_nack ( );
if (ret == DPROT_ACK_ACCEPTED)
{
// stop trying
break;
}
}
return ret;
}
uint8_t dprot_master_send_data_msg (uint8_t* buffer, uint8_t len)
{
uint8_t i;
uint8_t ret = 0;
uint8_t calc_check = 0;
uint8_t retry = DPROT_MASTER_NUM_RETRIES;
uint8_t header[2] = { DPROT_TYPE_DATA, len };
if (len > DPROT_MAX_PAYLOAD)
{
// the buffer is bigger than the maximal allowed
// transaction size
return DPROT_MSG_SIZE_ERROR;
}
// calculate the checking
DPROT_CHECKING(calc_check,header[0]);
DPROT_CHECKING(calc_check,header[1]);
for (i = 0; i < len; i++)
{
DPROT_CHECKING(calc_check,buffer[i]);
}
while (retry--)
{
// finally send the data
slip_tx(&master_channel, header, 2, SLIP_MSG_START);
slip_tx(&master_channel, buffer, len, SLIP_MSG_MIDDLE);
slip_tx(&master_channel, &calc_check, 1, SLIP_MSG_END);
// wait for response
ret = dprot_master_wait_for_ack_nack ( );
if (ret == DPROT_ACK_ACCEPTED)
{
// stop trying
break;
}
}
return ret;
}
void server_non_blocking_rx (int fd)
{
struct sockaddr_in from;
int n = recvfrom (sock, buf, 1024, 0, (struct sockaddr *) &from, (socklen_t *) &fromlen);
if (n > 0) {
bcopy(&from,&client,sizeof(struct sockaddr));
got_connection = 1;
slip_tx (fd, buf, n);
}
}
void Task3 ()
{
int8_t v;
uint8_t pckts=0;
printf ("radio stuff Task3 PID=%d\r\n", nrk_get_pid ());
while (slip_started () != 1)
nrk_wait_until_next_period ();
while (1) {
v = slip_rx (slip_rx_buf, MAX_SLIP_BUF);
printf("nanork@ bytesread %d\n",v);
//for (i=0;i<v;i++) printf("<%d>",slip_rx_buf[i]);
//printf("\n");
if (v > HDR_SIZE) {
ack_buf[0] = 'Z';
ack_buf[1] = slip_rx_buf[1];
ack_buf[2] = slip_rx_buf[2];
while(uart_tx_busy==1) nrk_wait_until_next_period();
uart_tx_busy=1;
slip_tx (ack_buf, 3);
uart_tx_busy=0;
rfTxInfo.pPayload = slip_rx_buf;
rfTxInfo.length= v;
rfTxInfo.destAddr = 0xFFFF;
rfTxInfo.cca = 0;
rfTxInfo.ackRequest = 0;
nrk_led_toggle (RED_LED);
pckts++;
PORTG=0x1;
if(rf_tx_packet(&rfTxInfo) != 1) {
printf("--- RF_TX ERROR ---\r\n");
nrk_spin_wait_us(10000);
}
}
}
}
void Task1 ()
{
uint16_t cnt;
uint8_t len;
printf ("My node's address is %d\r\n", NODE_ADDR);
printf ("Task1 PID=%d\r\n", nrk_get_pid ());
cnt = 0;
slip_init (stdin, stdout, 0, 0);
while (1) {
nrk_led_set (ORANGE_LED);
sprintf (slip_tx_buf, "Hello %d", cnt);
len = strlen (slip_tx_buf);
slip_tx (slip_tx_buf, len);
nrk_wait_until_next_period ();
nrk_led_clr (ORANGE_LED);
nrk_wait_until_next_period ();
cnt++;
}
}
void Task1 ()
{
uint16_t cnt;
uint8_t len,i;
//printf ("My node's address is %d\r\n", NODE_ADDR);
//printf ("Task1 PID=%d\r\n", nrk_get_pid ());
rfRxInfo.pPayload = rx_buf;
rfRxInfo.max_length = RF_MAX_PAYLOAD_SIZE;
nrk_int_enable();
rf_init (&rfRxInfo, 13, 0x2420, 0x1214);
cnt = 0;
slip_init (stdin, stdout, 0, 0);
rf_rx_on();
while (1) {
while (rf_rx_packet_nonblock () != NRK_OK) {
nrk_wait_until_next_period();
}
rx_packet_len = rfRxInfo.length;
for(i=0; i<rfRxInfo.length; i++ ) slip_tx_buf[i]=rfRxInfo.pPayload[i];
slip_tx_buf[10] = rfRxInfo.rssi;
while(uart_tx_busy==1) nrk_wait_until_next_period();
uart_tx_busy=1;
slip_tx (slip_tx_buf, rx_packet_len);
uart_tx_busy=0;
}
}
/************************* Function definitions ***************************/
int8_t sendToSerial(uint8_t *buf, uint8_t len) // CHECKED
{
while( slip_started () == NRK_ERROR ) // wait till the serial task starts the SLIPstream module
nrk_wait_until_next_period();
/*
if(len > SIZE_SLIP_TX_BUF)
{
nrk_kprintf(PSTR("SR: sendToSerial(): Buffer length too big\r\n"));
return NRK_ERROR;
}
*/
if( slip_tx (buf, len) == NRK_ERROR )
{
nrk_int_disable();
nrk_led_set(RED_LED);
while(1)
nrk_kprintf(PSTR("SR: sendToSerial(): Error sending out message over serial port\r\n"));
}
return NRK_OK;
}
/*
void sendToSerial(uint8_t *buf, int8_t length)
{
putchar(END);
if(DEBUG_SR == 2)
printf("%d ", END);
while(length > 0)
{
switch(*buf)
{
case END:
putchar(ESC);
putchar(ESC_END);
if(DEBUG_SR == 2)
printf("%d %d ",ESC, ESC_END);
break;
case ESC:
putchar(ESC);
putchar(ESC_ESC);
if(DEBUG_SR == 2)
printf("%d %d ",ESC, ESC_ESC);
break;
default:
putchar(*buf);
if(DEBUG_SR == 2)
printf("%d ", *buf);
} // end switch
buf++;
length--;
} // end while
putchar(END);
if(DEBUG_SR == 2)
printf("%d ", END);
return;
}
*/
void sendToSerial(uint8_t *buf, int8_t len)
{
while( slip_started () == NRK_ERROR )
{
nrk_wait_until_next_period();
}
if(DEBUG_SR == 2)
{
nrk_kprintf(PSTR("Calling slip_tx\r\n"));
}
if( slip_tx (buf, len) == NRK_ERROR )
{
nrk_int_disable();
nrk_led_set(RED_LED);
while(1)
{
nrk_kprintf(PSTR("Error sending out NGB_LIST message over serial\r\n"));
}
}
return;
}
int main ()
{
uint8_t v_TempCnt_u8r, v_Dummy_u8r, v_RdLcycmode_u8r;
nrk_setup_ports();
nrk_setup_uart(UART_BAUDRATE_115K2);
nrk_kprintf( PSTR("Starting up...\r\n") );
//////////////////////////////////////////////////
F_ChkIntEntry_U8R = 0;
nrk_led_clr(BLUE_LED);
nrk_led_clr(GREEN_LED);
nrk_led_clr(ORANGE_LED);
nrk_led_clr(RED_LED);
for(v_TempCnt_u8r=0;v_TempCnt_u8r<100;v_TempCnt_u8r++)
V_TxBuff_U8R[v_TempCnt_u8r]=v_TempCnt_u8r+'a';
V_RdPtr_U32R = 0;
slip_tx(&V_TxBuff_U8R[V_RdPtr_U32R],C_SlipPktSize,&V_TxBuff_U8R[C_CircBuffSize-1],C_CircBuffSize);
signal_one=nrk_signal_create();
sei();
DDRD &= ~(_BV(PORTD3)); //Making INT3 pin as input
EIMSK = 0x00;
EICRA = 0x80;
EIMSK = 0x08;
printf("#");
//Set ADE in normal power mode PM0=1 (PE2), PM!=0 (PE3)
DDRE |= _BV(PORTE2) | _BV(PORTE3);
PORTE |= _BV(PORTE2);
PORTE &= ~(_BV(PORTE3));
while(F_ChkIntEntry_U8R==0);
while(EIMSK !=0);
//Enable SPI Master, Set Clock rate fck/4
SPCR = 0x01;
SPCR |= _BV(SPE) | _BV(MSTR) | _BV(CPOL) | _BV(CPHA);
PORTB |= _BV(PORTB0);//default state of SS should be low
v_RdLcycmode_u8r=0;
//This segment below is added because it was observed that the 7878
//SPI or the ATMEL SPI takes some time to start. So waiting till
//some register gives its default value
printf("Wait..");
while(v_RdLcycmode_u8r!=0x78)
v_RdLcycmode_u8r = ade_read8(LCYCMODE);
printf("\r\n7878 Ready");
if(ade_init() < 0)
printf("\nInit failed");
else
printf("\nInit Success");
V_Status1RdWr_U32R = ade_read32(STATUS1);
ade_write32(STATUS1, V_Status1RdWr_U32R);
/////////////////////////////////////////////////
nrk_init();
nrk_time_set(0,0);
nrk_create_taskset ();
nrk_start();
return 0;
}
void Task5()
{
int8_t v;
nrk_sig_mask_t my_sigs;
nrk_sig_t t;
nrk_time_t timeout;
// timeout.secs=10;
// timeout.nano_secs=0;
printf( "Task5 PID=%d\r\n",nrk_get_pid());
v=nrk_signal_register(signal_one);
// v=nrk_signal_register(nrk_wakeup_signal);
// if(v==NRK_ERROR)
// nrk_kprintf( PSTR ("T2 nrk_signal_register failed\r\n"));
while(1)
{
// nrk_led_toggle(BLUE_LED);
// nrk_set_next_wakeup(timeout);
// printf("ee");
// my_sigs=nrk_event_wait(SIG(signal_one) | SIG(nrk_wakeup_signal));
F_ReadyForSignal_U8R=1;
my_sigs=nrk_event_wait(SIG(signal_one));
nrk_led_set(RED_LED);
F_ReadyForSignal_U8R=0;
if(my_sigs==0)
nrk_kprintf( PSTR ("T2 nrk_event_wait failed\r\n"));
if(my_sigs & SIG(signal_one))
{
// nrk_kprintf( PSTR( "T2 got S1\r\n"));
// nrk_kprintf( PSTR("*"));
slip_tx(&V_TxBuff_U8R[V_RdPtr_U32R],C_SlipPktSize,&V_TxBuff_U8R[C_CircBuffSize-1],C_CircBuffSize);
// printf("\r\n%d",V_WrPtr_U32R);
// printf(",%d",V_RdPtr_U32R);
V_RdPtr_U32R=V_RdPtr_U32R+C_SlipPktSize;
if(V_RdPtr_U32R>=C_CircBuffSize)
{
V_RdPtr_U32R = V_RdPtr_U32R - C_CircBuffSize;
V_WrSeqNo_U8R = 0;
}
if(F_Det_U8R==1)
{
printf("\r\nEvent!");
F_Det_U8R = 0;
}
if(F_1secData_U8R==1)
{
F_1secData_U8R = 0;
V_CalcTemp1_U32R = V_ArmsVolt_U32R*33;
V_CalcTemp2_U32R = V_CalcTemp1_U32R/1000000;
// printf("\r\nV = %ld",V_ArmsVolt_U32R);
printf("\r\n%ld V",V_CalcTemp2_U32R);
V_CalcTemp1_U32R = V_ArmsCurr_U32R*125;
V_CalcTemp2_U32R = V_CalcTemp1_U32R/10000;
printf(", %ld mA",V_CalcTemp2_U32R);
// printf(", I = %ld",V_ArmsCurr_U32R);
V_CalcTemp1_S32R = V_ArmsWatt_S32R;
V_CalcTemp2_S32R = V_CalcTemp1_S32R/10;
V_CalcTemp1_S32R = V_CalcTemp2_S32R*344;
V_CalcTemp2_S32R = V_CalcTemp1_S32R/100000;
// V_AwattCalc1_U32R = V_Awatt_S32R*3;
// V_AwattCalc2_U32R = (V_AwattCalc1_U32R>>13);
// printf(" P = %ld",V_AwattCalc2_U32R);i
printf(", P = %ld W",V_CalcTemp2_S32R);
V_RdDSP_U16R = ade_read16(RUN);
if(V_RdDSP_U16R==0)
{
ade_write16(RUN,START);
// printf("\nDSP restarted");
printf("\r\r$$");
}
}
nrk_led_clr(RED_LED);
}
// if(my_sigs & SIG(nrk_wakeup_signal))
// nrk_kprintf( PSTR( "T2 timeout\r\n"));
// nrk_wait_until_next_period();
}
}
void rx_task()
{
nrk_time_t t;
uint16_t cnt;
int8_t v;
uint8_t len,i,chan;
cnt=0;
nrk_kprintf( PSTR("Nano-RK Version ") );
printf( "%d\r\n",NRK_VERSION );
printf( "Gateway Task PID=%u\r\n",nrk_get_pid());
t.secs=10;
t.nano_secs=0;
// setup a software watch dog timer
nrk_sw_wdt_init(0, &t, NULL);
nrk_sw_wdt_start(0);
chan = 16;
if (SET_MAC == 0xffff) {
v = read_eeprom_mac_address (&mac_address);
if (v == NRK_OK) {
v = read_eeprom_channel (&chan);
}
else {
while (1) {
nrk_kprintf (PSTR
("* ERROR reading MAC address, run eeprom-set utility\r\n"));
nrk_led_toggle(RED_LED);
nrk_wait_until_next_period ();
}
}
}
else
mac_address = SET_MAC;
printf ("MAC ADDR: %x\r\n", mac_address & 0xffff);
printf ("chan = %d\r\n", chan);
tdma_init(TDMA_HOST, chan, mac_address);
// Change these parameters anytime you want...
tdma_set_slot_len_ms(10);
tdma_set_slots_per_cycle(12);
slip_init (stdin, stdout, 0, 0);
while(!tdma_started()) nrk_wait_until_next_period();
nrk_led_set(GREEN_LED);
while(1) {
v=tdma_recv(&rx_tdma_fd, &slip_tx_buf, &len, TDMA_BLOCKING );
nrk_led_set(ORANGE_LED);
if(v==NRK_OK)
{
//for(i=0; i<len; i++ ) printf( "%c", rx_buf[i]);
// Got a packet from the network so send it over SLIP
slip_tx ( slip_tx_buf, len );
}
else tdma_rx_pkt_release();
nrk_led_clr(ORANGE_LED);
nrk_sw_wdt_update(0);
}
}
