Changeset 113


Ignore:
Timestamp:
06/26/2007 03:20:59 PM (5 years ago)
Author:
ayb
Message:

reduced the .data section

Location:
nano-RK/projects/network_stack
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • nano-RK/projects/network_stack/App.c

    r110 r113  
    1010#include <stdint.h> 
    1111 
     12 
    1213#include "NWStackConfig.h" 
    1314#include "TransportLayerUDP.h" 
    … …  
    1617#include "Serial.h" 
    1718#include "BufferManager.h" 
    18  
     19                         
    1920#define SERVER1_PORT 1  
    2021#define SERVER2_PORT 2  
    2122#define SERVER1_RQS 4  
    22 #define SERVER2_RQS 4  
    23  
    24 #define PAYLOAD 64  
     23#define SERVER2_RQS 4 
     24 
     25#define PAYLOAD MAX_APP_PAYLOAD  
    2526#define DEBUG_APP 2  
    2627 
    … …  
    3839/**************************************************************************************/ 
    3940 
    40 void initialise() 
     41void rx_task () 
     42{ 
     43  int8_t sock; 
     44  int8_t ret; 
     45  uint8_t *rx_buf; 
     46  int8_t len; 
     47  int16_t srcAddr = 10; 
     48  int8_t srcPort; 
     49  int8_t rssi; 
     50  int8_t i; 
     51   
     52  printf ("rx_task PID=%d\r\n", nrk_get_pid ()); 
     53  sock = create_socket(SOCK_DGRAM); 
     54  if(sock == NRK_ERROR) 
     55        nrk_kprintf(PSTR("Error creating socket in rx_task")); 
     56         
     57  if(NODE_ADDR == 1) 
     58        ret = bind(sock, SERVER1_PORT); 
     59  else 
     60        ret = bind(sock, SERVER2_PORT); 
     61   
     62  if(ret == NRK_ERROR) 
     63                printf("Error in binding to socket %d\n", nrk_errno_get()); 
     64         
     65  if(NODE_ADDR == 1) 
     66        ret = set_rx_queue_size(sock, SERVER1_RQS); 
     67  else 
     68        ret = set_rx_queue_size(sock, SERVER2_RQS); 
     69   
     70  if(ret == NRK_ERROR) 
     71                printf("Error in setting rx queue size %d\n", nrk_errno_get()); 
     72   
     73  while(1) 
     74  { 
     75                nrk_kprintf(PSTR("APP rx_task: Waiting for a packet\r\n"));   
     76                set_timeout(sock, 5, 0);                 
     77                rx_buf = receive(sock, &len, &srcAddr, &srcPort, &rssi); 
     78                 
     79                if(rx_buf != NULL) 
     80                { 
     81                        printf("Received a pkt from %d,%d with RSSI = %d\n", srcAddr, srcPort, rssi); 
     82                        //nrk_led_set(GREEN_LED);  
     83                  
     84                        //for(i = 0; i < len; i++) 
     85                        //      printf("%c ", rx_buf[i]); 
     86                        //printf("\r\n"); 
     87                } 
     88                else 
     89                        nrk_kprintf(PSTR("Receive timed out\n")); 
     90                //nrk_led_clr(GREEN_LED); 
     91                release_buffer(sock, rx_buf); 
     92        } 
     93         
     94        return; 
     95} 
     96/**************************************************************************************/ 
     97         
     98void tx_task () 
     99{ 
     100          int8_t ret, len, cnt; 
     101          int8_t sock; 
     102          int8_t flag; 
     103   
     104          printf ("tx_task PID=%d\r\n", nrk_get_pid ()); 
     105         
     106          sock = create_socket(SOCK_DGRAM); 
     107          if(sock == NRK_ERROR) 
     108                printf("Error in creating socket %d\n", nrk_errno_get()); 
     109          cnt = 0; 
     110          
     111          while (1) 
     112          { 
     113                // Build a TX packet 
     114                sprintf (tx_buf, "This is a test %d", cnt); 
     115                cnt++; 
     116                nrk_led_set (BLUE_LED); 
     117                flag = 0; 
     118                         
     119                        if(NODE_ADDR == 1) 
     120                                if( send(sock, tx_buf, strlen(tx_buf), 2,  SERVER2_PORT, NORMAL_PRIORITY) == NRK_ERROR )         
     121                                { 
     122                                        printf("Error returned by send() %d\r\n", nrk_errno_get()); 
     123                                        flag = 1; 
     124                                } 
     125                        else 
     126                                if( send(sock, tx_buf, strlen(tx_buf), 1,  SERVER1_PORT, NORMAL_PRIORITY) == NRK_ERROR ) 
     127                                { 
     128                                        printf("Error returned by send() %d\r\n", nrk_errno_get()); 
     129                                        flag = 1; 
     130                                }  
     131                         
     132                if(flag == 0) 
     133                { 
     134                        nrk_kprintf (PSTR ("Tx packet enqueued\r\n")); 
     135                                ret = wait_until_send_done(sock);     
     136                        if(ret == NRK_ERROR) 
     137                                printf("Error in waiting for send done signal %d\n", nrk_errno_get()); 
     138                 
     139                        // Task gets control again after TX complete 
     140                        if(flag == 0) 
     141                                printf("Tx sent data = %d\r\n", cnt); 
     142                } 
     143                nrk_led_clr (BLUE_LED); 
     144                nrk_wait_until_next_period (); 
     145          } 
     146         
     147          return; 
     148} 
     149 
     150/**********************************************************************************************/         
     151void nrk_create_taskset() 
     152{ 
     153  
     154  RX_TASK.task = rx_task; 
     155  RX_TASK.Ptos = (void *) &rx_task_stack[NRK_APP_STACKSIZE - 1]; 
     156  RX_TASK.Pbos = (void *) &rx_task_stack[0]; 
     157  RX_TASK.prio = 2; 
     158  RX_TASK.FirstActivation = TRUE; 
     159  RX_TASK.Type = BASIC_TASK; 
     160  RX_TASK.SchType = PREEMPTIVE; 
     161   
     162  RX_TASK.cpu_reserve.secs = 2; 
     163  RX_TASK.cpu_reserve.nano_secs = 0;   
     164  RX_TASK.period.secs = 3; 
     165  RX_TASK.period.nano_secs = 0; 
     166     
     167  RX_TASK.offset.secs = 3; 
     168  RX_TASK.offset.nano_secs= 0; 
     169  //if(NODE_ADDR == 1) 
     170                nrk_activate_task (&RX_TASK); 
     171 
     172/*****************************************************************************************/   
     173  TX_TASK.task = tx_task; 
     174  TX_TASK.Ptos = (void *) &tx_task_stack[NRK_APP_STACKSIZE - 1]; 
     175  TX_TASK.Pbos = (void *) &tx_task_stack[0]; 
     176  TX_TASK.prio = 3; 
     177  TX_TASK.FirstActivation = TRUE; 
     178  TX_TASK.Type = BASIC_TASK; 
     179  TX_TASK.SchType = PREEMPTIVE; 
     180   
     181  TX_TASK.cpu_reserve.secs = 1; 
     182  TX_TASK.cpu_reserve.nano_secs = 0;     
     183  TX_TASK.period.secs = 2; 
     184  TX_TASK.period.nano_secs = 0; 
     185   
     186  TX_TASK.offset.secs = 5; 
     187  TX_TASK.offset.nano_secs= 0; 
     188  //if(NODE_ADDR == 2) 
     189        nrk_activate_task (&TX_TASK); 
     190   
     191  if(DEBUG_APP == 2) 
     192        nrk_kprintf(PSTR("Created the two application layer tasks\r\n")); 
     193} 
     194 
     195int main() 
    41196{ 
    42197        // initialise the UART   
    … …  
    48203 
    49204        // clear all LEDs        
    50         // this will toggle when information about an already received neighbor is received again 
    51205                 
    52206        if(DEBUG_APP == 2) 
    53                 nrk_kprintf(PSTR("Before clearing LEDs\n")); 
     207                nrk_kprintf(PSTR("Before clearing LEDs\r\n")); 
    54208 
    55209        nrk_led_clr(ORANGE_LED);                 
    … …  
    61215        nrk_time_set(0,0); 
    62216 
    63         printf("Before initialising network stack"); 
     217        if(DEBUG_APP == 2) 
     218                nrk_kprintf(PSTR("Before initialising network stack\r\n")); 
    64219        // initialise the network stack          
    65         nrk_init_nw_stack(); 
     220         nrk_init_nw_stack(); 
    66221                  
    67         return; 
    68 } 
    69  
    70 void rx_task () 
    71 { 
    72   int8_t sock; 
    73   int8_t ret; 
    74   uint8_t *rx_buf; 
    75   int8_t len; 
    76   int16_t srcAddr; 
    77   int8_t srcPort; 
    78   int8_t rssi; 
    79   int8_t i; 
    80    
    81      
    82   printf ("rx_task PID=%d\r\n", nrk_get_pid ()); 
    83   sock = create_socket(SOCK_DGRAM); 
    84   if(sock == NRK_ERROR) 
    85         nrk_kprintf(PSTR("Error creating socket in rx_task")); 
    86          
    87   if(NODE_ADDR == 1) 
    88         ret = bind(sock, SERVER1_PORT); 
    89   else 
    90         ret = bind(sock, SERVER2_PORT); 
    91    
    92   if(ret == NRK_ERROR) 
    93                 printf("Error in binding to socket %d\n", nrk_errno_get()); 
    94          
    95   if(NODE_ADDR == 1) 
    96         ret = set_rx_queue_size(sock, SERVER1_RQS); 
    97   else 
    98         ret = set_rx_queue_size(sock, SERVER2_RQS); 
    99    
    100   if(ret == NRK_ERROR) 
    101                 printf("Error in setting rx queue size %d\n", nrk_errno_get()); 
    102    
    103   while(1) 
    104   { 
    105                 rx_buf = receive(sock, &len, &srcAddr, &srcPort, &rssi); 
    106                  
    107                 printf("Received a pkt from %d,%d with RSSI = %d\n", srcAddr, srcPort, rssi); 
    108                 nrk_led_set(GREEN_LED);  
    109                   
    110                 for(i = 0; i < len; i++) 
    111                         printf("%c ", rx_buf[i]); 
    112                          
    113                 nrk_led_clr(GREEN_LED); 
    114                 release_buffer(sock, rx_buf); 
    115         } 
    116          
    117         return; 
    118 } 
    119                          
    120 void tx_task () 
    121 { 
    122   int8_t ret, len, cnt; 
    123   int8_t sock; 
    124    
    125   printf ("tx_task PID=%d\r\n", nrk_get_pid ()); 
    126  
    127   sock = create_socket(SOCK_DGRAM); 
    128   if(sock == NRK_ERROR) 
    129         printf("Error in creating socket %d\n", nrk_errno_get()); 
    130   cnt = 0; 
    131   
    132   while (1) 
    133   { 
    134         // Build a TX packet 
    135         sprintf (tx_buf, "This is a test %d", cnt); 
    136         cnt++; 
    137         nrk_led_set (BLUE_LED); 
    138                  
    139                 if(NODE_ADDR == 1) 
    140                         send(sock, tx_buf, strlen(tx_buf), 2,  SERVER2_PORT, NORMAL_PRIORITY); 
    141                 else 
    142                         send(sock, tx_buf, strlen(tx_buf), 1,  SERVER1_PORT, NORMAL_PRIORITY); 
    143                  
    144         nrk_kprintf (PSTR ("Tx packet enqueued\r\n")); 
    145      
    146                 ret = wait_until_send_done(sock);     
    147         if(ret == NRK_ERROR) 
    148                 printf("Error in waiting for send done signal %d\n", nrk_errno_get()); 
    149  
    150         // Task gets control again after TX complete 
    151         nrk_kprintf (PSTR ("Tx task sent data!\r\n")); 
    152         nrk_led_clr (BLUE_LED); 
    153         nrk_wait_until_next_period (); 
    154   } 
    155  
    156   return; 
    157 } 
    158  
    159  
    160 void nrk_create_taskset() 
    161 { 
    162  
    163   RX_TASK.task = rx_task; 
    164   RX_TASK.Ptos = (void *) &rx_task_stack[NRK_APP_STACKSIZE-1]; 
    165   RX_TASK.Pbos = (void *) &rx_task_stack[0]; 
    166   RX_TASK.prio = 3; 
    167   RX_TASK.FirstActivation = TRUE; 
    168   RX_TASK.Type = BASIC_TASK; 
    169   RX_TASK.SchType = PREEMPTIVE; 
    170    
    171   RX_TASK.cpu_reserve.secs = 4; 
    172   RX_TASK.cpu_reserve.nano_secs = 500*NANOS_PER_MS;   
    173   RX_TASK.period.secs = 3; 
    174   RX_TASK.period.nano_secs = 0; 
    175      
    176   RX_TASK.offset.secs = 0; 
    177   RX_TASK.offset.nano_secs= 0; 
    178   nrk_activate_task (&RX_TASK); 
    179  
    180 /*****************************************************************************************/   
    181   TX_TASK.task = tx_task; 
    182   TX_TASK.Ptos = (void *) &tx_task_stack[NRK_APP_STACKSIZE-1]; 
    183   TX_TASK.Pbos = (void *) &tx_task_stack[0]; 
    184   TX_TASK.prio = 4; 
    185   TX_TASK.FirstActivation = TRUE; 
    186   TX_TASK.Type = BASIC_TASK; 
    187   TX_TASK.SchType = PREEMPTIVE; 
    188    
    189   TX_TASK.cpu_reserve.secs = 3; 
    190   TX_TASK.cpu_reserve.nano_secs = 0;     
    191   TX_TASK.period.secs = 4; 
    192   TX_TASK.period.nano_secs = 0; 
    193    
    194   TX_TASK.offset.secs = 0; 
    195   TX_TASK.offset.nano_secs= 0; 
    196   nrk_activate_task (&TX_TASK); 
    197 } 
    198  
    199 int main() 
    200 { 
    201         initialise(); 
     222        nrk_kprintf(PSTR("Finished initialise\r\n")); 
    202223         
    203224        nrk_create_taskset();           // create the set of tasks 

  • nano-RK/projects/network_stack/BufferManager.c

    r103 r113  
    22 
    33#include<stdint.h> 
    4  
     4#include <nrk.h> 
     5#include <include.h> 
     6#include <ulib.h> 
     7#include <stdio.h> 
     8#include <avr/sleep.h> 
     9#include <hal.h> 
     10#include <nrk_error.h> 
    511 
    612#include "BufferManager.h"  
    … …  
    2733 
    2834/***************************************************************************************/ 
    29 void enter_cr(nrk_sem_t *sem, int8_t *fn) 
    30 { 
    31         int8_t str[30]; // temporary variable to hold error message  
    32          
     35void enter_cr(nrk_sem_t *sem, int8_t fno) 
     36{ 
    3337        if( nrk_sem_pend(sem) == NRK_ERROR ) 
    3438        { 
    35                 sprintf (str, "Error sem pending in %s", fn); 
    36                 go_into_panic(str); 
    37         } 
    38          
     39                switch(fno) 
     40                { 
     41                        /******************************** Transport Layer ******************************/ 
     42                        case 1: 
     43                                nrk_kprintf(PSTR("Error sem pending on initialise_transport_layer_udp()\r\n")); 
     44                                break; 
     45                                 
     46                        case 2:  
     47                                nrk_kprintf(PSTR("Error sem pending on get_next_available_socket()\r\n")); 
     48                                break; 
     49                                 
     50                        case 3:  
     51                                nrk_kprintf(PSTR("Error sem pending on create_socket()\r\n")); 
     52                                break; 
     53                         
     54                        case 4:  
     55                                nrk_kprintf(PSTR("Error sem pending on get_next_available_port()\r\n")); 
     56                                break; 
     57                         
     58                        case 5:  
     59                                nrk_kprintf(PSTR("Error sem pending on check_port_available()\r\n")); 
     60                                break; 
     61                         
     62                        case 6:  
     63                                nrk_kprintf(PSTR("Error sem pending on assign_port()\r\n")); 
     64                                break; 
     65                         
     66                        case 7:  
     67                                nrk_kprintf(PSTR("Error sem pending on release_port()\r\n")); 
     68                                break; 
     69                         
     70                        case 8:  
     71                                nrk_kprintf(PSTR("Error sem pending on bind()\r\n")); 
     72                                break; 
     73                         
     74                        case 9:  
     75                                nrk_kprintf(PSTR("Error sem pending on get_rx_queue_size()\r\n")); 
     76                                break; 
     77                         
     78                        case 10:  
     79                                nrk_kprintf(PSTR("Error sem pending on set_rx_queue_size()\r\n")); 
     80                                break; 
     81                         
     82                        case 11:  
     83                                nrk_kprintf(PSTR("Error sem pending on release_buffer()\r\n")); 
     84                                break; 
     85                         
     86                        case 12:  
     87                                nrk_kprintf(PSTR("Error sem pending on close_socket()\r\n")); 
     88                                break; 
     89                         
     90                        case 13:  
     91                                nrk_kprintf(PSTR("Error sem pending on is_port_associated()\r\n")); 
     92                                break; 
     93                         
     94                        case 14:  
     95                                nrk_kprintf(PSTR("Error sem pending on send()\r\n")); 
     96                                break; 
     97                         
     98                        case 15:  
     99                                nrk_kprintf(PSTR("Error sem pending on set_timeout()\r\n")); 
     100                                break; 
     101                         
     102                        case 16:  
     103                                nrk_kprintf(PSTR("Error sem pending on receive()\r\n")); 
     104                                break; 
     105                                 
     106                        case 17:  
     107                                nrk_kprintf(PSTR("Error sem pending on check_receive_queue()\r\n")); 
     108                                break; 
     109                                                 
     110                        case 18:  
     111                                nrk_kprintf(PSTR("Error sem pending on wait_until_send_done()\r\n")); 
     112                                break; 
     113                                 
     114                        /*************************** Network Layer ********************************/                             
     115                        case 19:  
     116                                nrk_kprintf(PSTR("Error sem pending on add_neighbor()\r\n")); 
     117                                break; 
     118                         
     119                        case 20:  
     120                                nrk_kprintf(PSTR("Error sem pending on shouldIMultihop()\r\n")); 
     121                                break; 
     122                         
     123                        case 21:  
     124                                nrk_kprintf(PSTR("Error sem pending on multihop()\r\n")); 
     125                                break; 
     126                                 
     127                        case 22: 
     128                                nrk_kprintf(PSTR("Error sem pending on route_addr()\r\n")); 
     129                         
     130                        case 23:  
     131                                nrk_kprintf(PSTR("Error sem pending on route_packet()\r\n")); 
     132                                break; 
     133                                 
     134                        case 24:  
     135                                nrk_kprintf(PSTR("Error sem pending on sendToGateway()\r\n")); 
     136                                break; 
     137                         
     138                        case 25:  
     139                                nrk_kprintf(PSTR("Error sem pending on pkt_type()\r\n")); 
     140                                break; 
     141                                 
     142                        case 26:  
     143                                nrk_kprintf(PSTR("Error sem pending on tl_type()\r\n")); 
     144                                break; 
     145                                 
     146                        case 27:  
     147                                nrk_kprintf(PSTR("Error sem pending on nw_ctrl_type()\r\n")); 
     148                                break; 
     149                         
     150                        case 28:  
     151                                nrk_kprintf(PSTR("Error sem pending on process_app_pkt()\r\n")); 
     152                                break; 
     153                         
     154                        case 29:  
     155                                nrk_kprintf(PSTR("Error sem pending on process_nw_ctrl_pkt()\r\n")); 
     156                                break; 
     157                                 
     158                        case 30: 
     159                                nrk_kprintf(PSTR("Error sem pending on process_other_pkt()\r\n")); 
     160                                break; 
     161                                 
     162                        case 31: 
     163                                nrk_kprintf(PSTR("Error sem pending on build_Msg_Hello()\r\n")); 
     164                                break; 
     165                                 
     166                        case 32: 
     167                                nrk_kprintf(PSTR("Error sem pending on build_Msg_NgbList()\r\n")); 
     168                                break; 
     169                                 
     170                        case 33: 
     171                                nrk_kprintf(PSTR("Error sem pending on nl_rx_task()\r\n")); 
     172                                break; 
     173                                 
     174                        case 34: 
     175                                nrk_kprintf(PSTR("Error sem pending on nl_tx_task()\r\n")); 
     176                                break; 
     177                                 
     178                        case 35:  
     179                                nrk_kprintf(PSTR("Error sem pending on create_network_layer_tasks()\r\n")); 
     180                                break; 
     181                         
     182                        case 36:  
     183                                nrk_kprintf(PSTR("Error sem pending on initialise_network_layer()\r\n")); 
     184                                break; 
     185                                 
     186                        /****************************** BufferManager.c *********************************/ 
     187                        case 37:  
     188                                nrk_kprintf(PSTR("Error sem pending on initialise_buffer_manager()\r\n")); 
     189                                break; 
     190                         
     191                        case 38:  
     192                                nrk_kprintf(PSTR("Error sem pending on is_excess_policy_valid()\r\n")); 
     193                                break; 
     194                         
     195                        case 39:  
     196                                nrk_kprintf(PSTR("Error sem pending on set_excess_policy()\r\n")); 
     197                                break; 
     198                         
     199                        case 40:  
     200                                nrk_kprintf(PSTR("Error sem pending on get_excess_policy()\r\n")); 
     201                                break; 
     202                         
     203                        case 41:  
     204                                nrk_kprintf(PSTR("Error sem pending on get_index_unallocated_rx_buf()\r\n")); 
     205                                break; 
     206                         
     207                        case 42:  
     208                                nrk_kprintf(PSTR("Error sem pending on insert_rx_pq()\r\n")); 
     209                                break; 
     210                         
     211                        case 43:  
     212                                nrk_kprintf(PSTR("Error sem pending on remove_rx_pq()\r\n")); 
     213                                break; 
     214                         
     215                        case 44:  
     216                                nrk_kprintf(PSTR("Error sem pending on insert_rx_fq()\r\n")); 
     217                                break; 
     218                         
     219                        case 45:  
     220                                nrk_kprintf(PSTR("Error sem pending on remove_rx_fq()\r\n")); 
     221                                break; 
     222                                 
     223                        case 46:  
     224                                nrk_kprintf(PSTR("Error sem pending on insert_tx_aq()\r\n")); 
     225                                break; 
     226                         
     227                        case 47:  
     228                                nrk_kprintf(PSTR("Error sem pending on remove_tx_aq()\r\n")); 
     229                                break; 
     230                         
     231                        case 48:  
     232                                nrk_kprintf(PSTR("Error sem pending on insert_tx_fq()\r\n")); 
     233                                break; 
     234                         
     235                        case 49:  
     236                                nrk_kprintf(PSTR("Error sem pending on remove_tx_fq()\r\n")); 
     237                                break; 
     238                         
     239                        case 50:  
     240                                nrk_kprintf(PSTR("Error sem pending on get_in_process_buf_count()\r\n")); 
     241                                break; 
     242                         
     243                        /******************************************************************************/ 
     244                         
     245                        default: 
     246                                nrk_kprintf(PSTR("enter_cr(): Unknown function number\r\n")); 
     247                                break; 
     248                } // end switch  
     249        } // end if  
     250                         
    39251        return; 
    40252} 
    41253 
    42254/******************************************************************************************/ 
    43 void leave_cr(nrk_sem_t *sem, int8_t *fn) 
    44 { 
    45         int8_t str[30]; // temporary variable to hold error message  
    46          
     255void leave_cr(nrk_sem_t *sem, int8_t fno) 
     256{ 
    47257        if( nrk_sem_post(sem) == NRK_ERROR ) 
    48258        { 
    49                 sprintf (str, "Error sem posting in %s", fn); 
    50                 go_into_panic(str); 
    51         } 
    52          
     259                switch(fno) 
     260                { 
     261                        /******************************** Transport Layer ******************************/ 
     262                        case 1: 
     263                                nrk_kprintf(PSTR("Error sem posting on initialise_transport_layer_udp()\r\n")); 
     264                                break; 
     265                                 
     266                        case 2:  
     267                                nrk_kprintf(PSTR("Error sem posting on get_next_available_socket()\r\n")); 
     268                                break; 
     269                                 
     270                        case 3:  
     271                                nrk_kprintf(PSTR("Error sem posting on create_socket()\r\n")); 
     272                                break; 
     273                         
     274                        case 4:  
     275                                nrk_kprintf(PSTR("Error sem posting on get_next_available_port()\r\n")); 
     276                                break; 
     277                         
     278                        case 5:  
     279                                nrk_kprintf(PSTR("Error sem posting on check_port_available()\r\n")); 
     280                                break; 
     281                         
     282                        case 6:  
     283                                nrk_kprintf(PSTR("Error sem posting on assign_port()\r\n")); 
     284                                break; 
     285                         
     286                        case 7:  
     287                                nrk_kprintf(PSTR("Error sem posting on release_port()\r\n")); 
     288                                break; 
     289                         
     290                        case 8:  
     291                                nrk_kprintf(PSTR("Error sem posting on bind()\r\n")); 
     292                                break; 
     293                         
     294                        case 9:  
     295                                nrk_kprintf(PSTR("Error sem posting on get_rx_queue_size()\r\n")); 
     296                                break; 
     297                         
     298                        case 10:  
     299                                nrk_kprintf(PSTR("Error sem posting on set_rx_queue_size()\r\n")); 
     300                                break; 
     301                         
     302                        case 11:  
     303                                nrk_kprintf(PSTR("Error sem posting on release_buffer()\r\n")); 
     304                                break; 
     305                         
     306                        case 12:  
     307                                nrk_kprintf(PSTR("Error sem posting on close_socket()\r\n")); 
     308                                break; 
     309                         
     310                        case 13:  
     311                                nrk_kprintf(PSTR("Error sem posting on is_port_associated()\r\n")); 
     312                                break; 
     313                         
     314                        case 14:  
     315                                nrk_kprintf(PSTR("Error sem posting on send()\r\n")); 
     316                                break; 
     317                         
     318                        case 15:  
     319                                nrk_kprintf(PSTR("Error sem posting on set_timeout()\r\n")); 
     320                                break; 
     321                         
     322                        case 16:  
     323                                nrk_kprintf(PSTR("Error sem posting on receive()\r\n")); 
     324                                break; 
     325                                 
     326                        case 17:  
     327                                nrk_kprintf(PSTR("Error sem posting on check_receive_queue()\r\n")); 
     328                                break; 
     329                                                 
     330                        case 18:  
     331                                nrk_kprintf(PSTR("Error sem posting on wait_until_send_done()\r\n")); 
     332                                break; 
     333                                 
     334                        /*************************** Network Layer ********************************/                             
     335                        case 19:  
     336                                nrk_kprintf(PSTR("Error sem posting on add_neighbor()\r\n")); 
     337                                break; 
     338                         
     339                        case 20:  
     340                                nrk_kprintf(PSTR("Error sem posting on shouldIMultihop()\r\n")); 
     341                                break; 
     342                         
     343                        case 21:  
     344                                nrk_kprintf(PSTR("Error sem posting on multihop()\r\n")); 
     345                                break; 
     346                                 
     347                        case 22: 
     348                                nrk_kprintf(PSTR("Error sem posting on route_addr()\r\n")); 
     349                         
     350                        case 23:  
     351                                nrk_kprintf(PSTR("Error sem posting on route_packet()\r\n")); 
     352                                break; 
     353                                 
     354                        case 24:  
     355                                nrk_kprintf(PSTR("Error sem posting on sendToGateway()\r\n")); 
     356                                break; 
     357                         
     358                        case 25:  
     359                                nrk_kprintf(PSTR("Error sem posting on pkt_type()\r\n")); 
     360                                break; 
     361                                 
     362                        case 26:  
     363                                nrk_kprintf(PSTR("Error sem posting on tl_type()\r\n")); 
     364                                break; 
     365                                 
     366                        case 27:  
     367                                nrk_kprintf(PSTR("Error sem posting on nw_ctrl_type()\r\n")); 
     368                                break; 
     369                         
     370                        case 28:  
     371                                nrk_kprintf(PSTR("Error sem posting on process_app_pkt()\r\n")); 
     372                                break; 
     373                         
     374                        case 29:  
     375                                nrk_kprintf(PSTR("Error sem posting on process_nw_ctrl_pkt()\r\n")); 
     376                                break; 
     377                                 
     378                        case 30: 
     379                                nrk_kprintf(PSTR("Error sem posting on process_other_pkt()\r\n")); 
     380                                break; 
     381                                 
     382                        case 31: 
     383                                nrk_kprintf(PSTR("Error sem posting on build_Msg_Hello()\r\n")); 
     384                                break; 
     385                                 
     386                        case 32: 
     387                                nrk_kprintf(PSTR("Error sem posting on build_Msg_NgbList()\r\n")); 
     388                                break; 
     389                                 
     390                        case 33: 
     391                                nrk_kprintf(PSTR("Error sem posting on nl_rx_task()\r\n")); 
     392                                break; 
     393                                 
     394                        case 34: 
     395                                nrk_kprintf(PSTR("Error sem posting on nl_tx_task()\r\n")); 
     396                                break; 
     397                                 
     398                        case 35:  
     399                                nrk_kprintf(PSTR("Error sem posting on create_network_layer_tasks()\r\n")); 
     400                                break; 
     401                         
     402                        case 36:  
     403                                nrk_kprintf(PSTR("Error sem posting on initialise_network_layer()\r\n")); 
     404                                break; 
     405                                 
     406                        /****************************** BufferManager.c *********************************/ 
     407                        case 37:  
     408                                nrk_kprintf(PSTR("Error sem posting on initialise_buffer_manager()\r\n")); 
     409                                break; 
     410                         
     411                        case 38:  
     412                                nrk_kprintf(PSTR("Error sem posting on is_excess_policy_valid()\r\n")); 
     413                                break; 
     414                         
     415                        case 39:  
     416                                nrk_kprintf(PSTR("Error sem posting on set_excess_policy()\r\n")); 
     417                                break; 
     418                         
     419                        case 40:  
     420                                nrk_kprintf(PSTR("Error sem posting on get_excess_policy()\r\n")); 
     421                                break; 
     422                         
     423                        case 41:  
     424                                nrk_kprintf(PSTR("Error sem posting on get_index_unallocated_rx_buf()\r\n")); 
     425                                break; 
     426                         
     427                        case 42:  
     428                                nrk_kprintf(PSTR("Error sem posting on insert_rx_pq()\r\n")); 
     429                                break; 
     430                         
     431                        case 43:  
     432                                nrk_kprintf(PSTR("Error sem posting on remove_rx_pq()\r\n")); 
     433                                break; 
     434                         
     435                        case 44:  
     436                                nrk_kprintf(PSTR("Error sem posting on insert_rx_fq()\r\n")); 
     437                                break; 
     438                         
     439                        case 45:  
     440                                nrk_kprintf(PSTR("Error sem posting on remove_rx_fq()\r\n")); 
     441                                break; 
     442                                 
     443                        case 46:  
     444                                nrk_kprintf(PSTR("Error sem posting on insert_tx_aq()\r\n")); 
     445                                break; 
     446                         
     447                        case 47:  
     448                                nrk_kprintf(PSTR("Error sem posting on remove_tx_aq()\r\n")); 
     449                                break; 
     450                         
     451                        case 48:  
     452                                nrk_kprintf(PSTR("Error sem posting on insert_tx_fq()\r\n")); 
     453                                break; 
     454                         
     455                        case 49:  
     456                                nrk_kprintf(PSTR("Error sem posting on remove_tx_fq()\r\n")); 
     457                                break; 
     458                         
     459                        case 50:  
     460                                nrk_kprintf(PSTR("Error sem posting on get_in_process_buf_count()\r\n")); 
     461                                break; 
     462                         
     463                        /******************************************************************************/ 
     464                         
     465                        default: 
     466                                nrk_kprintf(PSTR("leave_cr(): Unknown function number\r\n")); 
     467                                break; 
     468                } // end switch  
     469        } // end if  
     470                         
    53471        return; 
    54472} 
    … …  
    101519        bm_sem = nrk_sem_create(1,MAX_TASK_PRIORITY);   // create the mutex   
    102520        if(bm_sem == NULL) 
    103                 go_into_panic("Error creating the semaphore in initialise_buffer_manager()");            
    104          
    105          
     521        { 
     522                nrk_int_disable(); 
     523                nrk_led_set(RED_LED); 
     524                while(1) 
     525                nrk_kprintf(PSTR("initialise_buffer_manager(): Error creating the semaphore\r\n")); 
     526        }        
    106527        return; 
    107528} 
    … …  
    126547        } 
    127548         
    128         enter_cr(bm_sem, "set_excess_policy()");        // enter CR  
     549        enter_cr(bm_sem, 39);   // enter CR  
    129550                 
    130551        if(pref == DROP)        // set bit number 'prio' in excessPolicySettings to 1 
    … …  
    133554                excessPolicySettings &= ~( (uint32_t)1 << prio ); 
    134555         
    135         leave_cr(bm_sem, "set_excess_policy()");        // leave CR  
     556        leave_cr(bm_sem, 39);   // leave CR  
    136557                 
    137558        return NRK_OK; 
    … …  
    146567        }        
    147568         
    148         enter_cr(bm_sem, "get_excess_policy()"); 
     569        enter_cr(bm_sem, 40); 
    149570                 
    150571        // check the state of bit number 'prio' in excessPolicySettings  
    151572        if( ((excessPolicySettings >> prio) & ((uint32_t)1)) == 0 ) // is bit 'prio' cleared 
    152573        { 
    153                 leave_cr(bm_sem, "get_excess_policy()");         
     574                leave_cr(bm_sem, 40);    
    154575                return OVERWRITE; 
    155576        } 
    156577         
    157         leave_cr(bm_sem, "get_excess_policy()"); 
     578        leave_cr(bm_sem, 40); 
    158579        return DROP; 
    159580} 
    … …  
    223644        { 
    224645                if(rx_buf_mgr[port].countFree != 0)     // debugging purposes  
    225                         go_into_panic("Bug found in rx_buf_mgr in insert_rx_pq()"); 
     646                { 
     647                        nrk_int_disable(); 
     648                        nrk_led_set(RED_LED); 
     649                        while(1) 
     650                                nrk_kprintf(PSTR("insert_rx_pq(): Bug found in implementation of countFree in rx_buf_mgr\r\n")); 
     651                } 
    226652                 
    227653                //leave_cr(bm_sem, "insert_rx_pq()");            

  • nano-RK/projects/network_stack/BufferManager.h

    r103 r113  
    3636 
    3737// priority level of task ....SHIFT this to Anthony's code  
    38 #define MAX_TASK_PRIORITY 255  
     38#define MAX_TASK_PRIORITY 10  
    3939  
    4040// priority levels of messages  

  • nano-RK/projects/network_stack/NWStackConfig.c

    r110 r113  
    3333extern go_into_panic(char*); 
    3434 
     35//From bmac.c 
     36extern void bmac_task_config(); 
     37 
    3538/********************************* FUNCTION DEFINITIONS ****************************/ 
    3639void nrk_init_nw_stack() 
    … …  
    4043                 
    4144        if(DEBUG == 2) 
    42                 nrk_kprintf(PSTR("Before initialising buffer manager\n")); 
     45                nrk_kprintf(PSTR("Before initialising buffer manager\r\n")); 
    4346        initialise_buffer_manager(); 
    4447         
    4548        if(DEBUG == 2) 
    46                 nrk_kprintf(PSTR("Before initialising transport layer\n")); 
     49                nrk_kprintf(PSTR("Before initialising transport layer\r\n")); 
    4750        initialise_transport_layer_udp(); 
    4851         
    4952        if(DEBUG == 2) 
    50                 nrk_kprintf(PSTR("Before initialising network layer\n")); 
     53                nrk_kprintf(PSTR("Before initialising the link layer\r\n")); 
     54        bmac_task_config(); 
     55         
     56        if(DEBUG == 2) 
     57                nrk_kprintf(PSTR("Before initialising network layer\r\n")); 
    5158        initialise_network_layer(); 
    5259         
    5360        return; 
    5461} 
    55  
    56          

  • nano-RK/projects/network_stack/NWStackConfig.h

    r110 r113  
     1 
    12/* This file should be edited by the user depneding on his application */ 
    23 
    … …  
    56 
    67 
    7 #define MAX_APP_PAYLOAD  16                                     // maximum size of the application payload in bytes  
    8 #define MAX_SERIAL_PAYLOAD 16                                   // maximum size of serial data payload 
     8#define MAX_APP_PAYLOAD  32                                     // maximum size of the application payload in bytes  
     9#define MAX_SERIAL_PAYLOAD 32                           // maximum size of serial data payload 
    910#define MAX_RX_QUEUE_SIZE 8                                     // maximum number of receive buffers available in the  
    1011                                                                                                                // system for USER tasks  

  • nano-RK/projects/network_stack/NetworkLayer.c

    r103 r113  
    6565static NeighborList nl;                                                                                                 // to hold the neighbors of this node 
    6666 
    67 static uint8_t rx_buf[RF_MAX_PAYLOAD_SIZE];                                             // receive buffer for network layer 
     67static uint8_t rx_buf[RF_BUFFER_SIZE];                                          // receive buffer for network layer 
    6868static NW_Packet pkt_rx;                                                                                                // to hold a received packet from link layer  
    6969 
    … …  
    106106        */ 
    107107         
    108         enter_cr(nl_sem, "add_neighbor()"); 
     108        enter_cr(nl_sem, 19); 
    109109        for(i = 0; i < MAX_NGBS; i++)    
    110110        { 
    … …  
    134134        if(found == TRUE)                       // neighbor was already present in array; do nothing further 
    135135        { 
    136                 leave_cr(nl_sem, "add_neighbor()");      
     136                leave_cr(nl_sem, 19);    
    137137                return NRK_OK; 
    138138        } 
    … …  
    143143                _nrk_errno_set(MAX_NEIGHBOR_LIMIT_REACHED); 
    144144                 
    145                 leave_cr(nl_sem, "add_neighbor()");              
     145                leave_cr(nl_sem, 19);            
    146146                return NRK_ERROR; 
    147147        } 
    … …  
    161161         
    162162        if(i == MAX_NGBS)                                                                       // sanity check for debugging 
    163                 go_into_panic("Bug in add_neighbor()");  
    164                  
    165         leave_cr(nl_sem, "add_neighbor()");      
     163        { 
     164                nrk_int_disable(); 
     165                nrk_led_set(RED_LED); 
     166                while(1) 
     167                        nrk_kprintf(PSTR("add_neighbor(): Bug found in implementation of MAX_NGBS\r\n")); 
     168        } 
     169                 
     170        leave_cr(nl_sem, 19);    
    166171        return NRK_OK;  
    167172} 
    … …  
    182187        if( shouldIMultihop(pkt) == MULTIHOP_YES )// see whether this packet should be multi hopped 
    183188        { 
    184                 enter_cr(bm_sem, "multihop()"); 
     189                enter_cr(bm_sem, 21); 
    185190                insert_tx_aq(pkt);      // ignore the return type. If no space, drop the packet 
    186                 leave_cr(bm_sem, "multihop()");  
     191                leave_cr(bm_sem, 21);  
    187192        }  
    188193        return; 
    … …  
    261266                                                                                 
    262267                // check to see if the destination port in the header is associated with any socket  
    263                 enter_cr(bm_sem, "process_app_pkt()"); 
     268                enter_cr(bm_sem, 28); 
    264269                if(is_port_associated(udp_seg.destPort) == TRUE)        // yes there is  
    265270                { 
    … …  
    271276                        ; 
    272277                         
    273                 leave_cr(bm_sem, "process_app_pkt()"); 
     278                leave_cr(bm_sem, 28); 
    274279        } 
    275280        else // as of now UDP is the only supported transport layer, hence flag an error 
    276281        { 
    277                 go_into_panic("Unsupported transport layer type found in process_app_pkt()"); 
     282                nrk_int_disable(); 
     283                nrk_led_set(RED_LED); 
     284                while(1) 
     285                        nrk_kprintf(PSTR("process_app_pkt(): Unsupported transport layer type found\r\n")); 
    278286        } 
    279287        return; 
    … …  
    286294                case HELLO:             // HELLO msg 
    287295                         
    288                         enter_cr(nl_sem, "process_nw_ctrl_pkt()");                       
     296                        enter_cr(nl_sem, 29);                    
    289297                        count_HELLO_msg_rcvd++;  
    290                         leave_cr(nl_sem, "process_nw_ctrl_pkt()"); 
     298                        leave_cr(nl_sem, 29); 
    291299                        // unpack the Msg_Hello from the packet payload  
    292300                        unpack_Msg_Hello(&mh, pkt -> data); 
    … …  
    344352                         
    345353                default:  
    346                         go_into_panic("Unsupported network control message received in process_nw_ctrl_pkt()"); 
     354                        nrk_int_disable(); 
     355                        nrk_led_set(RED_LED); 
     356                        while(1) 
     357                                nrk_kprintf(PSTR("process_nw_ctrl_pkt(): Unsupported network control message received\r\n")); 
     358                        break;                   
     359                         
    347360        } // end switch 
    348361         
    … …  
    354367        return; 
    355368} 
    356 /**********************************************************************************************/         
    357  
    358 void nl_rx_task() 
    359 { 
    360         uint8_t len;                               // to hold the size of the received packet, always = sizeof(NW_Packet)  
    361         int8_t rssi;                            // to hold rssi of received packet 
    362         uint8_t *local_rx_buf;     // pointer to receive buffer of link layer 
    363         int8_t val;                                             // status variable to hold the return type of function calls 
    364  
    365         if(DEBUG_NL >= 1) 
    366                 printf("DEBUG: NL_RX_TASK PID=%d\r\n",nrk_get_pid()); 
    367  
    368         // initialise the BMAC layer     
    369         bmac_init(25); 
    370         bmac_rx_pkt_set_buffer(rx_buf, RF_MAX_PAYLOAD_SIZE); 
    371  
    372         while(1) 
    373         { 
    374                 if(DEBUG_NL == 2) 
    375                         nrk_kprintf(PSTR("DEBUG: Waiting for packet in RX task\r\n")); 
    376  
    377                 // wait for the next packet 
    378                 do 
    379                 { 
    380                         val = bmac_wait_until_rx_packet(); 
    381                  
    382                 } while(val == NRK_ERROR); 
    383                  
    384                 if(DEBUG_NL == 2) 
    385                         nrk_kprintf(PSTR("DEBUG: Received a packet\r\n"));     
    386                  
    387                 nrk_led_set(GREEN_LED);                 // shine the LED  
    388          
    389                 // Get the packet  
    390         do 
    391         { 
    392                 local_rx_buf = bmac_rx_pkt_get(&len,&rssi); 
    393                  
    394         } while(local_rx_buf == NULL); 
    395          
    396                 // unpack the packet header from the received buffer  
    397                 unpack_NW_Packet_header(&pkt_rx, local_rx_buf); 
    398                 // copy the packet payload to the data field of the local packet 
    399                 memcpy(pkt_rx.data, local_rx_buf + SIZE_NW_PACKET_HEADER, pkt_rx.length); 
    400                 // Release the RX buffer quickly so future packets can arrive 
    401                 bmac_rx_pkt_release();           
    402                  
    403                 // begin processing this packet 
    404                 if(pkt_type(&pkt_rx) == APPLICATION)    // its an application layer packet  
    405                 { 
    406                         if(pkt_rx.dest == NODE_ADDR || pkt_rx.dest == BCAST_ADDR)        
    407                                 process_app_pkt(&pkt_rx, rssi); 
    408                                  
    409                         else // the packet is destined for some one else 
    410                                 if(pkt_rx.src != NODE_ADDR)     // I did not send this packet  
    411                                         route_packet(&pkt_rx);          // route this packet  
    412                                 else // I sent this pkt and it has come back to me. Drop it 
    413                                         ; 
    414                 } 
    415                 else // its a network control packet  
    416                 { 
    417                         if(pkt_rx.dest == NODE_ADDR || pkt_rx.dest == BCAST_ADDR) 
    418                                 process_nw_ctrl_pkt(&pkt_rx, rssi); 
    419                                  
    420                         else    // the packet is destined for some one else 
    421                                 if(pkt_rx.src != NODE_ADDR)     // I did not send this packet  
    422                                         route_packet(&pkt_rx);          // route this packet  
    423                                 else // I sent this pkt and it has come back to me. Drop it  
    424                                         ; 
    425                 } 
    426                                  
    427                 nrk_led_clr(GREEN_LED);         // clear the LEDs        
    428                 nrk_led_clr(ORANGE_LED); 
    429          
    430         } // end while(1) 
    431          
    432         return; 
    433 }       // end rx_task 
     369 
    434370/*********************************************************************************************/ 
    435371void build_Msg_Hello(Msg_Hello *m) 
    … …  
    451387void build_Msg_NgbList(Msg_NgbList *m) 
    452388{ 
    453         enter_cr(nl_sem, "build_Msg_NgbList()"); 
     389        enter_cr(nl_sem, 32); 
    454390        m -> nl = nl;    
    455         leave_cr(nl_sem, "build_Msg_NgbList()"); 
     391        leave_cr(nl_sem, 32); 
    456392         
    457393        // Build the network packet which will hold the NGB_LIST message 
    … …  
    466402         
    467403        return; 
    468 }                                        
     404}                                
     405/**********************************************************************************************/         
     406 
     407void nl_rx_task() 
     408{ 
     409        uint8_t len;                               // to hold the size of the received packet, always = sizeof(NW_Packet)  
     410        int8_t rssi;                            // to hold rssi of received packet 
     411        uint8_t *local_rx_buf;     // pointer to receive buffer of link layer 
     412        int8_t val;                                             // status variable to hold the return type of function calls 
     413 
     414        if(DEBUG_NL >= 1) 
     415                printf("DEBUG: NL_RX_TASK PID=%d\r\n",nrk_get_pid()); 
     416 
     417        // initialise the BMAC layer     
     418        val = bmac_init(25); 
     419        if(val == NRK_ERROR) 
     420                nrk_kprintf(PSTR("Error returned by bmac_init()\r\n")); 
     421                 
     422        val = bmac_rx_pkt_set_buffer(rx_buf, RF_BUFFER_SIZE); 
     423        if(val == NRK_ERROR) 
     424                nrk_kprintf(PSTR("Error returned in bmac_rx_pkt_set_buffer()\r\n")); 
     425                 
     426 
     427        while(1) 
     428        { 
     429                if(DEBUG_NL == 2) 
     430                        nrk_kprintf(PSTR("DEBUG: Waiting for packet in RX task\r\n")); 
     431 
     432                // wait for the next packet 
     433                while(bmac_rx_pkt_ready() == 0) 
     434                { 
     435                        val = bmac_wait_until_rx_packet(); 
     436                        if(DEBUG_NL == 2) 
     437                                printf("Val here = %d\n", val); 
     438                } 
     439                                 
     440                if(DEBUG_NL == 2) 
     441                        nrk_kprintf(PSTR("DEBUG: Received a packet\r\n"));     
     442                 
     443                nrk_led_set(GREEN_LED);                 // shine the LED  
     444         
     445                // Get the packet  
     446        do 
     447        { 
     448                local_rx_buf = bmac_rx_pkt_get(&len,&rssi); 
     449                if(local_rx_buf == NULL) 
     450                { 
     451                        nrk_kprintf(PSTR("NULL returned by bmac_rx_pkt_get()\r\n")); 
     452                        //break; 
     453                } 
     454                 
     455        } while(local_rx_buf == NULL); 
     456         
     457        if(DEBUG_NL == 2) 
     458        { 
     459                nrk_kprintf(PSTR("Contents of received packet are\r\n")); 
     460                        int8_t i; 
     461                        for(i = 0; i < len; i++) 
     462                                printf("%c ", local_rx_buf[i]); 
     463                }                
     464         
     465                // unpack the packet header from the received buffer  
     466                unpack_NW_Packet_header(&pkt_rx, local_rx_buf); 
     467                // copy the packet payload to the data field of the local packet 
     468                memcpy(pkt_rx.data, local_rx_buf + SIZE_NW_PACKET_HEADER, pkt_rx.length); 
     469                // Release the RX buffer quickly so future packets can arrive 
     470                bmac_rx_pkt_release();           
     471                 
     472                if(pkt_rx.src != 1 && pkt_rx.src != 2)  // Temp if comdition  
     473                        goto xyz; 
     474                 
     475                // begin processing this packet 
     476                if(pkt_type(&pkt_rx) == APPLICATION)    // its an application layer packet  
     477                { 
     478                        if(DEBUG_NL == 2) 
     479                                nrk_kprintf(PSTR("Received an application layer packet\r\n")); 
     480                         
     481                        if(pkt_rx.dest == NODE_ADDR || pkt_rx.dest == BCAST_ADDR)        
     482                                process_app_pkt(&pkt_rx, rssi); 
     483                                 
     484                        else // the packet is destined for some one else 
     485                                if(pkt_rx.src != NODE_ADDR)     // I did not send this packet  
     486                                        route_packet(&pkt_rx);          // route this packet  
     487                                else // I sent this pkt and it has come back to me. Drop it 
     488                                        ; 
     489                } 
     490                else // its a network control packet  
     491                { 
     492                        if(DEBUG_NL == 2) 
     493                                nrk_kprintf(PSTR("Received an network control packet\r\n")); 
     494                         
     495                        if(pkt_rx.dest == NODE_ADDR || pkt_rx.dest == BCAST_ADDR) 
     496                                process_nw_ctrl_pkt(&pkt_rx, rssi); 
     497                                 
     498                        else    // the packet is destined for some one else 
     499                                if(pkt_rx.src != NODE_ADDR)     // I did not send this packet  
     500                                        route_packet(&pkt_rx);          // route this packet  
     501                                else // I sent this pkt and it has come back to me. Drop it  
     502                                        ; 
     503                } 
     504                                 
     505                xyz: nrk_led_clr(GREEN_LED);            // clear the LEDs        
     506                          nrk_led_clr(ORANGE_LED); 
     507         
     508        } // end while(1) 
     509         
     510        return; 
     511}       // end rx_task 
     512         
    469513/*********************************************************************************************/ 
    470514void nl_tx_task() 
    … …  
    495539                }       */                               
    496540                 
    497                 enter_cr(bm_sem, "nl_tx_task()");                
     541                enter_cr(bm_sem, 34);            
    498542                ptr = remove_tx_aq(); 
    499                 leave_cr(bm_sem, "nl_tx_task()"); 
     543                leave_cr(bm_sem, 34); 
    500544                if(ptr == NULL) 
    501                         continue;               // FIX ME  
     545                { 
     546                        nrk_wait_until_next_period();   // FIX ME  
     547                        continue; 
     548                }  
    502549                         
    503550                if( pkt_type((ptr -> pkt).type) == APPLICATION ) 
    … …  
    512559                memcpy(tx_buf + SIZE_NW_PACKET_HEADER, (ptr -> pkt).data, (ptr -> pkt).length); 
    513560                 
    514                 enter_cr(bm_sem, "nl_tx_task()");                
     561                enter_cr(bm_sem, 34);            
    515562                insert_tx_fq(ptr);      // release the transmit buffer into the free queue  
    516                 leave_cr(bm_sem, "nl_tx_task()"); 
     563                leave_cr(bm_sem, 34); 
    517564                 
    518565                do 
    … …  
    524571                ret = nrk_event_wait (SIG(tx_done_signal)); 
    525572           if(ret & SIG(tx_done_signal) == 0 )  
    526                         go_into_panic("Bug discovered in nl_tx_task()"); 
    527                          
     573                { 
     574                        nrk_int_disable(); 
     575                        nrk_led_set(RED_LED); 
     576                        while(1) 
     577                                nrk_kprintf(PSTR("nl_tx_task(): Unknown signal caught\r\n")); 
     578                }                                                        
    528579                // signal 'send done' signal  
    529                 enter_cr(bm_sem, "nl_tx_task()"); 
     580                enter_cr(bm_sem, 34); 
    530581                nrk_event_signal(sd_sig[seg -> srcPort].send_done_signal); 
    531                 leave_cr(bm_sem, "nl_tx_task()"); 
     582                leave_cr(bm_sem, 34); 
    532583   } 
    533584    
    … …  
    539590{ 
    540591  NL_RX_TASK.task = nl_rx_task; 
    541   NL_RX_TASK.Ptos = (void *) &nl_rx_task_stack[NRK_APP_STACKSIZE-1]; 
     592  NL_RX_TASK.Ptos = (void *) &nl_rx_task_stack[NRK_APP_STACKSIZE - 1]; 
    542593  NL_RX_TASK.Pbos = (void *) &nl_rx_task_stack[0]; 
    543   NL_RX_TASK.prio = 3; 
     594  NL_RX_TASK.prio = 19; 
    544595  NL_RX_TASK.FirstActivation = TRUE; 
    545596  NL_RX_TASK.Type = BASIC_TASK; 
    546597  NL_RX_TASK.SchType = PREEMPTIVE; 
    547598   
    548   NL_RX_TASK.period.secs = 3; 
     599  NL_RX_TASK.cpu_reserve.secs = 3; 
     600  NL_RX_TASK.cpu_reserve.nano_secs = 0;   
     601  NL_RX_TASK.period.secs = 4; 
    549602  NL_RX_TASK.period.nano_secs = 0; 
    550   NL_RX_TASK.cpu_reserve.secs = 2; 
    551   NL_RX_TASK.cpu_reserve.nano_secs = 500*NANOS_PER_MS; 
     603    
    552604   
    553605  NL_RX_TASK.offset.secs = 0; 
    … …  
    557609/*****************************************************************************************/   
    558610  NL_TX_TASK.task = nl_tx_task; 
    559   NL_TX_TASK.Ptos = (void *) &nl_tx_task_stack[NRK_APP_STACKSIZE-1]; 
     611  NL_TX_TASK.Ptos = (void *) &nl_tx_task_stack[NRK_APP_STACKSIZE - 1]; 
    560612  NL_TX_TASK.Pbos = (void *) &nl_tx_task_stack[0]; 
    561   NL_TX_TASK.prio = 2; 
     613  NL_TX_TASK.prio = 18; 
    562614  NL_TX_TASK.FirstActivation = TRUE; 
    563615  NL_TX_TASK.Type = BASIC_TASK; 
    564616  NL_TX_TASK.SchType = PREEMPTIVE; 
    565617   
    566   NL_TX_TASK.cpu_reserve.secs = 0; 
     618  NL_TX_TASK.cpu_reserve.secs = 3; 
    567619  NL_TX_TASK.cpu_reserve.nano_secs = 0;  
    568   NL_TX_TASK.period.secs = NL_TX_TASK.cpu_reserve.secs + HELLO_PERIOD; 
     620  NL_TX_TASK.period.secs = 4; 
    569621  NL_TX_TASK.period.nano_secs = 0; 
    570622   
    … …  
    574626 
    575627  if(DEBUG_NL == 2) 
    576         nrk_kprintf(PSTR("DEBUG: Network layer task creation done\r\n")); 
     628        nrk_kprintf(PSTR("create_network_layer_tasks(): Network layer task creation done\r\n")); 
    577629} 
    578630 
    … …  
    596648        nl_sem = nrk_sem_create(1,MAX_TASK_PRIORITY);   // create the mutex   
    597649        if(nl_sem == NULL) 
    598                 go_into_panic("Error creating the semaphore in initialise_network_layer()"); 
     650        { 
     651                nrk_int_disable(); 
     652                nrk_led_set(RED_LED); 
     653                while(1) 
     654                        nrk_kprintf(PSTR("Error creating semaphore in initialise_network_layer()\r\n")); 
     655        } 
    599656         
    600657        create_network_layer_tasks();   // create the two tasks  

  • nano-RK/projects/network_stack/NetworkLayer.h

    r103 r113  
    1212#define TRUE 1 
    1313#define FALSE 0 
    14 #define DEBUG_NL 0      // debug flag for the network layer  
     14#define DEBUG_NL 2      // debug flag for the network layer  
    1515 
    1616/****************************** CONSTANTS *********************************************/ 
    … …  
    3838#define SIZE_NW_PACKET_HEADER 8   
    3939#define SIZE_NW_PACKET (SIZE_NW_PACKET_HEADER + MAX_NETWORK_PAYLOAD) 
     40 
     41#define RF_BUFFER_SIZE 116  
    4042 
    4143/* possible bit mask values of the packet type */ 

  • nano-RK/projects/network_stack/TransportLayerUDP.c

    r103 r113  
    3434extern nrk_sem_t *bm_sem; 
    3535 
    36 extern void enter_cr(nrk_sem_t *, int8_t *); 
     36extern void enter_cr(nrk_sem_t *, int8_t); 
    3737extern void leave_cr(nrk_sem_t *, int8_t *); 
    3838extern int8_t get_num_bufs_free(); 
    … …  
    6565        tl_sem = nrk_sem_create(1,MAX_TASK_PRIORITY);   // create the mutex   
    6666        if(tl_sem == NULL) 
    67                 go_into_panic("Error creating the semaphore in initialise_transport_layer_udp()"); 
    68          
     67        { 
     68                nrk_int_disable(); 
     69                nrk_led_set(RED_LED); 
     70                while(1) 
     71                        nrk_kprintf(PSTR("initialise_transport_layer_udp(): Error creating the semaphore\r\n")); 
     72        }        
    6973        // set the init_done flag  
    7074        tlayer_init_done = 1; 
    … …  
    9498        int8_t result;          // temporary variable 
    9599         
    96         enter_cr(tl_sem, "create_socket()"); 
     100        enter_cr(tl_sem, 3); 
    97101                 
    98102        if(tlayer_init_done != 1) 
    99                 go_into_panic("Transport layer not initialised inside create_socket()"); 
     103        { 
     104                nrk_int_disable(); 
     105                nrk_led_set(RED_LED); 
     106                while(1) 
     107                        nrk_kprintf(PSTR("create_socket(): Transport layer not initialised\r\n")); 
     108        } 
    100109         
    101110        switch(type) 
    … …  
    125134{ 
    126135        int8_t i;       // loop index  
    127          
    128         for(i = EPHEMERAL_PORT_NUM_START; i <= MAX_PORTS; i++)  // check only for ephemeral port numbers  
    129         { 
     136        if(DEBUG_TL == 2) 
     137                printf("Inside get_next_available_ports(). Value of ports = %d\r\n", ports);  
     138         
     139        //for(i = EPHEMERAL_PORT_NUM_START; i <= MAX_PORTS; i++)        // check only for ephemeral port numbers 
     140        for(i = 3; i <= MAX_PORTS; i++)  
     141        { 
     142                if(DEBUG_TL == 2) 
     143                        printf("Inside get_next_available_ports(). i = %d\r\n", i); 
    130144                if( ((ports >> i) & ((uint32_t)1)) == 0 )       // bit 'i' is 0  
    131145                        return i; 
    … …  
    167181        int8_t size;                                                    // size of receive queue allocated for this port  
    168182         
    169         enter_cr(bm_sem, "bind()");      
    170         enter_cr(tl_sem, "bind()"); 
     183        enter_cr(bm_sem, 8);     
     184        enter_cr(tl_sem, 8); 
    171185                         
    172186        if(tlayer_init_done != 1) 
    173                 go_into_panic("Transport Layer not initialised inside bind()"); 
    174                          
     187        { 
     188                nrk_int_disable(); 
     189                nrk_led_set(RED_LED); 
     190                while(1) 
     191                        nrk_kprintf(PSTR("bind(): Transport layer not initialised\r\n")); 
     192        } 
     193                                 
    175194        // ERROR CHECKING  
    176195        if(sock_num < 0 || sock_num >= MAX_PORTS)       // bad input  
    … …  
    238257        rx_buf_mgr[port].pid = nrk_get_pid();           // fill up the members of the ReceiveBufferManager 
    239258        if( nrk_signal_register(rx_buf_mgr[port].seg_arrived_signal) == NRK_ERROR ) 
    240                 go_into_panic("Error while registering for seg_arrived_signal in bind()"); 
     259        { 
     260                nrk_int_disable(); 
     261                nrk_led_set(RED_LED); 
     262                while(1) 
     263                        nrk_kprintf(PSTR("bind(): Error while registering for seg_arrived_signal\r\n")); 
     264        } 
    241265                 
    242266        // allocate 'size' buffers  
    … …  
    245269                index = get_index_unallocated_rx_buf(); // look for the unallocated receive buffer  
    246270                if(index == NRK_ERROR)  //       this should not happen  
    247                         go_into_panic("Bug found in bind()"); 
    248                  
    249                 insert_rx_fq(&rx_buf_udp[index], port, EMPTY);  // insert the buffer in the free queue of the port  
     271                { 
     272                        nrk_int_disable(); 
     273                        nrk_led_set(RED_LED); 
     274                        while(1) 
     275                                nrk_kprintf(PSTR("bind(): Bug found in implementation of num_bufs_free\r\n")); 
     276                } 
     277                 
     278                insert_rx_fq(&rx_buf_udp[index], port, EMPTY);  // insert the buffer in the free queue of the port 
     279                rx_buf_mgr[port].countTotal++;                                          // increment the countTotal for this port  
    250280                num_bufs_free--;                 
    251281        } 
    … …  
    261291        int8_t count; 
    262292         
    263         enter_cr(bm_sem, "bind()");      
    264         enter_cr(tl_sem, "bind()"); 
     293        enter_cr(bm_sem, 9);     
     294        enter_cr(tl_sem, 9); 
    265295         
    266296        // ERROR checking 
    … …  
    269299                _nrk_errno_set(INVALID_ARGUMENT); 
    270300                 
    271                 leave_cr(tl_sem, "bind()");      
    272                 leave_cr(bm_sem, "bind()"); 
     301                leave_cr(tl_sem, 9);     
     302                leave_cr(bm_sem, 9); 
    273303                return NRK_ERROR; 
    274304        } 
    … …  
    278308                _nrk_errno_set(INVALID_SOCKET); 
    279309                 
    280                 leave_cr(tl_sem, "bind()");      
    281                 leave_cr(bm_sem, "bind()"); 
     310                leave_cr(tl_sem, 9);     
     311                leave_cr(bm_sem, 9); 
    282312                return NRK_ERROR; 
    283313        } 
    … …  
    285315        if(sock[sock_num].port == INVALID_PORT) // no socket operations were performed yet 
    286316        { 
    287                 leave_cr(tl_sem, "bind()");      
    288                 leave_cr(bm_sem, "bind()");      
     317                leave_cr(tl_sem, 9);     
     318                leave_cr(bm_sem, 9);     
    289319                return 0; 
    290320        } 
    … …  
    294324        count = rx_buf_mgr[port].countTotal; 
    295325         
    296         leave_cr(tl_sem, "bind()");      
    297         leave_cr(bm_sem, "bind()"); 
     326        leave_cr(tl_sem, 9);     
     327        leave_cr(bm_sem, 9); 
    298328        return count; 
    299329}        
    … …  
    307337        int8_t index;           // stores the index of next unallocated receive buffer   
    308338                 
    309         enter_cr(bm_sem, "set_rx_queue_size()"); 
    310         enter_cr(tl_sem, "set_rx_queue_size()"); 
     339        enter_cr(bm_sem, 10); 
     340        enter_cr(tl_sem, 10); 
    311341                 
    312342        if(tlayer_init_done != 1) 
    313                 go_into_panic("Transport Layer not initialised. Inside set_rx_queue_size()"); 
    314          
     343        { 
     344                nrk_int_disable(); 
     345                nrk_led_set(RED_LED); 
     346                while(1) 
     347                        nrk_kprintf(PSTR("set_rx_queue_size(): Transport layer not initialised\r\n")); 
     348        } 
     349                 
    315350        flag = 0;                       // assume bind() was called prior to this call   
    316351        // ERROR CHECKING  
    … …  
    319354                _nrk_errno_set(INVALID_ARGUMENT); 
    320355                 
    321                 leave_cr(tl_sem, "set_rx_queue_size()"); 
    322                 leave_cr(bm_sem, "set_rx_queue_size()"); 
     356                leave_cr(tl_sem, 10); 
     357                leave_cr(bm_sem, 10); 
    323358                return NRK_ERROR; 
    324359        } 
    … …  
    328363                _nrk_errno_set(INVALID_SOCKET); 
    329364                 
    330                 leave_cr(tl_sem, "set_rx_queue_size()"); 
    331                 leave_cr(bm_sem, "set_rx_queue_size()"); 
     365                leave_cr(tl_sem, 10); 
     366                leave_cr(bm_sem, 10); 
    332367                return NRK_ERROR; 
    333368        } 
    … …  
    339374                if(port == NRK_ERROR)                                           // no port available  
    340375                { 
    341                         leave_cr(tl_sem, "set_rx_queue_size()"); 
    342                         leave_cr(bm_sem, "set_rx_queue_size()"); 
     376                        leave_cr(tl_sem, 10); 
     377                        leave_cr(bm_sem, 10); 
    343378                        return NRK_ERROR;                                                       // errorNo is already set to NO_PORTS_AVAILABLE 
    344379                }  
    … …  
    347382                        _nrk_errno_set(NO_RX_BUFFERS_AVAILABLE); 
    348383                         
    349                         leave_cr(tl_sem, "set_rx_queue_size()"); 
    350                         leave_cr(bm_sem, "set_rx_queue_size()"); 
     384                        leave_cr(tl_sem, 10); 
     385                        leave_cr(bm_sem, 10); 
    351386                        return NRK_ERROR; 
    352387           } 
    … …  
    355390                sock[sock_num].port = port; 
    356391                assign_port(port); 
    357                 if( nrk_signal_register(rx_buf_mgr[port].seg_arrived_signal) == NRK_ERROR) 
    358                         go_into_panic("Error while registering for seg_arrived_signal in set_rx_queue_size()"); 
     392                if( nrk_signal_register(rx_buf_mgr[port].seg_arrived_signal) == NRK_ERROR ) 
     393                { 
     394                        nrk_int_disable(); 
     395                        nrk_led_set(RED_LED); 
     396                        while(1) 
     397                                nrk_kprintf(PSTR("set_rx_queue_size(): Error registering for seg_arrived_signal\r\n")); 
     398                }  
    359399        } 
    360400        else // bind was called earlier. DEFAULT_RX_QUEUE_SIZE buffers already allocated 
    … …  
    363403                if(size == DEFAULT_RX_QUEUE_SIZE)       // nothing to do, buffers already allocated 
    364404                { 
    365                         leave_cr(tl_sem, "set_rx_queue_size()"); 
    366                         leave_cr(bm_sem, "set_rx_queue_size()"); 
     405                        leave_cr(tl_sem, 10); 
     406                        leave_cr(bm_sem, 10); 
    367407                        return size; 
    368408                } 
    … …  
    383423                index = get_index_unallocated_rx_buf(); // look for the next unallocated receive buffer  
    384424                if(index == NRK_ERROR)  //       this should not happen  
    385                         go_into_panic("Bug found in set_rx_queue_size()"); 
    386                  
    387                 insert_rx_fq(&rx_buf_udp[index], port, EMPTY);  // insert the buffer in the free queue of the port  
     425                { 
     426                        nrk_int_disable(); 
     427                        nrk_led_set(RED_LED); 
     428                        while(1) 
     429                                nrk_kprintf(PSTR("set_rx_queue_size(): Bug found in implementation of num_bufs_free\r\n")); 
     430                }                
     431                insert_rx_fq(&rx_buf_udp[index], port, EMPTY);  // insert the buffer in the free queue of the port 
     432                rx_buf_mgr[port].countTotal++;  
    388433                num_bufs_free--;                 
    389434        } 
    390435         
    391         leave_cr(tl_sem, "set_rx_queue_size()"); 
    392         leave_cr(bm_sem, "set_rx_queue_size()"); 
     436        leave_cr(tl_sem, 10); 
     437        leave_cr(bm_sem, 10); 
    393438        return size; 
    394439} 
    … …  
    399444        ReceiveBufferUDP *buf;                  // pointer to traverse the buffer list of the free queue  
    400445         
    401         enter_cr(bm_sem, "release_buffer()");    
    402         enter_cr(tl_sem, "release_buffer()");    
     446        enter_cr(bm_sem, 11);    
     447        enter_cr(tl_sem, 11);    
    403448         
    404449        // ERROR CHECKING  
    … …  
    407452                _nrk_errno_set(INVALID_ARGUMENT); 
    408453                 
    409                 leave_cr(tl_sem, "release_buffer()");    
    410                 leave_cr(bm_sem, "release_buffer()"); 
     454                leave_cr(tl_sem, 11);    
     455                leave_cr(bm_sem, 11); 
    411456                return NRK_ERROR; 
    412457        } 
    … …  
    415460                _nrk_errno_set(INVALID_SOCKET); 
    416461                 
    417                 leave_cr(tl_sem, "release_buffer()");    
    418                 leave_cr(bm_sem, "release_buffer()"); 
     462                leave_cr(tl_sem, 11);    
     463                leave_cr(bm_sem, 11); 
    419464                return NRK_ERROR; 
    420465        } 
    … …  
    423468                _nrk_errno_set(INVALID_SOCKET); 
    424469                 
    425                 leave_cr(tl_sem, "release_buffer()");    
    426                 leave_cr(bm_sem, "release_buffer()"); 
     470                leave_cr(tl_sem, 11);    
     471                leave_cr(bm_sem, 11); 
    427472                return NRK_ERROR; 
    428473        } 
    … …  
    442487                _nrk_errno_set(INVALID_ARGUMENT); 
    443488                 
    444                 leave_cr(tl_sem, "release_buffer()");    
    445                 leave_cr(bm_sem, "release_buffer()"); 
     489                leave_cr(tl_sem, 11);    
     490                leave_cr(bm_sem, 11); 
    446491                return NRK_ERROR; 
    447492        } 
    … …  
    450495        rx_buf_mgr[port].countFree++;  
    451496         
    452         leave_cr(tl_sem, "release_buffer()");    
    453         leave_cr(bm_sem, "release_buffer()"); 
     497        leave_cr(tl_sem, 11);    
     498        leave_cr(bm_sem, 11); 
    454499        return NRK_OK; 
    455500} 
    … …  
    460505        ReceiveBufferUDP *ptr;  // temp variable  
    461506                 
    462         enter_cr(bm_sem, "close_socket()"); 
    463         enter_cr(tl_sem, "close_socket()"); 
     507        enter_cr(bm_sem, 12); 
     508        enter_cr(tl_sem, 12); 
    464509         
    465510        // ERROR checking  
    … …  
    468513                _nrk_errno_set(INVALID_ARGUMENT); 
    469514                 
    470                 leave_cr(tl_sem, "close_socket()"); 
    471                 leave_cr(bm_sem, "close_socket()"); 
     515                leave_cr(tl_sem, 12); 
     516                leave_cr(bm_sem, 12); 
    472517                return NRK_ERROR; 
    473518        }        
    … …  
    476521                _nrk_errno_set(INVALID_SOCKET); 
    477522                 
    478                 leave_cr(tl_sem, "close_socket()"); 
    479                 leave_cr(bm_sem, "close_socket()"); 
     523                leave_cr(tl_sem, 12); 
     524                leave_cr(bm_sem, 12); 
    480525                return NRK_ERROR; 
    481526        } 
    … …  
    487532                rx_buf_mgr[port].pid = INVALID_PID; 
    488533                if( nrk_signal_delete(rx_buf_mgr[port].seg_arrived_signal) == NRK_ERROR ) 
    489                         go_into_panic("Error while deleting seg_arrived_signal in close_socket()"); 
     534                { 
     535                        nrk_int_disable(); 
     536                        nrk_led_set(RED_LED); 
     537                        while(1) 
     538                                nrk_kprintf(PSTR("close_socket(): Error in deleting seg_arrived_signal\r\n")); 
     539                } 
    490540 
    491541                // remove all the FULL buffers from the port queue                       
    … …  
    507557        sock[sock_num].pid = INVALID_PID; 
    508558         
    509         leave_cr(tl_sem, "close_socket()"); 
    510         leave_cr(bm_sem, "close_socket()");      
     559        leave_cr(tl_sem, 12); 
     560        leave_cr(bm_sem, 12);    
    511561        return NRK_OK; 
    512562} 
    … …  
    514564int8_t is_port_associated(int8_t port) 
    515565{ 
    516         enter_cr(tl_sem, "is_port_associated()"); 
     566        enter_cr(tl_sem, 13); 
    517567                 
    518568        if(check_port_available(port) == NRK_OK) 
    519569        { 
    520                 leave_cr(tl_sem, "is_port_associated()"); 
     570                leave_cr(tl_sem, 13); 
    521571                return FALSE; 
    522572        } 
    523         leave_cr(tl_sem, "is_port_associated()"); 
     573        leave_cr(tl_sem, 13); 
    524574        return TRUE; 
    525575} 
    … …  
    529579        int8_t port;                    // to hold the port number corresponding to the socket number passed 
    530580        int8_t result;                  // to hold the return type of various functions  
    531                          
    532         enter_cr(bm_sem, "send()"); 
    533         enter_cr(tl_sem, "send()"); 
     581         
     582        if(DEBUG_TL == 2) 
     583                nrk_kprintf(PSTR("Entered send operation of TL\r\n")); 
     584                         
     585        enter_cr(bm_sem, 14); 
     586        enter_cr(tl_sem, 14); 
     587         
     588        if(DEBUG_TL == 2) 
     589                nrk_kprintf(PSTR("Inside CR of send operation of TL\r\n")); 
    534590         
    535591        // ERROR checking 
    … …  
    538594                _nrk_errno_set(INVALID_ARGUMENT); 
    539595                 
    540                 leave_cr(tl_sem, "send()"); 
    541                 leave_cr(bm_sem, "send()");              
     596                leave_cr(tl_sem, 14); 
     597                leave_cr(bm_sem, 14);            
    542598                return NRK_ERROR; 
    543599        } 
    … …  
    547603                _nrk_errno_set(INVALID_ARGUMENT); 
    548604                 
    549                 leave_cr(tl_sem, "send()"); 
    550                 leave_cr(bm_sem, "send()"); 
     605                leave_cr(tl_sem, 14); 
     606                leave_cr(bm_sem, 14); 
    551607                return NRK_ERROR; 
    552608        } 
    … …  
    556612                _nrk_errno_set(INVALID_ARGUMENT); 
    557613                 
    558                 leave_cr(tl_sem, "send()"); 
    559                 leave_cr(bm_sem, "send()"); 
     614                leave_cr(tl_sem, 14); 
     615                leave_cr(bm_sem, 14); 
    560616                return NRK_ERROR; 
    561617        } 
    … …  
    565621                _nrk_errno_set(INVALID_ARGUMENT); 
    566622                 
    567                 leave_cr(tl_sem, "send()"); 
    568                 leave_cr(bm_sem, "send()"); 
     623                leave_cr(tl_sem, 14); 
     624                leave_cr(bm_sem, 14); 
    569625                return NRK_ERROR; 
    570626        } 
    … …  
    574630                _nrk_errno_set(INVALID_SOCKET); 
    575631                 
    576                 leave_cr(tl_sem, "send()"); 
    577                 leave_cr(bm_sem, "send()"); 
     632                leave_cr(tl_sem, 14); 
     633                leave_cr(bm_sem, 14); 
    578634                return NRK_ERROR; 
    579635        } 
    … …  
    583639                                                                                                                        // not called earlier 
    584640        { 
    585                 // FIX ME IMPORTANT.................             
     641                // FIX ME IMPORTANT.................     
     642                leave_cr(tl_sem, 14); 
     643                leave_cr(bm_sem, 14);    
    586644                result = set_rx_queue_size(sock_num, DEFAULT_RX_QUEUE_SIZE); 
     645                enter_cr(bm_sem, 14); 
     646                enter_cr(tl_sem, 14); 
    587647                if(result == NRK_ERROR)         // error number will be set already  
    588648                { 
    589                         leave_cr(tl_sem, "send()"); 
    590                         leave_cr(bm_sem, "send()");              
     649                        leave_cr(tl_sem, 14); 
     650                        leave_cr(bm_sem, 14);            
    591651                        return NRK_ERROR; 
    592652                } 
    … …  
    595655        // register for the 'send done' signal  
    596656        if( nrk_signal_register(sd_sig[port].send_done_signal) == NRK_ERROR ) 
    597                 go_into_panic("Error while registering for send_done_signal in send()"); 
    598          
     657        { 
     658                nrk_int_disable(); 
     659                nrk_led_set(RED_LED); 
     660                while(1) 
     661                        nrk_kprintf(PSTR("send(): Error while registering for send_done_signal\r\n")); 
     662        }        
    599663                 
    600664        // prepare a UDP segment  
    … …  
    615679                 
    616680        // insert the packet into the active transmit queue of the system 
     681         
     682        if(DEBUG_TL == 2) 
     683                nrk_kprintf(PSTR("Inside send(). Before inserting packet in transmit queue\r\n")); 
     684                 
    617685        result = insert_tx_aq(&pkt); 
     686         
     687        if(DEBUG_TL == 2) 
     688                nrk_kprintf(PSTR("Inside send(). After inserting packet in transmit queue\r\n")); 
     689                 
    618690        if(result == NRK_ERROR) 
    619691                _nrk_errno_set(NO_TX_BUFFERS_AVAILABLE); 
    620692                 
    621         leave_cr(tl_sem, "send()"); 
    622         leave_cr(bm_sem, "send()");      
     693        leave_cr(tl_sem, 14); 
     694        leave_cr(bm_sem, 14);    
    623695        return result; 
    624696                         
    … …  
    627699int8_t set_timeout(int8_t sock_num, int8_t secs, int8_t nano_secs) 
    628700{ 
    629         enter_cr(tl_sem, "set_timeout()"); 
     701        enter_cr(tl_sem, 15); 
    630702         
    631703         
    … …  
    635707                _nrk_errno_set(INVALID_ARGUMENT); 
    636708                 
    637                 leave_cr(tl_sem, "set_timeout()"); 
     709                leave_cr(tl_sem, 15); 
    638710                return NRK_ERROR; 
    639711        } 
    … …  
    643715                _nrk_errno_set(INVALID_ARGUMENT); 
    644716                 
    645                 leave_cr(tl_sem, "set_timeout()"); 
     717                leave_cr(tl_sem, 15); 
    646718                return NRK_ERROR; 
    647719        }  
    … …  
    651723                _nrk_errno_set(INVALID_SOCKET); 
    652724                 
    653                 leave_cr(tl_sem, "set_timeout()"); 
     725                leave_cr(tl_sem, 15); 
    654726                return NRK_ERROR; 
    655727        } 
    … …  
    660732        sock[sock_num].timeout.nano_secs = nano_secs; 
    661733         
    662         leave_cr(tl_sem, "set_timeout()");       
     734        leave_cr(tl_sem, 15);    
    663735        return NRK_OK; 
    664736} 
    … …  
    671743        Transport_Segment_UDP *seg;// pointer to received segment from the network layer  
    672744         
    673         enter_cr(bm_sem, "receive()"); 
    674         enter_cr(tl_sem, "receive()"); 
     745        enter_cr(bm_sem, 16); 
     746        enter_cr(tl_sem, 16); 
    675747         
    676748        // ERROR checking 
    … …  
    679751                _nrk_errno_set(INVALID_ARGUMENT); 
    680752                 
    681                 leave_cr(tl_sem, "receive()"); 
    682                 leave_cr(bm_sem, "receive()"); 
     753                leave_cr(tl_sem, 16); 
     754                leave_cr(bm_sem, 16); 
    683755                return NULL; 
    684756        } 
    … …  
    688760                _nrk_errno_set(INVALID_SOCKET); // socket description not complete 
    689761                 
    690                 leave_cr(tl_sem, "receive()"); 
    691                 leave_cr(bm_sem, "receive()"); 
     762                leave_cr(tl_sem, 16); 
     763                leave_cr(bm_sem, 16); 
    692764                return NULL; 
    693765        } 
    … …  
    698770        { 
    699771                // the user has not specified any maximum wait period  
     772                if(DEBUG_TL == 2) 
     773                        nrk_kprintf(PSTR("receive(): Inside the section that relates to 'without timeout' receive\r\n")); 
    700774                 
    701775                // check the receive buffer manager for this port to see if there are any queued segments 
    702776                if(rx_buf_mgr[port].countFree == rx_buf_mgr[port].countTotal)   // no queued segments  
    703777                { 
     778                        if(DEBUG_TL == 2) 
     779                                printf("receive(): No segments in receive queue of port = %d\n", port); 
    704780                        while(1) 
    705781                        { 
    706                                 leave_cr(tl_sem, "receive()"); 
    707                                 leave_cr(bm_sem, "receive()"); 
     782                                leave_cr(tl_sem, 16); 
     783                                leave_cr(bm_sem, 16); 
    708784                                my_sigs = nrk_event_wait(SIG(rx_buf_mgr[port].seg_arrived_signal));     // block 
    709                                 enter_cr(bm_sem, "receive()"); 
    710                                 enter_cr(tl_sem, "receive()");   
     785                                enter_cr(bm_sem, 16); 
     786                                enter_cr(tl_sem, 16);   
    711787                 
    712788                                // check what signal we got  
    713789                        if(my_sigs == 0)                        
    714                                 go_into_panic("Error calling nrk_event_wait() in receive()..1"); 
    715          
     790                        { 
     791                                nrk_int_disable(); 
     792                                        nrk_led_set(RED_LED); 
     793                                        while(1) 
     794                                                nrk_kprintf(PSTR("receive(): Error calling nrk_event_wait (without timeout)\r\n")); 
     795                                }        
    716796                                if( my_sigs & SIG(rx_buf_mgr[port].seg_arrived_signal) )        // got a segment  
     797                                { 
     798                                        if(DEBUG_TL == 2) 
     799                                        nrk_kprintf(PSTR("receive(): Received the seg arrived signal\r\n")); 
    717800                                break; 
     801                        } 
    718802                                else    // some other signal was received by the task. Go back and wait for 'seg arrived' 
    719                                         go_into_panic("Bug discovered in receive()...1");  
     803                                { 
     804                                        nrk_int_disable(); 
     805                                        nrk_led_set(RED_LED); 
     806                                        while(1) 
     807                                                nrk_kprintf(PSTR("receive(): Unknown signal received (without timeout)\r\n")); 
     808                                }  
    720809                        } // end while(1)  
    721810                } // end if 
    … …  
    723812        else // the user has specified a timeout value  
    724813        { 
     814                if(DEBUG_TL == 2) 
     815                        nrk_kprintf(PSTR("receive(): Inside the section that relates to 'with timeout' receive\r\n")); 
     816                         
    725817                if( nrk_signal_register(nrk_wakeup_signal) == NRK_ERROR) 
    726                         go_into_panic("nrk_signal_register(nrk_wakeup_signal) returned an error in receive()"); 
     818                { 
     819                        nrk_int_disable(); 
     820                        nrk_led_set(RED_LED); 
     821                        while(1) 
     822                                nrk_kprintf(PSTR("receive(): Error in registering for nrk_wakeup_signal (with timeout)\r\n")); 
     823                } 
    727824                if( nrk_set_next_wakeup(sock[sock_num].timeout) == NRK_ERROR) 
    728                         go_into_panic("nrk_set_next_wakeup() returned an error in receive()"); 
    729                  
     825                { 
     826                        nrk_int_disable(); 
     827                        nrk_led_set(RED_LED); 
     828                        while(1) 
     829                                nrk_kprintf(PSTR("receive(): Error returned by nrk_set_next_wakeup (with timeout)\r\n")); 
     830                }                
    730831                // check the receive manager for this port to see if there are any queued segments 
    731832                if(rx_buf_mgr[port].countFree == rx_buf_mgr[port].countTotal)   // no queued segments  
    … …  
    733834                        while(1) 
    734835                        { 
    735                                 leave_cr(tl_sem, "receive()"); 
    736                                 leave_cr(bm_sem, "receive()"); 
     836                                leave_cr(tl_sem, 16); 
     837                                leave_cr(bm_sem, 16); 
    737838                                my_sigs = nrk_event_wait(SIG(rx_buf_mgr[port].seg_arrived_signal) | SIG(nrk_wakeup_signal)); 
    738                                 enter_cr(bm_sem, "receive()"); 
    739                                 enter_cr(tl_sem, "receive()");                                    
     839                                enter_cr(bm_sem, 16); 
     840                                enter_cr(tl_sem, 16);                                     
    740841                 
    741842                                // check what signal we got  
    742843                        if(my_sigs == 0)                        
    743                                 go_into_panic("Error calling nrk_event_wait() in receive()..2"); 
    744          
     844                        { 
     845                                nrk_int_disable(); 
     846                                        nrk_led_set(RED_LED); 
     847                                        while(1) 
     848                                                nrk_kprintf(PSTR("receive(): Error calling nrk_event_wait() (with timeout)\r\n")); 
     849                                }        
    745850                        if( my_sigs & SIG(rx_buf_mgr[port].seg_arrived_signal) )        // got a segment  
    746851                        { 
    747852                                sock[sock_num].timeout.secs = 0;                // invalidate the timeout  
    748853                                sock[sock_num].timeout.nano_secs = 0; 
     854                                if(DEBUG_TL == 2) 
     855                                        nrk_kprintf(PSTR("Received the seg arrived signal\r\n")); 
    749856                                // FIX me change the wakeup period back to what it was 
    750857                                break; 
    … …  
    758865                                _nrk_errno_set(SOCKET_TIMEOUT); 
    759866                                 
    760                                 leave_cr(tl_sem, "receive()"); 
    761                                         leave_cr(bm_sem, "receive()"); 
     867                                leave_cr(tl_sem, 16); 
     868                                        leave_cr(bm_sem, 16); 
    762869                                        return NULL; 
    763870                        } 
    764871                        else 
    765                                 go_into_panic("Bug discovered in receive()...2"); 
     872                        { 
     873                                nrk_int_disable(); 
     874                                        nrk_led_set(RED_LED); 
     875                                        while(1) 
     876                                                nrk_kprintf(PSTR("receive(): Unknown signal received (with timeout)\r\n")); 
     877                                } 
    766878                } // end while(1) 
    767879        } // end if  
    … …  
    775887   buf = remove_rx_pq(port);    // remove the buffer from the port queue  
    776888   if(buf == NULL)      // this should not happen  
    777         go_into_panic("Bug discovered in receive()...3"); 
     889   { 
     890        nrk_int_disable(); 
     891                nrk_led_set(RED_LED); 
     892                while(1) 
     893                        nrk_kprintf(PSTR("receive(): Bug found in implementation of seg_arrived_signal / rx buffer mgmt\r\n")); 
     894        } 
    778895   insert_rx_fq(buf, port, FULL);       // insert the buffer into the free queue with status = FULL  
    779          
    780896   seg = &(buf -> seg); 
    781897    
    … …  
    789905                *rssi = buf -> rssi; 
    790906 
    791         leave_cr(tl_sem, "receive()"); 
    792         leave_cr(bm_sem, "receive()"); 
     907        leave_cr(tl_sem, 16); 
     908        leave_cr(bm_sem, 16); 
    793909        return seg -> data; 
    794910} 
    … …  
    800916        int8_t count1, count2, count3; 
    801917         
    802         enter_cr(bm_sem, "check_receive_queue()"); 
    803         enter_cr(tl_sem, "check_receive_queue()"); 
     918        enter_cr(bm_sem, 17); 
     919        enter_cr(tl_sem, 17); 
    804920         
    805921         
    … …  
    809925                _nrk_errno_set(INVALID_ARGUMENT); 
    810926                 
    811                 leave_cr(tl_sem, "check_receive_queue()"); 
    812                 leave_cr(bm_sem, "check_receive_queue()"); 
     927                leave_cr(tl_sem, 17); 
     928                leave_cr(bm_sem, 17); 
    813929                return NRK_ERROR; 
    814930        } 
    … …  
    818934                _nrk_errno_set(INVALID_SOCKET); 
    819935                 
    820                 leave_cr(tl_sem, "check_receive_queue()"); 
    821                 leave_cr(bm_sem, "check_receive_queue()"); 
     936                leave_cr(tl_sem, 17); 
     937                leave_cr(bm_sem, 17); 
    822938                return NRK_ERROR; 
    823939        } 
    … …  
    828944        count3 = get_in_process_buf_count(port); 
    829945         
    830         leave_cr(tl_sem, "check_receive_queue()"); 
    831         leave_cr(bm_sem, "check_receive_queue()"); 
     946        leave_cr(tl_sem, 17); 
     947        leave_cr(bm_sem, 17); 
    832948        return count1 - count2 - count3; 
    833949} 
    … …  
    838954        nrk_sig_mask_t my_sigs; // temp variable  
    839955         
    840         enter_cr(bm_sem, "wait_until_send_done()"); 
    841         enter_cr(tl_sem, "wait_until_send_done()"); 
     956        enter_cr(bm_sem, 18); 
     957        enter_cr(tl_sem, 18); 
    842958         
    843959        // ERROR checking 
    … …  
    846962                _nrk_errno_set(INVALID_ARGUMENT); 
    847963                 
    848                 leave_cr(tl_sem, "wait_until_send_done()"); 
    849                 leave_cr(bm_sem, "wait_until_send_done()"); 
     964                leave_cr(tl_sem, 18); 
     965                leave_cr(bm_sem, 18); 
    850966                return NRK_ERROR; 
    851967        } 
    … …  
    855971                _nrk_errno_set(INVALID_SOCKET); 
    856972                 
    857                 leave_cr(tl_sem, "wait_until_send_done()"); 
    858                 leave_cr(bm_sem, "wait_until_send_done()"); 
     973                leave_cr(tl_sem, 18); 
     974                leave_cr(bm_sem, 18); 
    859975                return NRK_ERROR; 
    860976        } 
    … …  
    867983                while(1) 
    868984                { 
    869                         leave_cr(tl_sem, "wait_until_send_done()"); 
    870                         leave_cr(bm_sem, "wait_until_send_done()");                      
     985                        leave_cr(tl_sem, 18); 
     986                        leave_cr(bm_sem, 18);                    
    871987                        my_sigs = nrk_event_wait( SIG(sd_sig[port].send_done_signal) ); 
    872                         enter_cr(bm_sem, "wait_until_send_done()"); 
    873                         enter_cr(tl_sem, "wait_until_send_done()"); 
     988                        enter_cr(bm_sem, 18); 
     989                        enter_cr(tl_sem, 18); 
    874990                 
    875991                        if(my_sigs == 0) 
    876                                 go_into_panic("Error calling nrk_event_wait() in wait_until_send_done()..1"); 
     992                        { 
     993                                nrk_int_disable(); 
     994                                nrk_led_set(RED_LED); 
     995                                while(1) 
     996                                        nrk_kprintf(PSTR("wait_until_send_done(): Error returned by nrk_event_wait() (without timeout)\r\n")); 
     997                        } 
    877998                         
    878999                        if( my_sigs & SIG(sd_sig[port].send_done_signal) ) 
    8791000                        { 
    880                                 leave_cr(tl_sem, "wait_until_send_done()"); 
    881                                 leave_cr(bm_sem, "wait_until_send_done()");                      
     1001                                leave_cr(tl_sem, 18); 
     1002                                leave_cr(bm_sem, 18);                    
    8821003                                return NRK_OK; 
    8831004                        } 
    8841005                                 
    8851006                        else    // unknown signal 
    886                                 go_into_panic("Bug discovered in wait_until_send_done()...1"); 
     1007                        { 
     1008                                nrk_int_disable(); 
     1009                                nrk_led_set(RED_LED); 
     1010                                while(1) 
     1011                                        nrk_kprintf(PSTR("wait_until_send_done(): Unknown signal received (without timeout)\r\n")); 
     1012                        } 
    8871013                } // end while(1) 
    8881014        } 
    … …  
    8901016        { 
    8911017                if( nrk_signal_register(nrk_wakeup_signal) == NRK_ERROR ) 
    892                         go_into_panic("nrk_signal_register(nrk_wakeup_signal) returned an error in wait_until_send_done()"); 
     1018                { 
     1019                        nrk_int_disable(); 
     1020                        nrk_led_set(RED_LED); 
     1021                        while(1) 
     1022                                nrk_kprintf(PSTR("wait_until_send_done(): Error registering for nrk_wakeup_signal\r\n")); 
     1023                } 
    8931024                if( nrk_set_next_wakeup(sock[sock_num].timeout) == NRK_ERROR) 
    894                         go_into_panic("nrk_set_next_wakeup() returned an error in wait_until_send_done()"); 
    895                   
     1025                { 
     1026                        nrk_int_disable(); 
     1027                        nrk_led_set(RED_LED); 
     1028                        while(1) 
     1029                                nrk_kprintf(PSTR("wait_until_send_done(): Error returned by nrk_set_next_wakeup()\r\n")); 
     1030                }                 
    8961031                while(1) 
    8971032                { 
    898                         leave_cr(tl_sem, "wait_until_send_done()"); 
    899                         leave_cr(bm_sem, "wait_until_send_done()");                      
     1033                        leave_cr(tl_sem, 18); 
     1034                        leave_cr(bm_sem, 18);                    
    9001035                        my_sigs = nrk_event_wait( SIG(sd_sig[port].send_done_signal) | SIG(nrk_wakeup_signal) ); 
    901                         enter_cr(bm_sem, "wait_until_send_done()"); 
    902                         enter_cr(tl_sem, "wait_until_send_done()"); 
     1036                        enter_cr(bm_sem, 18); 
     1037                        enter_cr(tl_sem, 18); 
    9031038                         
    9041039                        if(my_sigs == 0) 
    905                                 go_into_panic("Error calling nrk_event_wait() in wait_until_send_done()..2"); 
     1040                        { 
     1041                                nrk_int_disable(); 
     1042                                nrk_led_set(RED_LED); 
     1043                                while(1) 
     1044                                        nrk_kprintf(PSTR("wait_until_send_done(): Error returned by nrk_event_wait() (with timeout)\r\n")); 
     1045                        } 
    9061046                                 
    9071047                        if( my_sigs & SIG(sd_sig[port].send_done_signal) ) 
    … …  
    9101050                                sock[sock_num].timeout.nano_secs = 0;  
    9111051                                 
    912                                 leave_cr(tl_sem, "wait_until_send_done()"); 
    913                                 leave_cr(bm_sem, "wait_until_send_done()"); 
     1052                                leave_cr(tl_sem, 18); 
     1053                                leave_cr(bm_sem, 18); 
    9141054                                return NRK_OK; 
    9151055                        } 
    … …  
    9211061                                _nrk_errno_set(SOCKET_TIMEOUT); 
    9221062                                 
    923                                 leave_cr(tl_sem, "wait_until_send_done()"); 
    924                                 leave_cr(bm_sem, "wait_until_send_done()"); 
     1063                                leave_cr(tl_sem, 18); 
     1064                                leave_cr(bm_sem, 18); 
    9251065                                return NRK_ERROR; 
     1066                        } 
     1067                        else    // unknown signal caught 
     1068                        { 
     1069                                nrk_int_disable(); 
     1070                                nrk_led_set(RED_LED); 
     1071                                while(1) 
     1072                                        nrk_kprintf(PSTR("wait_until_send_done(): Unknown signal received (with timeout)\r\n")); 
    9261073                        } 
    9271074                } //end while(1) 
    9281075        } // end else  
    9291076         
    930         leave_cr(tl_sem, "wait_until_send_done()"); 
    931         leave_cr(bm_sem, "wait_until_send_done()"); 
     1077        leave_cr(tl_sem, 18); 
     1078        leave_cr(bm_sem, 18); 
    9321079        return NRK_ERROR; 
    9331080} 

  • nano-RK/projects/network_stack/TransportLayerUDP.h

    r103 r113  
    1212/********************************* CONSTANTS **********************************************/ 
    1313 
    14 #define DEBUG_TL 0                                      // debug flag for the transport layer  
     14#define DEBUG_TL 0                                      // debug flag for the transport layer  
    1515 
    1616// Types of sockets supported by the network stack  
    … …  
    2424#define SIZE_TRANSPORT_UDP_HEADER 3 
    2525#define MAX_TRANSPORT_UDP_SEG (MAX_APP_PAYLOAD + SIZE_TRANSPORT_UDP_HEADER) 
    26 #define MAX_PORTS                         24    // maximum number of ports that can be opened in the system  
     26#define MAX_PORTS                          4    // maximum number of ports that can be opened in the system  
    2727#define INVALID_PORT                    0  // indicates an invalid port number  
    2828#define INVALID_PID                     0  // indicates an invalid pid (reserved for the kernel) 

  • nano-RK/projects/network_stack/nrk_cfg.h

    r103 r113  
    22*                            NanoRK CONFIG                     * 
    33***************************************************************/ 
    4  
    54#ifndef __nrk_cfg_h      
    65#define __nrk_cfg_h 
    … …  
    87// NRK_REPORT_ERRORS will cause the kernel to print out information about 
    98// missed deadlines or reserve violations