Changeset 519

Show
Ignore:
Timestamp:
04/16/08 21:59:41 (4 months ago)
Author:
mthamilt
Message:

IMEC update

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • nano-RK/projects/ecg_project/main.c

    r449 r519  
    2222*******************************************************************************/ 
    2323 
     24 
    2425#include <nrk.h> 
    2526#include <include.h> 
    …… 
    3031#include <nrk_timer.h> 
    3132#include <nrk_stack_check.h> 
     33#include <nrk_driver_list.h> 
     34#include <nrk_driver.h> 
     35#include <adc_driver.h> 
     36#include <eeg_driver.h> 
    3237 
    33 NRK_STK ECGBufferTaskStack[NRK_APP_STACKSIZE]; 
    34 nrk_task_type ECGBufferTask; 
     38NRK_STK ECGReaderTaskStack[NRK_APP_STACKSIZE]; 
     39nrk_task_type ECGReaderTask; 
    3540void ECGBuffer(void); 
    3641 
    …… 
    4449 
    4550void nrk_create_taskset(); 
     51void nrk_register_drivers(); 
    4652 
    4753int main () 
    …… 
    5460 
    5561        nrk_time_set(0,0); 
     62  nrk_register_drivers(); 
    5663        nrk_create_taskset (); 
    5764        nrk_start(); 
    …… 
    6067} 
    6168 
    62 void ECGBuffer() { 
     69void ECGReader() { 
     70        uint16_t cnt; 
     71        int8_t fd,val,chan; 
     72        uint16_t buf[8]; 
     73 
     74        fd=nrk_open(IMEC_EEG_MANAGER,READ); 
     75  if(fd==NRK_ERROR) nrk_kprintf( "Failed to open EEG driver\r\n"); 
     76   
     77  cnt=0; 
     78  chan=0; 
     79  val=nrk_set_status(fd,EEG_CHAN,1); 
     80  if(val==NRK_ERROR) nrk_kprintf( "Failed to set EEG status\r\n"); 
     81  val=nrk_set_status(fd,ECG_GAIN,5); 
     82  if(val==NRK_ERROR) nrk_kprintf( "Failed to set EEG gain\r\n"); 
     83 
     84        while(1) { 
     85                nrk_gpio_toggle(NRK_MISC1); 
     86                //printf("Task 1\r\n"); 
     87          val=nrk_read(fd,&buf[chan],2); 
     88          if(val==NRK_ERROR) nrk_kprintf("Failed to read EEG\r\n"); 
     89                printf( "EEG: %d\r\n",buf[chan]); 
     90 
     91                nrk_wait_until_next_period(); 
     92                cnt++; 
     93        } 
     94 
    6395} 
    6496 
    …… 
    70102 
    71103void nrk_create_taskset() { 
    72         nrk_task_set_entry_function(&ECGBufferTask, ECGBuffer); 
    73         ECGBufferTask.Ptos = (void *) &ECGBufferTaskStack[NRK_APP_STACKSIZE]; 
    74         ECGBufferTask.Pbos = (void *) &ECGBufferTaskStack[0]; 
    75         ECGBufferTask.prio = 1; 
    76         ECGBufferTask.FirstActivation = TRUE; 
    77         ECGBufferTask.Type = BASIC_TASK; 
    78         ECGBufferTask.SchType = PREEMPTIVE; 
    79         ECGBufferTask.period.secs = 0; 
    80         ECGBufferTask.period.nano_secs = 600*NANOS_PER_MS; 
    81         ECGBufferTask.cpu_reserve.secs = 0; 
    82         ECGBufferTask.cpu_reserve.nano_secs =  50*NANOS_PER_MS; 
    83         ECGBufferTask.offset.secs = 0; 
    84         ECGBufferTask.offset.nano_secs= 0; 
    85         nrk_activate_task (&ECGBufferTask); 
     104        nrk_task_set_entry_function(&ECGReaderTask, ECGReader); 
     105        ECGReaderTask.Ptos = (void *) &ECGReaderTaskStack[NRK_APP_STACKSIZE]; 
     106        ECGReaderTask.Pbos = (void *) &ECGReaderTaskStack[0]; 
     107        ECGReaderTask.prio = 1; 
     108        ECGReaderTask.FirstActivation = TRUE; 
     109        ECGReaderTask.Type = BASIC_TASK; 
     110        ECGReaderTask.SchType = PREEMPTIVE; 
     111        ECGReaderTask.period.secs = 0; 
     112        ECGReaderTask.period.nano_secs = 600*NANOS_PER_MS; 
     113        ECGReaderTask.cpu_reserve.secs = 0; 
     114        ECGReaderTask.cpu_reserve.nano_secs =  50*NANOS_PER_MS; 
     115        ECGReaderTask.offset.secs = 0; 
     116        ECGReaderTask.offset.nano_secs= 0; 
     117        nrk_activate_task (&ECGReaderTask); 
    86118 
     119/* 
    87120        nrk_task_set_entry_function(&ECGProcessorTask, ECGProcessor); 
    88121        ECGProcessorTask.Ptos = (void *) &ECGProcessorTaskStack[NRK_APP_STACKSIZE]; 
    …… 
    114147        RadioTask.offset.nano_secs= 0; 
    115148        nrk_activate_task (&RadioTask); 
     149*/ 
    116150} 
    117151 
     152void nrk_register_drivers() 
     153{ 
     154int8_t val; 
     155// Register the ADC device driver 
     156// Make sure to add:  
     157//     #define NRK_MAX_DRIVER_CNT   
     158//     in nrk_cfg.h 
     159// Make sure to add:  
     160//     SRC += $(ROOT_DIR)/src/drivers/platform/$(PLATFORM_TYPE)/source/adc_driver.c 
     161//     in makefile 
     162val=nrk_register_driver( &dev_manager_adc,ADC_DEV_MANAGER); 
     163if(val==NRK_ERROR) nrk_kprintf( "Failed to load my ADC driver\r\n"); 
     164 
     165val=nrk_register_driver( &dev_manager_eeg,IMEC_EEG_MANAGER); 
     166if(val==NRK_ERROR) nrk_kprintf( "Failed to load EEG driver\r\n"); 
     167} 

  • nano-RK/projects/ecg_project/makefile

    r445 r519  
    2626# SRC += $(ROOT_DIR)/src/platform/$(PLATFORM_TYPE)/source/my_src1.c  
    2727# SRC += $(ROOT_DIR)/src/platform/$(PLATFORM_TYPE)/source/my_src2.c  
     28SRC += $(ROOT_DIR)/src/drivers/platform/$(PLATFORM_TYPE)/source/adc_driver.c 
     29SRC += $(ROOT_DIR)/src/drivers/platform/$(PLATFORM_TYPE)/source/eeg_driver.c 
    2830 
    2931# Add extra includes files.  

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

    r445 r519  
    4040#define NRK_APP_STACKSIZE 128  
    4141#define NRK_KERNEL_STACKSIZE 128  
    42 #define NRK_MAX_RESOURCE_CNT 1 
     42#define NRK_MAX_RESOURCE_CNT 3 
     43#define NRK_MAX_DRIVER_CNT 3 
    4344 
    4445 

  • nano-RK/projects/msp_basic_adc/main.c

    r457 r519  
    6464 
    6565        printf("Starting up...\r\n"); 
     66  P1DIR = 0xff; 
     67  P2DIR = 0x7e; 
    6668 
    6769        nrk_start(); 
    …… 
    7678        uint16_t buf[8]; 
    7779 
     80  //EEG init 
     81  /* 
     82  nrk_gpio_clr(UP_RESET); 
     83  nrk_gpio_set(UP_RESET); 
     84  nrk_gpio_clr(UP_RESET); 
     85  nrk_gpio_clr(UP_A0_ECG); 
     86  nrk_gpio_clr(UP_A1_ECG); 
     87  nrk_gpio_clr(UP_A2_ECG); 
     88  nrk_gpio_set(ENABLE1); 
     89  */ 
     90  P1DIR = 0xff; 
     91  P2DIR = 0x7e; 
     92 
    7893        fd=nrk_open(ADC_DEV_MANAGER,READ); 
    7994  if(fd==NRK_ERROR) nrk_kprintf( "Failed to open ADC driver\r\n"); 
    …… 
    87102                nrk_gpio_toggle(NRK_MISC1); 
    88103                //printf("Task 1\r\n"); 
     104 
     105    P1OUT = 0xff; 
    89106          val=nrk_read(fd,&buf[chan],2); 
    90107          if(val==NRK_ERROR) nrk_kprintf( PSTR("Failed to read ADC\r\n" )); 
    91108                printf( "ADC: %d\r\n",buf[chan]); 
     109    P1OUT = 0x00; 
    92110 
    93111                nrk_wait_until_next_period(); 
    …… 
    116134        TaskOne.SchType = PREEMPTIVE; 
    117135        TaskOne.period.secs = 0; 
    118         TaskOne.period.nano_secs = 600*NANOS_PER_MS; 
     136        TaskOne.period.nano_secs = 10*NANOS_PER_MS; 
    119137        TaskOne.cpu_reserve.secs = 0; 
    120         TaskOne.cpu_reserve.nano_secs =  50*NANOS_PER_MS; 
     138        TaskOne.cpu_reserve.nano_secs =  1*NANOS_PER_MS; 
    121139        TaskOne.offset.secs = 0; 
    122140        TaskOne.offset.nano_secs = 0; 

  • nano-RK/projects/msp_basic_adc/makefile

    r457 r519  
    2727# SRC += $(ROOT_DIR)/src/platform/$(PLATFORM_TYPE)/source/my_src2.c  
    2828SRC += $(ROOT_DIR)/src/drivers/platform/$(PLATFORM_TYPE)/source/adc_driver.c 
     29SRC += $(ROOT_DIR)/src/drivers/platform/$(PLATFORM_TYPE)/source/eeg_driver.c 
    2930 
    3031# Add extra includes files.  

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

    r239 r519  
    2929#define ADC_DEV_MANAGER         0 
    3030#define FIREFLY_SENSOR_BASIC    1 
     31#define IMEC_EEG_MANAGER 2 
    3132 
    3233 

  • nano-RK/src/drivers/platform/imec/include/eeg_driver.h

    r486 r519  
    2323*  Mark Hamilton 
    2424*******************************************************************************/ 
    25  
    26 #endif 
    2725 
    2826#include<stdio.h> 

  • nano-RK/src/drivers/platform/imec/source/adc_driver.c

    r486 r519  
    9090    case INIT:  
    9191      init_adc();   
    92       return 1; 
     92      return NRK_OK; 
    9393 
    9494    case OPEN:    

  • nano-RK/src/drivers/platform/imec/source/eeg_driver.c

    r486 r519  
    4343#define EEG_INIT()\ 
    4444  do {\ 
    45     nrk_gpio_set(UP_RESET); 
    46     nrk_gpio_clr(UP_RESET); 
     45    nrk_gpio_clr(UP_RESET);\ 
     46    nrk_gpio_set(UP_RESET);\ 
     47    nrk_gpio_clr(UP_RESET);\ 
    4748  } while(0); 
    4849 
    4950#define EEG_SET_CHANNEL(channel)\ 
    50   do { 
     51  do {\ 
    5152  } while(0); 
    5253 
    …… 
    103104          return NRK_ERROR; 
    104105        } 
     106        val=nrk_set_status(eeg_adc_fd,ADC_CHAN,0); 
     107        if(val==NRK_ERROR) nrk_kprintf( "Failed to set ADC status\r\n"); 
    105108        return NRK_OK;  
    106109      } 
    …… 
    113116        return NRK_ERROR;  
    114117      } 
    115       if(opt&(READ_FLAG|WRITE_FLAG|APPEND_FLAG)==0) 
     118      if((opt&(READ_FLAG|WRITE_FLAG|APPEND_FLAG))==0) 
    116119        return NRK_ERROR; 
    117120      else return NRK_OK; 
    …… 
    142145        case EEG_CHAN: 
    143146        eeg_channel = value; 
    144         ADC_SET_CHANNEL(eeg_channel); 
     147        EEG_SET_CHANNEL(eeg_channel); 
    145148        return NRK_OK; 
    146149 
    …… 
    175178uint16_t get_eeg_val() 
    176179{                          
    177         uint16_t eeg_val; 
    178         val=nrk_read(fd,&eeg_val,2); //TODO: ensure correct byte ordering 
    179         if(val==NRK_ERROR) nrk_kprintf("Failed to read ADC for EEG\r\n"); 
     180        uint8_t eeg_val[2]; 
     181  uint8_t retval; 
     182        retval=nrk_read(eeg_adc_fd,&eeg_val,2); //TODO: ensure correct byte ordering 
     183        if(retval==NRK_ERROR) nrk_kprintf("Failed to read ADC for EEG\r\n"); 
     184  printf("get_eeg_val: %d\r\n", eeg_val); 
    180185        return eeg_val; 
    181186} 

  • nano-RK/src/platform/imec/source/ulib.c

    r457 r519  
    7676if(uart_num==1) 
    7777        { 
     78        //TODO: fix 
    7879        if( IFG2 & BM(URXIFG1) ) return 1; 
    7980        } 
    …… 
    101102{ 
    102103        //TODO: set unused pins as output to minimize current consumption 
     104  //Misc pins 
    103105        nrk_gpio_raw_direction(P6DIR,MISC1,NRK_PIN_OUTPUT); 
    104106        nrk_gpio_raw_direction(P6DIR,MISC2,NRK_PIN_OUTPUT); 
    105107        nrk_gpio_raw_direction(P6DIR,MISC3,NRK_PIN_OUTPUT); 
    106108        nrk_gpio_raw_direction(P6DIR,MISC4,NRK_PIN_OUTPUT); 
     109 
     110  //ASIC pins 
     111        nrk_gpio_raw_direction(P1DIR,ASIC_CLK,NRK_PIN_OUTPUT); 
     112        nrk_gpio_raw_direction(P2DIR,UP_RESET,NRK_PIN_OUTPUT); 
     113        nrk_gpio_raw_direction(P2DIR,ENABLE1,NRK_PIN_INPUT); 
     114 
     115        nrk_gpio_raw_direction(P1DIR,UP_A0_ECG,NRK_PIN_OUTPUT); 
     116        nrk_gpio_raw_direction(P1DIR,UP_A1_ECG,NRK_PIN_OUTPUT); 
     117        nrk_gpio_raw_direction(P1DIR,UP_A2_ECG,NRK_PIN_OUTPUT); 
     118 
     119        nrk_gpio_raw_direction(P2DIR,UP_A0_EEG,NRK_PIN_OUTPUT); 
     120        nrk_gpio_raw_direction(P2DIR,UP_A1_EEG,NRK_PIN_OUTPUT); 
     121        nrk_gpio_raw_direction(P2DIR,UP_A2_EEG,NRK_PIN_OUTPUT); 
    107122} 
    108123