Changeset 101


Ignore:
Timestamp:
06/18/2007 06:31:30 PM (5 years ago)
Author:
agr
Message:

counting reserves added

Location:
nano-RK
Files:
4 added
8 edited

Legend:

Unmodified
Added
Removed

  • nano-RK/include/common.mk

    r95 r101  
    6666SRC += $(ROOT_DIR)/src/kernel/source/nrk_scheduler.c 
    6767SRC += $(ROOT_DIR)/src/kernel/source/nrk_driver.c 
     68SRC += $(ROOT_DIR)/src/kernel/source/nrk_reserve.c 
    6869SRC += $(ROOT_DIR)/src/kernel/hal/$(MCU)/nrk_timer.c 
    6970SRC += $(ROOT_DIR)/src/kernel/hal/$(MCU)/nrk_status.c 

  • nano-RK/projects/basic_rtl/rtl_tx/main.c

    r1 r101  
    3737  nrk_init(); 
    3838 
    39   nrk_clr_led(0); 
    40   nrk_clr_led(1); 
    41   nrk_clr_led(2); 
    42   nrk_clr_led(3); 
     39  nrk_led_clr(0); 
     40  nrk_led_clr(1); 
     41  nrk_led_clr(2); 
     42  nrk_led_clr(3); 
    4343   
    4444  nrk_time_set(0,0); 
    … …  
    7474   
    7575  while(!rtl_ready())  nrk_wait_until_next_period();  
    76   nrk_set_led(0);   
     76  nrk_led_set(0);   
    7777  while(1) { 
    7878          
    7979          if( rtl_check_rx_status()!=0 ) 
    8080               { 
    81                    nrk_set_led(1); 
     81                   nrk_led_set(1); 
    8282                   printf( "Got Packet on slot %d %d: ",rtl_rx_slot,rtl_rfRxInfo.length ); 
    8383                   for(i=PKT_DATA_START; i<rtl_rfRxInfo.length; i++ ) 
    … …  
    8787                   nrk_kprintf( PSTR("\r\n") ); 
    8888                   rtl_release_rx_packet(); 
    89                    nrk_clr_led(1); 
     89                   nrk_led_clr(1); 
    9090               } 
    9191  
    … …  
    9595               } 
    9696          else { 
    97                 nrk_set_led(2); 
     97                nrk_led_set(2); 
    9898                cnt++; 
    9999                rfTxInfo.pPayload=tx_buf; 
    … …  
    102102                rtl_tx_packet( &rfTxInfo, MY_TX_SLOT ); 
    103103                printf( "Sending Packet on slot %d\r\n",MY_TX_SLOT ); 
    104                 nrk_clr_led(2); 
     104                nrk_led_clr(2); 
    105105               } 
    106106           

  • nano-RK/projects/basic_rtl/rtl_tx/makefile

    r1 r101  
    2929 
    3030# Platform name  cc2420DK, firefly, micaZ 
    31 PLATFORM = firefly2 
     31PLATFORM = firefly2_2 
    3232 
    3333ROOT_DIR = ../../.. 

  • nano-RK/src/kernel/include/nrk_reserve.h

    r15 r101  
    2929* Anthony Rowe 
    3030*******************************************************************************/ 
     31#ifndef NRK_RESERVE_H 
     32#define NRK_RESERVE_H 
     33 
     34#include <nrk_cfg.h> 
     35 
     36#ifdef NRK_MAX_RESERVES 
     37 
     38void _nrk_reserve_init(); 
     39 
     40int8_t nrk_reserve_create(); 
     41int8_t nrk_reserve_delete(uint8_t reserve_id); 
     42// Get counts remaining 
     43uint8_t nrk_reserve_get(uint8_t reserve_id); 
     44// Set period and counts in reserve 
     45int8_t nrk_reserve_set(uint8_t id, nrk_time_t *period,int16_t access_count,void *errhandler); 
     46// Consume reserve 
     47int8_t nrk_reserve_consume(uint8_t reserve_id); 
     48 
     49void _nrk_reserve_update(uint8_t reserve_id); 
    3150 
    3251 
    33 void nrk_consume_reserve(uint8_t reserve_id); 
    34 int32_t nrk_status(uint8_t reserve_id,uint8_t options); 
    35 uint8_t nrk_set_reserve(uint32_t seconds,uint32_t nanoseconds,int16_t access_count,uint8_t type,uint8_t id,void *errhandler); 
    3652typedef struct nrk_reserve 
    3753{ 
    38 uint32_t period;//period in ticks 
    39 uint32_t s_time; 
    40 uint32_t c_time;//current time in ticks 
    41 int16_t access;//reserve on number of calls etc.. 
    42 int16_t c_access;//current count of accesses 
    43 uint8_t  id; 
    44 uint8_t  type; 
     54uint32_t period_ticks; //period in ticks 
     55uint32_t set_time; 
     56uint32_t cur_time;//current time in ticks 
     57int16_t set_access;//reserve on number of calls etc.. 
     58int16_t cur_access;//current count of accesses 
     59int8_t  active; 
    4560void (*error)(); 
    4661}nrk_reserve; 
    47 nrk_reserve * get_reserve(uint8_t reserve_id); 
     62 
     63#endif 
     64#endif 

  • nano-RK/src/kernel/source/nrk.c

    r95 r101  
    4343#include <nrk_stack_check.h> 
    4444#include <nrk_status.h> 
     45#include <nrk_reserve.h> 
    4546#include <nrk_cfg.h> 
    4647 
    … …  
    105106    nrk_high_ready_TCB = NULL; 
    106107    nrk_high_ready_prio = 0;  
     108 
     109     
     110    // Setup the reserve structures 
     111    _nrk_reserve_init(); 
    107112 
    108113    _nrk_resource_cnt=0; //NRK_MAX_RESOURCE_CNT; 

  • nano-RK/src/kernel/source/nrk_reserve.c

    r15 r101  
    3131*******************************************************************************/ 
    3232 
     33#include <nrk_cfg.h> 
    3334 
    34 #include<nrk_time.h> 
    35 #include<nrk.h> 
    36 #include<nrk_cfg.h> 
    37 #include<nrk_error.h> 
     35#ifdef NRK_MAX_RESERVES 
     36 
     37#include <nrk_time.h> 
     38#include <nrk.h> 
     39#include <nrk_error.h> 
    3840#include <nrk_reserve.h> 
    39 int _curr_reserve_count=0; 
     41 
    4042nrk_reserve _nrk_reserve[NRK_MAX_RESERVES]; 
    4143//experimental 
    42 nrk_reserve * get_reserve(uint8_t reserve_id) 
     44 
     45 
     46// This function is called by the kernel at startup 
     47// to clear the list of reserves 
     48void _nrk_reserve_init () 
    4349{ 
    44         int i=0; 
    45          for(i=0;i<_curr_reserve_count;i++) 
    46         if(_nrk_reserve[i].id==reserve_id) 
    47                 return & _nrk_reserve[i]; 
     50  uint8_t i; 
    4851 
    49                 return NULL; 
     52  for (i = 0; i < NRK_MAX_RESERVES; i++) 
     53    _nrk_reserve[i].active = -1; 
     54} 
    5055 
     56// This function returns the id of a free reserve 
     57// This returns NRK_ERROR if there are no free reserves 
     58int8_t nrk_reserve_create () 
     59{ 
     60  int8_t i; 
     61  for (i = 0; i < NRK_MAX_RESERVES; i++) { 
     62    if (_nrk_reserve[i].active == -1) { 
     63      // Check and Accept 
     64      _nrk_reserve[i].active = 1; 
     65      return i; 
     66    } 
     67  } 
     68 
     69  return NRK_ERROR; 
    5170} 
    52 void nrk_consume_reserve(uint8_t reserve_id) 
     71 
     72// This function frees a current reserve 
     73// This returns NRK_ERROR if the reserve does not exist 
     74int8_t nrk_reserve_delete (uint8_t reserve_id) 
     75{ 
     76  int8_t i; 
     77  if (reserve_id >= 0 && reserve_id < NRK_MAX_RESERVES) { 
     78    if (_nrk_reserve[i].active == 1) { 
     79      _nrk_reserve[i].active = 0; 
     80      return NRK_OK; 
     81    } 
     82  } 
     83  return NRK_ERROR; 
     84} 
     85 
     86 
     87 
     88 
     89uint8_t nrk_reserve_get (uint8_t reserve_id) 
    5390{ 
    5491 
     92  if (reserve_id >= NRK_MAX_RESERVES) { 
     93    _nrk_errno_set (1); 
     94    return 0; 
     95  } 
     96  if (_nrk_reserve[reserve_id].active == -1) { 
     97    // Reserve isn't active  
     98    _nrk_errno_set (2); 
     99    return 0; 
     100  } 
    55101 
    56         nrk_time_t t; 
    57         nrk_int_disable(); 
    58         nrk_time_get(&t);//maybe inline 
     102  _nrk_reserve_update (reserve_id); 
    59103 
    60         _nrk_reserve[reserve_id].c_time=(int32_t)_nrk_time_to_ticks_long(t);  
    61         if(_nrk_reserve[reserve_id].c_time>=_nrk_reserve[reserve_id].s_time) 
    62         { 
    63                 _nrk_reserve[reserve_id].s_time=_nrk_reserve[reserve_id].c_time + _nrk_reserve[reserve_id].period; 
    64                 _nrk_reserve[reserve_id].c_access=0; 
    65                 nrk_int_enable(); 
    66         } 
    67         else if((_nrk_reserve[reserve_id].access-1<=_nrk_reserve[reserve_id].c_access))  
    68         { 
    69                 nrk_int_enable(); 
    70                _nrk_reserve[reserve_id].error();  
    71         } 
    72         else 
    73         { 
    74                 _nrk_reserve[reserve_id].c_access++; 
    75                 nrk_int_enable(); 
    76         } 
    77 }        
     104  if (_nrk_reserve[reserve_id].cur_access > 
     105      _nrk_reserve[reserve_id].set_access) 
     106    return 0; 
     107  return (_nrk_reserve[reserve_id].set_access - 
     108          _nrk_reserve[reserve_id].cur_access); 
     109} 
    78110 
    79 int32_t nrk_status(uint8_t reserve_id,uint8_t options) 
     111void _nrk_reserve_update (uint8_t reserve_id) 
    80112{ 
     113  nrk_time_t t; 
    81114 
    82         if(options) 
    83                 return (_nrk_reserve[reserve_id].c_time-_nrk_reserve[reserve_id].c_time);  
    84         else 
    85                 return _nrk_reserve[reserve_id].access-_nrk_reserve[reserve_id].c_access-1; 
     115  nrk_int_disable (); 
     116  nrk_time_get (&t); 
     117 
     118  _nrk_reserve[reserve_id].cur_time = (int32_t) _nrk_time_to_ticks_long (t); 
     119  if (_nrk_reserve[reserve_id].cur_time >= _nrk_reserve[reserve_id].set_time) { 
     120    // If the reserve is passed its period then replenish it 
     121    _nrk_reserve[reserve_id].set_time = 
     122      _nrk_reserve[reserve_id].cur_time + 
     123      _nrk_reserve[reserve_id].period_ticks; 
     124    _nrk_reserve[reserve_id].cur_access = 0; 
     125  } 
     126  nrk_int_enable (); 
    86127 
    87128} 
    88129 
    89 uint8_t nrk_set_reserve(uint32_t seconds,uint32_t nanoseconds,int16_t access_count,uint8_t type,uint8_t id,void *errhandler)  
    90 {                                                          
    91         nrk_time_t tmp_time; 
    92     if(_curr_reserve_count>NRK_MAX_RESERVES) 
    93         { 
    94                 return 0; 
    95         } 
    96         tmp_time.secs=seconds;   
    97         tmp_time.nano_secs=nanoseconds; 
    98         _nrk_reserve[_curr_reserve_count].period=_nrk_time_to_ticks_long(tmp_time); 
    99         _nrk_reserve[_curr_reserve_count].access=access_count; 
    100         _nrk_reserve[_curr_reserve_count].c_access=0; 
    101         _nrk_reserve[_curr_reserve_count].id=id; 
    102         nrk_time_get(&tmp_time);//maybe inline 
    103         _nrk_reserve[_curr_reserve_count].c_time=(uint32_t)_nrk_time_to_ticks_long(tmp_time);   
    104         _nrk_reserve[_curr_reserve_count].s_time=_nrk_reserve[_curr_reserve_count].c_time + _nrk_reserve[_curr_reserve_count].period; 
    105         _nrk_reserve[_curr_reserve_count].type=type; 
    106         _nrk_reserve[_curr_reserve_count].error=(void*)errhandler; 
    107         _curr_reserve_count++; 
    108         return _curr_reserve_count-1; 
     130int8_t nrk_reserve_consume (uint8_t reserve_id) 
     131{ 
     132 
     133  if (reserve_id >= NRK_MAX_RESERVES) { 
     134    _nrk_errno_set (1); 
     135    return NRK_ERROR; 
     136  } 
     137  if (_nrk_reserve[reserve_id].active == -1) { 
     138    _nrk_errno_set (2); 
     139    return NRK_ERROR; 
     140  } 
     141 
     142  _nrk_reserve_update (reserve_id); 
     143 
     144  if ((_nrk_reserve[reserve_id].set_access < 
     145       _nrk_reserve[reserve_id].cur_access)) { 
     146    // You violated your resource (like MJ after a little boy) 
     147    nrk_int_enable (); 
     148    if (_nrk_reserve[reserve_id].error != NULL) 
     149      _nrk_reserve[reserve_id].error (); 
     150    return NRK_ERROR; 
     151  } 
     152  else { 
     153    // Reserve is fine. Take some of it. 
     154    _nrk_reserve[reserve_id].cur_access++; 
     155  } 
     156 
     157 
     158  return NRK_OK; 
    109159} 
     160 
     161int8_t nrk_reserve_set (uint8_t id, nrk_time_t * period, int16_t access_count, 
     162                        void *errhandler) 
     163{ 
     164  nrk_time_t tmp_time; 
     165 
     166  if (id >= NRK_MAX_RESERVES) 
     167    return NRK_ERROR; 
     168  if (_nrk_reserve[id].active == -1) 
     169    return NRK_ERROR; 
     170 
     171  tmp_time.secs = period->secs; 
     172  tmp_time.nano_secs = period->nano_secs; 
     173  _nrk_reserve[id].period_ticks = _nrk_time_to_ticks_long (tmp_time); 
     174  _nrk_reserve[id].set_access = access_count; 
     175  _nrk_reserve[id].cur_access = 0; 
     176 
     177  nrk_time_get (&tmp_time); 
     178  _nrk_reserve[id].cur_time = (uint32_t) _nrk_time_to_ticks_long (tmp_time); 
     179  _nrk_reserve[id].set_time = 
     180    _nrk_reserve[id].cur_time + _nrk_reserve[id].period_ticks; 
     181  _nrk_reserve[id].error = (void *) errhandler; 
     182 
     183  return NRK_OK; 
     184} 
     185 
     186#endif 

  • nano-RK/src/kernel/source/nrk_time.c

    r15 r101  
    158158uint32_t ticks; 
    159159uint32_t tmp; 
    160 // FIXME: This will overflow 
    161160 
    162161if(t.secs>=1) 

  • nano-RK/src/net/rt_link/platform/firefly2/rt_link.c

    r15 r101  
    7373 
    7474  
    75 #define RTL_DEBUG 
     75//#define RTL_DEBUG 
    7676//#define LED_DEBUG 
    7777#define GPIO_SLOT_DEBUG 
    … …  
    348348    timer=0; 
    349349    battery_save_cnt=0; 
    350     nrk_set_led (2); 
     350    nrk_led_set(2); 
    351351while(1) 
    352352{ 
    … …  
    354354rtl_rfRxInfo.pPayload[GLOBAL_SLOT+1]=0xFF; 
    355355#ifdef LED_DEBUG 
    356     nrk_set_led (1); 
     356    nrk_led_set(1); 
    357357#endif 
    358358#ifdef GPIO_RX_DEBUG 
    … …  
    481481 
    482482#ifdef LED_DEBUG 
    483     nrk_clr_led (1); 
     483    nrk_led_clr(1); 
    484484#endif 
    485485          
    … …  
    573573 
    574574#ifdef LED_DEBUG 
    575     nrk_set_led (1); 
     575    nrk_led_set(1); 
    576576#endif 
    577577    rf_set_rx (&rtl_rfRxInfo, rtl_param.channel);       // sets rx buffer and channel  
    … …  
    592592                #endif 
    593593                #ifdef LED_DEBUG 
    594                 nrk_clr_led (1); 
     594                nrk_led_clr(1); 
    595595                #endif 
    596                 rtl_debug_dropped_pkt(); 
     596                // FIXME: add this back later 
     597                // rtl_debug_dropped_pkt(); 
    597598            return; 
    598599        } 
    … …  
    624625        uint8_t explicit_sync_pkt; 
    625626        // CRC and checksum passed 
    626         rtl_debug_rx_pkt(1); 
     627        // FIXME: DEBUG add back 
     628        //rtl_debug_rx_pkt(1); 
    627629        rtl_rx_data_ready = 1; 
    628630        rtl_rx_slot = slot; 
    … …  
    659661 
    660662#ifdef LED_DEBUG 
    661     nrk_clr_led (1); 
     663    nrk_led_clr (1); 
    662664#endif 
    663665#ifdef GPIO_RX_DEBUG 
    … …  
    692694#endif 
    693695#ifdef LED_DEBUG 
    694     nrk_set_led (0); 
     696    nrk_led_set(0); 
    695697#endif 
    696698    //rf_tx_packet (rtl_rfTxInfo[slot]); 
    … …  
    704706 
    705707#ifdef LED_DEBUG 
    706     nrk_clr_led (0); 
     708    nrk_led_clr (0); 
    707709#endif 
    708710#ifdef GPIO_TX_DEBUG 
Note: See TracChangeset for help on using the changeset viewer.