Changeset 95

Timestamp:

06/12/2007 06:42:37 PM (5 years ago)

Author:

agr

Message:

FireFly 2_2 adc device driver

Location:

nano-RK

Files:

• include/common.mk (modified) (1 diff)
• projects/basic_bmac/makefile (modified) (1 diff)
• projects/basic_tasks/nrk_cfg.h (modified) (1 diff)
• src/drivers/include/nrk_driver_list.h (modified) (1 diff)
• src/drivers/platform/firefly2_2 (added)
• src/drivers/platform/firefly2_2/include (added)
• src/drivers/platform/firefly2_2/include/adc_driver.h (added)
• src/drivers/platform/firefly2_2/include/ff_basic_sensor.h (added)
• src/drivers/platform/firefly2_2/source (added)
• src/drivers/platform/firefly2_2/source/adc_driver.c (added)
• src/drivers/platform/firefly2_2/source/ff_basic_sensor.c (added)
• src/kernel/hal/atmega1281/nrk_timer.c (modified) (5 diffs)
• src/kernel/include/nrk_cpu.h (modified) (1 diff)
• src/kernel/include/nrk_driver.h (modified) (1 diff)
• src/kernel/source/nrk.c (modified) (1 diff)
• src/kernel/source/nrk_driver.c (modified) (1 diff)
• src/kernel/source/nrk_scheduler.c (modified) (4 diffs)
• src/platform/firefly2_2/include/hal.h (modified) (1 diff)
• src/platform/firefly2_2/include/hal_firefly2_2.h (modified) (5 diffs)

nano-RK/include/common.mk

@@ -151 +151 @@
 # Set these parameters for the micaZ
 UISP = uisp
-UISP_FLAGS = -dprog=mib510 -dserial=/dev/ttyS0 --wr_fuse_h=0xd8 -dpart=ATmega128 --wr_fuse_e=ff  --erase --upload if=$(TARGET).srec
+UISP_FLAGS = -dprog=mib510 -dserial=$(PROGRAMMING_PORT) --wr_fuse_h=0xd8 -dpart=ATmega128 --wr_fuse_e=ff  --erase --upload if=$(TARGET).srec
 
 ################################# AVR DUDE SETTINGS ##########################

nano-RK/projects/basic_bmac/makefile

@@ -1 +1 @@
 # Platform name  cc2420DK, firefly, micaZ
-PLATFORM = firefly2
+PLATFORM = firefly2_2
 
 

nano-RK/projects/basic_tasks/nrk_cfg.h

@@ -10 +10 @@
 // NRK_HALT_ON_ERRORS will cause the kernel to freeze on errors so that
 // it is easier to see debugging messages.
-//#define NRK_HALT_AND_LOOP_ON_ERROR
+#define NRK_HALT_AND_LOOP_ON_ERROR
 
 // If you want to disable the looping kernel error message when the system
 // halts, then include the following define.  This will automatically
 // halt the error as well.
-#define NRK_HALT_ON_ERROR
+//#define NRK_HALT_ON_ERROR
 
 // NRK_STACK_CHECK adds a little check to see if the bottom of the stack

nano-RK/src/drivers/include/nrk_driver_list.h

@@ -31 +31 @@
 
 // DEVICE ID ASSIGNMENTS
-#define FIREFLY_SENSORS 1
-#define ADC_DEV_MANAGER 1
-#define QLIGHT_DEV0 2
+// These ids must be known by the implementation of the driver
+#define ADC_DEV_MANAGER         0
+#define FIREFLY_SENSOR_BASIC    1
 
 
-// Typical Driver States
-#define INIT_STATE 0
-#define OPEN_STATE 1
-#define CLOSE_STATE 2 
-#define HIGH_FREQ 3 
-#define STDIO 3
-#define STATUS 7
 
-
-//First level of direction primitives 
-#define READ_STATE  STDIO + 1
-#define READ  READ_STATE
-#define WRITE_STATE STDIO + 2
-#define WRITE WRITE_STATE
-#define RW_STATE STDIO + 3
-#define READ_WRITE RW_STATE
-
-

nano-RK/src/kernel/hal/atmega1281/nrk_timer.c

@@ -56 +56 @@
   OCR2A = _nrk_prev_timer_val;
   TIFR2 =   BM(OCF2A) | BM(TOV2);       // Clear interrupt flag
- // TIMSK =  BM(OCIE0) | BM(TOIE0) ;//| BM(TICIE1);    // Enable interrupt
-  //TCCR0 = BM(WGM01) | BM(CS02) | BM(CS00); //|      // reset counter on interrupt, set divider to 128
   TCCR2A = BM(WGM21);
   TCCR2B = BM(CS21) | BM(CS20); //|      // reset counter on interrupt, set divider to 128
   GTCCR |= BM(PSRASY);              // reset prescaler
-  //GTCCR |= TSM;              // reset prescaler
-  #ifdef NRK_DRIVER_CNTs
-  ETIFR =   BM(OCF3A);       // Clear interrupt flag
-  TIMSK =  BM(OCIE3A);//| BM(TICIE1);    // Enable interrupt
-  TCCR3A = BM(WGM32)|BM(CS32); //|      // reset counter on interrupt, set divider to 128
-  OCR3AH=0x00;
-  OCR3AL=250;
-  #endif
   // Clear interrupt flag
   TIFR2 =   BM(OCF2A) | BM(TOV2);       
@@ -147 +137 @@
 void _nrk_start_raw_timer()
 {
-  //SFIOR |= BM(PSR2);              // reset prescaler
   GTCCR |= BM(PSRASY);              // reset prescaler
   TCNT2 = 0;                  // reset counter
   TIMSK2 |=   BM(OCIE2A) | BM(TOIE2) ;//| BM(TICIE1);    // Enable interrupt
-/*
-   printf( "starting timer\r\n" );      
-        do{
-        printf( "timer = %d\r\n",(volatile)TCNT2);
-        }while(1);*/
 }
 
@@ -163 +147 @@
 
     GTCCR |= BM(PSRASY);              // reset prescaler
-    //SFIOR |= BM(PSR2);              // reset prescaler
     TCNT2 = 0;                  // reset counter
     _nrk_time_trigger=0;
@@ -192 +175 @@
 SIGNAL(__vector_default) {
         nrk_kernel_error_add(NRK_SEG_FAULT,0);
-        //printf("Seg Fault");
         while(1);
 }
 
-#ifdef NRK_MAX_DRIVER_CNT
-SIGNAL(SIG_OUTPUT_COMPARE3A)
-{
-        nrk_high_freq_driver_scheduler();
-return;
-
-}
-#endif  
 SIGNAL(TIMER2_OVF_vect) {
 
 nrk_kernel_error_add(NRK_TIMER_OVERFLOW,0);
-//      nrk_kprintf( "\r\n*Timer overflow!!!\r\n" );
-//      SET_LED_0();
-//      SET_LED_1();
-//      SET_LED_2();
-        while(1);
         return;         
 } 
 
 SIGNAL(TIMER2_COMPA_vect) {
-        //static uint8_t i=0;
-        //_nrk_time_trigger++;
-/*      if(i==0 ) {
-           SET_LED_2();
-           i=1;
-        }else
-        {
-           CLR_LED_2();
-           i=0;
-        }
-*/
-      //  printf( "Timer 2 interrup fired!\r\n" );      
         _nrk_timer_suspend_task();      
         return;         
@@ -237 +194 @@
 //-------------------------------------------------------------------------------------------------------
 SIGNAL(SIG_OUTPUT_COMPARE1A) {
-        static uint8_t i=0;
 
-        CLR_LED_1();
-        if(i==0 ) {
-
-           SET_LED_0();
-                i=1;
-        }else
-        {
-           CLR_LED_0();
-           i=0;
-
-        }
-
-        //SuspendTask2();       
         return;         
 } 

nano-RK/src/kernel/include/nrk_cpu.h

@@ -42 +42 @@
 
 // This is the deep sleep wakeup penalty...
-#define _NRK_SLEEP_WAKEUP_TIME  10 
+#define _NRK_SLEEP_WAKEUP_TIME  15 
 
 

nano-RK/src/kernel/include/nrk_driver.h

@@ -34 +34 @@
 #define NRK_DRIVER_H
 
-#define NRK_FREQ_DRIVER 0
-#define NRK_GPIO_DRIVER 1
-#define OPEN 0
-#define CLOSE 1
+#include <stdint.h>
+
+// Driver Open/Close 
+#define WAS_OPEN  1
+#define WAS_NOT_OPEN 0
+
+
+// Driver Actions 
+#define INIT            0
+#define OPEN            1
+#define CLOSE           2
+#define GET_STATUS      3
+#define SET_STATUS      4
+#define READ            5
+#define WRITE           6
+
+// Access Privileges Bits
+#define READ_FLAG       1
+#define WRITE_FLAG      2
+#define APPEND_FLAG     4
+
 
 typedef struct nrk_driver
 {
-        uint8_t dev_id; /* for enabling and disabling device drivers */
-        uint16_t type;/* type of driver GPIO or fast frequency drivers*/
-        uint8_t (*devicemanager)(uint8_t state,uint8_t opt,uint8_t*buf,uint8_t size);/*function pointer to the driver call*/
+        int8_t dev_id; 
+        // for enabling and disabling device drivers 
+        int8_t access_priv;
+        // Access privileges (read, write, append etc) 
+        int8_t (*devicemanager)(uint8_t state,uint8_t opt,uint8_t*buf,uint8_t size); 
+        // function pointer to the driver call
 
-}NRKDriver;
+} NRKDriver;
+
 
 int8_t nrk_register_driver(void *devicemanager,uint8_t driver_name);
-//int8_t nrk_register_driver(void(*devicemanager()),uitn8_t driver_name);
-//int8_t nrk_register_driver(uint8_t *devicemanager,uint8_t driver_name);
 int8_t nrk_open(uint8_t dev_id,uint8_t opt); // options provide the ablility to set_status
-uint8_t nrk_read(uint8_t dev_fd,uint8_t *buffer,uint8_t size);
-uint8_t nrk_write(uint8_t dev_fd,uint8_t opt);
-uint8_t nrk_close(uint8_t dev_fd); // options provide the ablility to set_status
-uint8_t nrk_check_high_freq();
-uint8_t nrk_high_freq_driver_scheduler();
-uint8_t nrk_driver_set_high_freq(uint8_t dev_id,uint16_t freq);
-uint8_t nrk_driver_stop_high_freq(uint8_t dev_id);
-uint8_t nrk_set_status(uint8_t dev_fd,uint8_t key,uint8_t value);
-uint8_t nrk_get_status(uint8_t dev_fd,uint8_t key);
+int8_t nrk_read(uint8_t dev_fd,uint8_t *buffer,uint8_t size);
+int8_t nrk_write(uint8_t dev_fd,uint8_t *buffer, uint8_t size);
+int8_t nrk_close(uint8_t dev_fd); // options provide the ablility to set_status
+int8_t nrk_set_status(uint8_t dev_fd,uint8_t key,uint8_t value);
+int8_t nrk_get_status(uint8_t dev_fd,uint8_t key);
 
 #endif

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

@@ -77 +77 @@
    #endif
 
+     nrk_led_clr(ORANGE_LED);
+     nrk_led_clr(BLUE_LED);
+     nrk_led_set(GREEN_LED);
+     nrk_led_clr(RED_LED);
+
+
     #ifdef KERNEL_STK_ARRAY
         stkc = (uint16_t*)&nrk_kernel_stk[NRK_KERNEL_STACKSIZE-1];

nano-RK/src/kernel/source/nrk_driver.c

@@ -50 +50 @@
 
 NRKDriver nrk_drivers[NRK_MAX_DRIVER_CNT];
-uint8_t driver_record_init[NRK_MAX_DRIVER_CNT]; /*keep track of the the driver state post initialization;*/ 
-uint8_t _nrk_driver_count;
-uint8_t NRKHighFreqDriverSchedule;
-uint8_t NRKHighFreqDriverCurrSchedule;
+uint8_t nrk_driver_init[NRK_MAX_DRIVER_CNT];
 
-int8_t nrk_register_driver(void *devicemanager,uint8_t driver_name)
+int8_t _nrk_driver_count;
+
+/*
+ * nrk_register_driver()
+ *
+ * This function takes a pointer to the entrance of a driver function
+ * and returns a device handler for the driver.
+ *
+ *
+ */
+
+int8_t nrk_register_driver(void *devicemanager,uint8_t dev_index)
 {
                 if(_nrk_driver_count<NRK_MAX_DRIVER_CNT)
                 {
-                 nrk_drivers[_nrk_driver_count].dev_id=driver_name; 
+                 nrk_drivers[_nrk_driver_count].dev_id=dev_index; 
                  nrk_drivers[_nrk_driver_count].devicemanager=(void*)devicemanager;
                  _nrk_driver_count++;
-                 return 1;
+                 return NRK_OK;
                 }
                  else
-                         return -1;
+                         return NRK_ERROR;
 }
-// create READ_STATE WRITE_STATE READ_WRITE_STATE CLOSE_STATE
-/*limit only 127 open devices at once.*/  // returns file descriptor
-int8_t nrk_open(uint8_t dev_id,uint8_t opt) // options provide the ablility to set_status
+
+
+int8_t nrk_open(uint8_t dev_index,uint8_t opt) 
 {
-        uint8_t cnt;
+uint8_t cnt;
+
+
                 for(cnt=0;cnt<_nrk_driver_count;cnt++)
                 {
-                      if(nrk_drivers[cnt].dev_id==dev_id)  
+                      if(nrk_drivers[cnt].dev_id==dev_index)  
                       {
-                              if(!driver_record_init[cnt])
+                                if(nrk_driver_init[cnt]==WAS_NOT_OPEN)
                                       {
-                                       driver_record_init[cnt]=1;
-                                        nrk_drivers[cnt].devicemanager(INIT_STATE,opt,NULL,0);
+                                        // Only call init the first time driver is opened
+                                        nrk_driver_init[cnt]=WAS_OPEN;
+                                        nrk_drivers[cnt].devicemanager(INIT,opt,NULL,0);
                                       }
-                        nrk_drivers[cnt].devicemanager(OPEN_STATE,opt,NULL,0);
+                        nrk_drivers[cnt].devicemanager(OPEN,opt,NULL,0);
                         return cnt;
                       }
                 }
- return -1;
+
+ return NRK_ERROR;
 }
  
-uint8_t nrk_close(uint8_t dev_fd)
+int8_t nrk_close(uint8_t dev_fd)
 {
-        /*causes the device to be reinitialized once its been closed*/
-                     uint8_t error=nrk_drivers[dev_fd].devicemanager(CLOSE_STATE,0,NULL,0);
-                     if(!error)
-                        driver_record_init[dev_fd]=0;
-                        
-                     return error;
+uint8_t error;
+
+        if(dev_fd<0 || dev_fd>_nrk_driver_count)
+                {
+                _nrk_errno_set(1);  // invalid device
+                return NRK_ERROR;
+                }
+
+error=nrk_drivers[dev_fd].devicemanager(CLOSE,0,NULL,0);
+
+// Do we need to do init on a second reopen?
+//if(!error)
+//      driver_record_init[dev_fd]=0;
+
+return error;
 } 
 
 
-uint8_t nrk_read(uint8_t dev_fd,uint8_t *buffer,uint8_t size)
+int8_t nrk_write(uint8_t dev_fd,uint8_t *buffer, uint8_t size)
 {
+        if(dev_fd<0 || dev_fd>_nrk_driver_count)
+                {
+                _nrk_errno_set(1);  // invalid device
+                return NRK_ERROR;
+                }
 
+         return nrk_drivers[dev_fd].devicemanager(WRITE,0,buffer,size);
 
-         return nrk_drivers[dev_fd].devicemanager(READ_STATE,0,buffer,size);
+}
+
+int8_t nrk_read(uint8_t dev_fd,uint8_t *buffer,uint8_t size)
+{
+        if(dev_fd<0 || dev_fd>_nrk_driver_count)
+                {
+                _nrk_errno_set(1);  // invalid device
+                return NRK_ERROR;
+                }
+
+         return nrk_drivers[dev_fd].devicemanager(READ,0,buffer,size);
 
 }
 /*if key is 0 then assumed to create a frequency setting*/
-uint8_t nrk_set_status(uint8_t dev_fd,uint8_t key,uint8_t value)
+int8_t nrk_set_status(uint8_t dev_fd,uint8_t key,uint8_t value)
 {
-         return nrk_drivers[dev_fd].devicemanager(key,value,NULL,0);
+        if(dev_fd<0 || dev_fd>_nrk_driver_count)
+                {
+                _nrk_errno_set(1);  // invalid device
+                return NRK_ERROR;
+                }
+         return nrk_drivers[dev_fd].devicemanager(SET_STATUS,key,NULL,value);
 } 
 
-uint8_t nrk_get_status(uint8_t dev_fd,uint8_t key)
+int8_t nrk_get_status(uint8_t dev_fd,uint8_t key)
 {
-        return nrk_drivers[dev_fd].devicemanager(key,0,NULL,0);
+        if(dev_fd<0 || dev_fd>_nrk_driver_count)
+                {
+                _nrk_errno_set(1);  // invalid device
+                return NRK_ERROR;
+                }
+
+        return nrk_drivers[dev_fd].devicemanager(GET_STATUS,key,NULL,0);
 }
-uint8_t nrk_driver_set_high_freq(uint8_t dev_id,uint16_t freq)
-{
-    uint8_t i;
-           /*timer 2 setup*/
-           #ifdef NRK_DRIVER_FREQ
-           /* if(!nrk_check_high_freq())
-            {
-              *  TIMSK=BM(OCIE1A)|BM(OCIE0);
-                TCCR0=BM(WGM01) | BM(CS01);
-                TCNT0=0x00;
-                OCR0=(uint16_t)(NRK_DRIVER_FREQ*100)/32;  
-            }                              i*/
-            for(i=0;i<NRK_MAX_DRIVER_CNT;i++)
-            if(nrk_drivers[i].dev_id==dev_id)
-                    nrk_drivers[i].type=freq/NRK_DRIVER_FREQ;
- 
-            if(NRKHighFreqDriverSchedule > nrk_drivers[i].type)
-                    NRKHighFreqDriverSchedule=nrk_drivers[i].type;
-            return nrk_drivers[i].type;
-           #else
-           return 0;
-           #endif
-}
-uint8_t nrk_driver_stop_high_freq(uint8_t dev_id)
-{
-uint8_t i;
-for(i=0;i<NRK_MAX_DRIVER_CNT;i++)
-            if(nrk_drivers[i].dev_id==dev_id)
-            {
-                    nrk_drivers[i].type=0;
-                    if(!nrk_check_high_freq())
-                            TIMSK=BM(OCIE1A);
-                    return 0;
-            }
-            return 1;
-}
-uint8_t nrk_check_high_freq()
-{
 
-        uint8_t i=0;
-        for(i=0;i<_nrk_driver_count;i++)        
-            if(nrk_drivers[i].type > 0)
-                    return 1;
-                    
-      return 0;
-
-}
-uint8_t nrk_high_freq_driver_scheduler()
-{
-        uint8_t i=0;
-
-        for(i=0;i<_nrk_driver_count;i++)        
-        {       
-                if(nrk_drivers[i].type)
-                {
-                if(!(NRKHighFreqDriverCurrSchedule%nrk_drivers[i].type))                                nrk_drivers[i].devicemanager(HIGH_FREQ,0,NULL,0);
-                }
-        }
-        if(NRKHighFreqDriverSchedule==NRKHighFreqDriverCurrSchedule)
-                NRKHighFreqDriverCurrSchedule=1;
-        else
-                NRKHighFreqDriverCurrSchedule++;
-        return 0;
-}
 #endif

nano-RK/src/kernel/source/nrk_scheduler.c

@@ -47 +47 @@
 // 800 * .125 = 100us
 #define CONTEXT_SWAP_TIME_BOUND    750
-
+#define MAX_WAKEUP_TIME         254
 
 void inline _nrk_scheduler()
@@ -65 +65 @@
         // Lets handle the timing stuff here.  Make sure your clock is good to go...
         //TIMSK = BM (OCIE1A) | BM(OCIE0); 
-        next_wake=254;
+        next_wake=MAX_WAKEUP_TIME;
         _nrk_set_next_wakeup(next_wake);
         start_time_stamp=_nrk_get_high_speed_timer();
@@ -191 +191 @@
         {
                 // You are a non-Idle Task
-                if(nrk_task_TCB[task_ID].cpu_reserve!=0 && nrk_task_TCB[task_ID].cpu_remaining<254)
+                if(nrk_task_TCB[task_ID].cpu_reserve!=0 && nrk_task_TCB[task_ID].cpu_remaining<MAX_WAKEUP_TIME)
                 {
                         if(next_wake>nrk_task_TCB[task_ID].cpu_remaining)
@@ -198 +198 @@
                 else 
                 { 
-                        if(next_wake>254) next_wake=254; 
+                        if(next_wake>MAX_WAKEUP_TIME) next_wake=MAX_WAKEUP_TIME; 
                 }
         } 

nano-RK/src/platform/firefly2_2/include/hal.h

@@ -402 +402 @@
 
 
-
-
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************                         ADC                       **************************
- *******************************************************************************************************
- *******************************************************************************************************/
-
-
-//-------------------------------------------------------------------------------------------------------
-// ADC initialization
-#define ADC_INIT() \
-    do { \
-        ADCSRA = BM(ADPS0) | BM(ADPS1) | BM(ADFR); \
-        ADMUX = BM(REFS0); \
-    } while (0)
-
-/*
-#define ADC_INIT() \
-    do { \
-        ADCSRA = BM(ADPS0) | BM(ADPS1) | BM(ADIF); \
-        ADMUX = BM(REFS0); \
-    } while (0)
-*/
-
-// Selects which ADC channel to use. The channels (0-3) are defined in the development board definition
-// files, e.g. hal_cc2420db.h, as ADC_INPUT_...
-#define ADC_SET_CHANNEL(channel) do { ADMUX = (ADMUX & ~0x1F) | (channel); } while (0)
-
-// Enables/disables the ADC
-#define ADC_ENABLE() do { ADCSRA |= BM(ADEN); } while (0)
-#define ADC_DISABLE() do { ADCSRA &= ~BM(ADEN); } while (0)
-//-------------------------------------------------------------------------------------------------------
-
-
-//-------------------------------------------------------------------------------------------------------
-// ADC sampling
-
-// Macro for taking a single sample in single-conversion mode (not required in continuous mode)
-#define ADC_SAMPLE_SINGLE() \
-    do { \
-        ADCSRA |= BM(ADSC); \
-        while (!(ADCSRA & 0x10)); \
-    } while(0)
-
-// Macros for obtaining the latest sample value
-#define ADC_GET_SAMPLE_10(x) \
-    do { \
-        x =  ADCL; \
-        x |= ADCH << 8; \
-    } while (0)
-
-#define ADC_GET_SAMPLE_8(x) \
-    do { \
-        x = ((uint8_t) ADCL) >> 2; \
-        x |= ((int8_t) ADCH) << 6; \
-    } while (0)
-//-------------------------------------------------------------------------------------------------------
 
 

nano-RK/src/platform/firefly2_2/include/hal_firefly2_2.h

@@ -52 +52 @@
 #define FIREFLY2_2_PLATFORM 
 
+#define NRK_DEFAULT_UART 1
+
 #define RED_LED         3
 #define GREEN_LED       2
 #define BLUE_LED        1
 #define ORANGE_LED      0
-
-
-#define NRK_DEFAULT_UART 1
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************                   AVR I/O PORTS                   **************************
- *******************************************************************************************************
- *******************************************************************************************************/
-
-//---------------------------------------------------------------------------------------------
-// Port A
-#define VREG_EN         5  // PA.5 - Output: VREG_EN to CC2420
-#define RESET_N         6  // PA.6 - Output: RESET_N to CC2420
-#define DEBUG_0         3
-#define DEBUG_1         4
-
-//---------------------------------------------------------------------------------------------
-// Port B
-#define SPI_SS          0  // PB.0 - Output: SPI Slave Select
-#define SCK             1  // PB.1 - Output: SPI Serial Clock (SCLK)
-#define MOSI            2  // PB.2 - Output: SPI Master out - slave in (MOSI)
-#define MISO            3  // PB.3 - Input:  SPI Master in - slave out (MISO)
-//---------------------------------------------------------------------------------------------
-//PORT C
-#define CSN             0  // PB.0 - Output: SPI Chip Select (CS_N)
-#define FIFO            1  // PB.7 - Input:  FIFO from CC2420
-
-
-//---------------------------------------------------------------------------------------------
-// Clears LED
-#define CLR_LED_0()                  (PORTE |= BM(YLED))
-#define CLR_LED_1()                  (PORTE |= BM(GLED))
-#define CLR_LED_2()                  (PORTE |= BM(RLED))
-#define CLR_LED_3()                  (PORTE |= BM(BLED))
-
-// Set LED
-#define SET_LED_0()                  (PORTE &= ~BM(YLED))
-#define SET_LED_1()                  (PORTE &= ~BM(GLED))
-#define SET_LED_2()                  (PORTE &= ~BM(RLED))
-#define SET_LED_3()                  (PORTE &= ~BM(BLED))
-//---------------------------------------------------------------------------------------------
-// Port D
-#define UART1_RXD       2 // PD.2 - Input:  UART1 RXD
-#define UART1_TXD       3 // PD.3 - Output: UART1 TXD
-#define SFD             6 // PD.4 - Input:  SFD from CC2420
-#define UART1_RTS       5 // PD.5 - Output: UART HW handshaking: RTS
-#define CCA             4 // PD.6 - Input:  CCA from CC2420
-#define UART1_CTS       7 // PD.7 - Input:  UART HW handshaking: CTS
-
-//----------------------------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------------------------
-// Port E
-#define UART0_RXD       0 // PE.0 - Input:  UART0 RXD
-#define UART0_TXD       1 // PE.1 - Output: UART0 TXD
-#define BUTTON          5 // PE.5 - Input : Push button S2
-#define FIFOP           7 // PE.7 - Input:  FIFOP from CC2420
-#define YLED            2  // PA.0 - Output: Yellow LED
-#define GLED            3  // PA.1 - Output: Green LED
-#define RLED            4  // PA.2 - Output: Red LED
-#define BLED            5  // PA.2 - Output: Red LED
-//-------------------------------------------------------------------------------------------------------
-
-
-//-------------------------------------------------------------------------------------------------------
-// Port F
-#define JOYSTICK_LEFT   1 // PF.1 - Input: Joystick left
-#define JOYSTICK_DOWN   2 // PF.2 - Input: Joystick down
-
-// ADC inputs
-#define ADC_INPUT_0_POT_METER       0 // PF.0 - ADC0 with potentiometer
-#define ADC_INPUT_1                 1 // PF.1 - ADC1
-#define ADC_INPUT_2                 2 // PF.2 - ADC2
-#define ADC_INPUT_3_TEMP_SENSOR     3 // PF.3 - ADC3 with temp sensor
-
-// JTAG interface:
-//     PF.4 - Input : JTAG TCK serial clock
-//     PF.5 - Input : JTAG TMS strobe enable
-//     PF.6 - Output: JTAG TDO serial data output
-//     PF.7 - Input : JTAG TDI serial data input
-//-------------------------------------------------------------------------------------------------------
-
-
-//-------------------------------------------------------------------------------------------------------
-// Port G
-//-------------------------------------------------------------------------------------------------------
-
-
-//-------------------------------------------------------------------------------------------------------
-// External RAM interface:
-//     PA and PC - Multiplexed address/data
-//     PG.0 - Output: Write enable: WR_N
-//     PG.1 - Output: Read enable: RD_N
-//     PG.2 - Output: Address Latch Enable: ALE
-//-------------------------------------------------------------------------------------------------------
-
-
-//----------------------------------------------------------------------------------------------
-// Port setup macros
 
 // Port initialization
@@ -166 +68 @@
         DDRC  = BM(CSN); \
         PORTC = BM(CSN); \
-        DDRE  = BM(RLED) | BM(YLED) | BM(GLED) | BM(BLED) | BM(UART0_TXD); \
+        DDRE  = BM(RED_LED) | BM(ORANGE_LED) | BM(GREEN_LED) | BM(BLUE_LED) | BM(UART0_TXD); \
+        DDRD  = BM(UART1_TXD); \
         PORTE  = BM(UART0_TXD); \
         DDRA  = BM(VREG_EN) | BM(RESET_N) | BM(DEBUG_0) | BM(DEBUG_1); \
         PORTA = BM(RESET_N); \
     } while (0)
-/*
-#define PORT_INIT() \
-    do { \
-        SFIOR |= BM(PUD); \
-        DDRB  = BM(RESET_N) | BM(VREG_EN) |  BM(SCK) | BM(CSN) | BM(OLED) | BM(GLED); \
-        PORTB = BM(RESET_N) |  BM(SCK) | BM(CSN); \
-        DDRD  = BM(UART1_TXD) | BM(UART1_RTS); \
-        PORTD = BM(UART1_RTS) | BM(UART1_CTS);\
-        DDRE  = BM(UART0_TXD) | BM(RLED) | BM(YLED); \
-        PORTE = 0x00; \
-    } while (0)
-*/
 
 // Enables the external SRAM
@@ -195 +86 @@
 
 
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************                 CC2420 PIN ACCESS                 **************************
- *******************************************************************************************************
- *******************************************************************************************************/
-
-
-//-------------------------------------------------------------------------------------------------------
+/******************************************************************************
+ ******************************************************************************
+ **************************                 CC2420 PIN ACCESS                 
+ ******************************************************************************
+ ******************************************************************************/
 // CC2420 pin access
 
@@ -220 +108 @@
 #define SET_VREG_ACTIVE()     PORTA |= BM(VREG_EN)
 #define SET_VREG_INACTIVE()   PORTA &= ~BM(VREG_EN)
-//-------------------------------------------------------------------------------------------------------
+//---------------------------------------------------------------------------
 
 
 
 
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************                   SERIAL PORTS                    **************************
- *******************************************************************************************************
- *******************************************************************************************************/
 
-
-//-------------------------------------------------------------------------------------------------------
-// UART hardware flow control
-#define CLR_RTS()                  (PORTD &= ~BM(UART1_RTS))
-#define SET_RTS()                  (PORTD |= BM(UART1_RTS))
-
-#define SET_CTS()                  (PORTD |= BM(UART1_CTS))
-#define CLR_CTS()                  (PORTD &= ~BM(UART1_CTS))
-//-------------------------------------------------------------------------------------------------------
-
-
-
-
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************               EXTERNAL INTERRUPTS                 **************************
- *******************************************************************************************************
- *******************************************************************************************************/
-
-
-//-------------------------------------------------------------------------------------------------------
+/*****************************************************************************
+ *****************************************************************************
+ **************************               EXTERNAL INTERRUPTS                 
+ ******************************************************************************
+ ******************************************************************************/
 // Rising edge trigger for external interrupt 0 (FIFOP)
 #define FIFOP_INT_INIT()            do { EICRA |= 0x03; CLEAR_FIFOP_INT(); } while (0)
@@ -270 +137 @@
 
 
-//-------------------------------------------------------------------------------------------------------
-// Falling edge trigger for external interrupt 6 (joystick)
-#define JOYSTICK_INT_INIT()         do { EICRB |= 0x20; } while (0)
-
-// Joystick on external interrupt 6
-#define ENABLE_JOYSTICK_INT()       do { EIMSK |= 0x40; } while (0)
-#define DISABLE_JOYSTICK_INT()      do { EIMSK &= ~0x40; } while (0)
-#define CLEAR_JOYSTICK_INT()        do { EIFR = 0x40; } while (0)
-//-------------------------------------------------------------------------------------------------------
-
-
-
-
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************                      BUTTONS                      **************************
- *******************************************************************************************************
- *******************************************************************************************************/
-
-//-------------------------------------------------------------------------------------------------------
-// S2 button
-#define BUTTON_PRESSED()           !(PINE & BM(BUTTON))
-
-// Joystick
-#define JOYSTICK_UP_PRESSED()       (PINE & BM(JOYSTICK_UP))
-#define JOYSTICK_DOWN_PRESSED()     (PINF & BM(JOYSTICK_DOWN))
-#define JOYSTICK_LEFT_PRESSED()     (PINF & BM(JOYSTICK_LEFT))
-#define JOYSTICK_RIGHT_PRESSED()    (PINE & BM(JOYSTICK_RIGHT))
-#define JOYSTICK_CENTER_PRESSED()   (PINE & BM(JOYSTICK_CENTER))
-//-------------------------------------------------------------------------------------------------------
-
-
-
-
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************                        LEDS                       **************************
- *******************************************************************************************************
- *******************************************************************************************************/
-
-
-//-------------------------------------------------------------------------------------------------------
-// Clears LED
-#define CLR_GLED()                  (PORTB &= ~BM(GLED))
-#define CLR_OLED()                  (PORTB &= ~BM(OLED))
-#define CLR_YLED()                  (PORTE &= ~BM(YLED))
-#define CLR_RLED()                  (PORTE &= ~BM(RLED))
-
-// Set LED
-#define SET_GLED()                  (PORTB |= BM(GLED))
-#define SET_OLED()                  (PORTB |= BM(OLED))
-#define SET_YLED()                  (PORTE |= BM(YLED))
-#define SET_RLED()                  (PORTE |= BM(RLED))
-
-// Sets all leds simultaneously to display a 4-bit binary code
-#define SET_LED_MASK(n) \
-    do { \
-        if (n & 0x01) SET_GLED(); else CLR_GLED(); \
-        if (n & 0x02) SET_OLED(); else CLR_OLED(); \
-        if (n & 0x04) SET_RLED(); else CLR_RLED(); \
-        if (n & 0x08) SET_YLED(); else CLR_YLED(); \
-    } while (0)
-//-------------------------------------------------------------------------------------------------------
-
-
-
-
-/*******************************************************************************************************
- *******************************************************************************************************
- **************************               APPLICATION DEBUGGING               **************************
- *******************************************************************************************************
- *******************************************************************************************************/
-
-
-//-------------------------------------------------------------------------------------------------------
-// Controlled application crash (flashes the LEDs forever to indicate an error code)
-#define EXCEPTION(n) \
-    do { \
-        DISABLE_GLOBAL_INT(); \
-        SET_LED_MASK(n); \
-        halWait(50000); \
-        SET_LED_MASK(0); \
-        halWait(50000); \
-    } while (TRUE)
-//-------------------------------------------------------------------------------------------------------
-
 
 #endif