/unittests/periphery-lld/src/ut_alld_DW1000_v1.c - Annotate - AMiRo-OS - Research for Cognitive Interaction

amiro-os / unittests / periphery-lld / src / ut_alld_DW1000_v1.c @ 88449987

History | View | Annotate | Download (14.645 KB)

-            e05848a6
+/*
 AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.
-f0ce9e
+Copyright (C) 2016..2019  Thomas Schöpping et al.
-            e05848a6
+            Robin Ewers
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
-            ddf34c3d
+#include <amiroos.h>
-cb40108
+#if ((AMIROOS_CFG_TESTS_ENABLE == true) && defined(AMIROLLD_CFG_DW1000) && (AMIROLLD_CFG_DW1000 == 1)) || defined(__DOXYGEN__)
 #include <aos_debug.h>
 #include <chprintf.h>
 #include <aos_thread.h>
 #include <math.h>
 #include <module.h>
 #include <alld_DW1000.h>
 #include <v1/deca_instance_v1.h>
-            88449987
+#include <v1/alld_dw1000_regs_v1.h>
 #include <string.h>
-cb40108
+            Thomas Schöpping
-            e05848a6
+            Robin Ewers
-            f3ac1c96
+/******************************************************************************/
 /* LOCAL DEFINITIONS                                                          */
 /******************************************************************************/
-            e05848a6
+            Robin Ewers
-cb40108
+//#define UNIT_TEST_SNIPPETS_DW1000   // switch between unit test and demo apps
 #define SWS1_SHF_MODE 0x02  //short frame mode (6.81M)
 #define SWS1_CH5_MODE 0x04  //channel 5 mode
 #define SWS1_ANC_MODE 0x08  //anchor mode
 #define SWS1_A1A_MODE 0x10  //anchor/tag address A1
 #define SWS1_A2A_MODE 0x20  //anchor/tag address A2
 #define SWS1_A3A_MODE 0x40  //anchor/tag address A3
 #define S1_SWITCH_ON  (1)
 #define S1_SWITCH_OFF (0)
-            f3ac1c96
+/******************************************************************************/
 /* EXPORTED VARIABLES                                                         */
 /******************************************************************************/
 /******************************************************************************/
 /* LOCAL TYPES                                                                */
 /******************************************************************************/
 /******************************************************************************/
 /* LOCAL VARIABLES                                                            */
 /******************************************************************************/
-cb40108
+uint8_t s1switch = 0;
 int instance_anchaddr = 0;
 int dr_mode = 0;
 int chan, tagaddr, ancaddr;
 int instance_mode = ANCHOR;
-            f3ac1c96
+            Thomas Schöpping
 /******************************************************************************/
 /* LOCAL FUNCTIONS                                                            */
 /******************************************************************************/
-cb40108
+/*! @brief Change the SPI speed configuration on the fly */
 void setHighSpeed_SPI(bool speedValue, DW1000Driver* drv){
   spiStop(drv->spid);
   if (speedValue == FALSE){
     spiStart(drv->spid, &moduleHalSpiUwbLsConfig);  // low speed spi configuration
+  }
   else{
     spiStart(drv->spid, &moduleHalSpiUwbHsConfig); // high speed spi configuration
+  }
+}
-            88449987
+/*! @brief entry point to the IRQn event in DW1000 module */
-cb40108
+void process_deca_irq(void){
   do{
     dwt_isr();
     //while IRS line active (ARM can only do edge sensitive interrupts)
   }while(port_CheckEXT_IRQ() == 1);
+}
 /*! @brief Manually set the chip select pin of the SPI */
 void set_SPI_chip_select(void){
   apalGpioWrite(moduleGpioSpiChipSelect.gpio, APAL_GPIO_HIGH);
+}
 /*! @brief Manually reset the chip select pin of the SPI */
 void clear_SPI_chip_select(void){
   apalGpioWrite(moduleGpioSpiChipSelect.gpio, APAL_GPIO_LOW);
+}
 /*! @brief Manually reset the DW1000 module  */
 void reset_DW1000(void){
   // Set the pin as output
-e8cc
+  palSetLineMode(moduleGpioDw1000Reset.gpio->line, APAL_GPIO_DIRECTION_OUTPUT);
-cb40108
+  //drive the RSTn pin low
   apalGpioWrite(moduleGpioDw1000Reset.gpio, APAL_GPIO_LOW);
   //put the pin back to tri-state ... as input
-e8cc
+//  palSetLineMode(moduleGpioDw1000Reset.gpio->line, APAL_GPIO_DIRECTION_INPUT); // TODO:
-            88449987
+  aosThdMSleep(7);
+}
-cb40108
+            Thomas Schöpping
-            88449987
+/*! @brief waking up the DW1000 module using Chip Select pin */
 void wakeup_DW1000(void){
   clear_SPI_chip_select();
   aosThdMSleep(1);
   set_SPI_chip_select();
   aosThdMSleep(7);  // wait for XTAL to stabilize
   // set wakeup pin directly high
 //   apalGpioWrite(moduleGpioDw1000WakeUp.gpio, APAL_GPIO_HIGH);
    aosThdMSleep(10);
-cb40108
+            Thomas Schöpping
 /*! @brief Configure instance tag/anchor/etc... addresses */
 void addressconfigure(uint8_t s1switch, uint8_t mode){
   uint16_t instAddress ;
   instance_anchaddr = (((s1switch & SWS1_A1A_MODE) << 2) + (s1switch & SWS1_A2A_MODE) + ((s1switch & SWS1_A3A_MODE) >> 2)) >> 4;
   if(mode == ANCHOR) {
     if(instance_anchaddr > 3) {
       instAddress = GATEWAY_ANCHOR_ADDR | 0x4 ; //listener
+    }
     else {
       instAddress = GATEWAY_ANCHOR_ADDR | (uint16_t)instance_anchaddr;
+    }
+  }
   else{
     instAddress = (uint16_t)instance_anchaddr;
+  }
   instancesetaddresses(instAddress);
+}
 /*! @brief returns the use case / operational mode */
 int decarangingmode(uint8_t s1switch){
   int mode = 0;
   if(s1switch & SWS1_SHF_MODE)  {
     mode = 1;
+  }
   if(s1switch & SWS1_CH5_MODE) {
     mode = mode + 2;
+  }
   return mode;
+}
 /*! @brief Check connection setting and initialize DW1000 module */
 int32_t inittestapplication(uint8_t s1switch, DW1000Driver* drv){
   uint32_t devID ;
   int result;
   setHighSpeed_SPI(FALSE, drv);          //low speed spi max. ~4M
   devID = instancereaddeviceid() ;
   if(DWT_DEVICE_ID != devID) {
     clear_SPI_chip_select();
     Sleep(1);
     set_SPI_chip_select();
     Sleep(7);
     devID = instancereaddeviceid() ;
     if(DWT_DEVICE_ID != devID){
       return(-1) ;
+    }
     dwt_softreset();
+  }
     reset_DW1000();  //reset the DW1000 by driving the RSTn line low
   if((s1switch & SWS1_ANC_MODE) == 0){
     instance_mode = TAG;
+  }
   else{
     instance_mode = ANCHOR;
+  }
-            88449987
+  result = instance_init(drv);
-cb40108
+  if (0 > result){
     return(-1) ;
+  }
   setHighSpeed_SPI(TRUE, drv);       // high speed spi max. ~ 20M
   devID = instancereaddeviceid() ;
   if (DWT_DEVICE_ID != devID){
     return(-1) ;
+  }
   addressconfigure(s1switch, (uint8_t)instance_mode) ;
   if((instance_mode == ANCHOR) && (instance_anchaddr > 0x3)){
     instance_mode = LISTENER;
+  }
   instancesetrole(instance_mode) ;       // Set this instance role
   dr_mode = decarangingmode(s1switch);
   chan = chConfig[dr_mode].channelNumber ;
   instance_config(&chConfig[dr_mode], &sfConfig[dr_mode], drv) ;
   return (int32_t)devID;
+}
 /*! @brief Main Entry point to Initialization of UWB DW1000 configuration  */
 #pragma GCC optimize ("O3")
 int UWB_Init(DW1000Driver* drv){
   /*! Software defined Configurartion for TAG, ANC, and other settings as needed */
   s1switch = S1_SWITCH_OFF << 1  // (on = 6.8 Mbps, off = 110 kbps)
            | S1_SWITCH_OFF << 2  // (on = CH5, off = CH2)
            | S1_SWITCH_OFF << 3  // (on = Anchor, off = TAG)
            | S1_SWITCH_OFF << 4  // (configure Tag or anchor ID no.)
            | S1_SWITCH_OFF << 5  // (configure Tag or anchor ID no.)
            | S1_SWITCH_OFF << 6  // (configure Tag or anchor ID no.)
            | S1_SWITCH_OFF << 7; // Not use in this demo
   port_DisableEXT_IRQ();           //disable ScenSor IRQ until we configure the device
   if(inittestapplication(s1switch, drv) == -1) {
     return (-1); //error
+  }
   aosThdMSleep(5);
   port_EnableEXT_IRQ();  //enable DW1000 IRQ before starting
   return 0;
+}
-            f3ac1c96
+/******************************************************************************/
 /* EXPORTED FUNCTIONS                                                         */
 /******************************************************************************/
-            e05848a6
+aos_utresult_t utAlldDw1000Func(BaseSequentialStream* stream, aos_unittest_t* ut) {
-cb40108
+  aosDbgCheck(ut->data != NULL);
   aos_utresult_t result = {0, 0};
-            e05848a6
+            Robin Ewers
-            88449987
+#if defined (AMIROLLD_CFG_MIC9404x)
   // Enable 3.3 and 1.8 supply voltages for powering up the DW1000 module in AMiRo Light Ring
   if ((ut->data != NULL) && (((ut_dw1000data_t*)(ut->data))->mic9404xd != NULL)){
     mic9404x_lld_state_t state;
     uint32_t status = APAL_STATUS_OK;
     chprintf(stream, "reading current status of the Power..\n");
     status = mic9404x_lld_get(((ut_dw1000data_t*)(ut->data))->mic9404xd, &state);
     if (status == APAL_STATUS_OK) {
       aosUtPassedMsg(stream, &result, "power %s\n", (state == MIC9404x_LLD_STATE_ON) ? "enabled" : "disabled");
     } else {
       aosUtFailed(stream, &result);
+    }
     if (state == MIC9404x_LLD_STATE_OFF) {
       chprintf(stream, "enabling the power ...\n");
       status = mic9404x_lld_set(((ut_dw1000data_t*)(ut->data))->mic9404xd, MIC9404x_LLD_STATE_ON);
       status |= mic9404x_lld_get(((ut_dw1000data_t*)(ut->data))->mic9404xd, &state);
       if (state == MIC9404x_LLD_STATE_ON) {
         aosThdSSleep(2);
         status |= mic9404x_lld_get(((ut_dw1000data_t*)(ut->data))->mic9404xd, &state);
+      }
       if ((status == APAL_STATUS_OK) && (state == MIC9404x_LLD_STATE_ON)) {
         aosUtPassed(stream, &result);
       } else {
         aosUtFailed(stream, &result);
+      }
+    }
     aosThdSleep(1);
     return result;
+  }
 #endif  /* defined (AMIROLLD_CFG_MIC9404x) */
   // Start the DW1000 module UT after powering up
-cb40108
+  chprintf(stream, "init DW1000...\n");
-            88449987
+  aosThdSleep(1);
   ut_dw1000data_t* h_dw1000data = NULL;
   if((ut->data != NULL) && (((ut_dw1000data_t*)(ut->data))->dw1000d != NULL)){
     h_dw1000data = ut->data;
     chprintf(stream, "assign handle for DW1000Driver struct \n");
+  }
   else {
     chprintf(stream, "unsupported data type \n");
     return result;
+  }
   aosThdSleep(1);
-            e05848a6
+            Robin Ewers
-            88449987
+  reset_DW1000();     // hard reset
 //  wakeup_DW1000();
   aosThdMSleep(5);
   int init = dwt_initialise(DWT_LOADUCODE, h_dw1000data->dw1000d);
   if (init == 0){
     chprintf(stream, "DW1000 is initialized \n");
+  }
   else {
     chprintf(stream, "init error with return value: %d \n", init);
+  }
   aosThdMSleep(5);
-            e05848a6
+            Robin Ewers
-cb40108
+/*! Unit Test snippets for DW1000.
  * @Note: Event IRQ for DW1000 should be tested separately
  */
 #if defined(UNIT_TEST_SNIPPETS_DW1000)
-            88449987
+  uint32_t actual_devID;
-cb40108
+  port_DisableEXT_IRQ();
-            e05848a6
+            Robin Ewers
-            88449987
+  /*! UT1: Low speed SPI result */
   setHighSpeed_SPI(false, h_dw1000data->dw1000d);
   chprintf(stream, "expected ID (LS SPI): 0xDECA0130 \n");
-cb40108
+  aosThdMSleep(5);
-            88449987
+  actual_devID = instancereaddeviceid();
   chprintf(stream, "read ID (LS SPI): 0x%x\n", actual_devID);
-cb40108
+  aosThdMSleep(5);
-            e05848a6
+            Robin Ewers
-cb40108
+  //if the read of device ID fails, the DW1000 could be asleep
-            88449987
+  if(DWT_DEVICE_ID != actual_devID){
-cb40108
+    clear_SPI_chip_select();
     aosThdMSleep(1);
     set_SPI_chip_select();
     aosThdMSleep(7);
-            88449987
+    actual_devID = instancereaddeviceid() ;
     if(DWT_DEVICE_ID != actual_devID){
-cb40108
+      chprintf(stream, "SPI is not working or Unsupported Device ID\n");
-            88449987
+      chprintf(stream, "actual device ID is: 0x%x\n", actual_devID);
-cb40108
+      chprintf(stream, "expected device ID: 0xDECA0130 \n");
       aosThdMSleep(5);
-            88449987
+            Cung Sang
-cb40108
+    dwt_softreset();
+  }
-            88449987
+  if (actual_devID == DWT_DEVICE_ID){
-cb40108
+    aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
-            88449987
+  /*! Blinking TX and RX LED simultenously for 5 times */
   chprintf(stream, "blinking TX and RX LEDs simultenously for 5 times \n");
   for(int i =0; i< 5; i++){
     uint8_t mode = 3;
     uint32_t reg ;
     // Set up for LED output.
     reg = dwt_read32bitoffsetreg(GPIO_CTRL_ID, GPIO_MODE_OFFSET); // Hardcoded = 0xDE001400
     reg &= ~(GPIO_MSGP2_MASK | GPIO_MSGP3_MASK);
     reg |= (GPIO_PIN2_RXLED | GPIO_PIN3_TXLED);
     dwt_write32bitoffsetreg(GPIO_CTRL_ID, GPIO_MODE_OFFSET, reg);
     // Enable LP Oscillator to run from counter and turn on de-bounce clock.
     reg = dwt_read32bitoffsetreg(PMSC_ID, PMSC_CTRL0_OFFSET);      // hard-coded = 0xF0B40200
     reg |= (PMSC_CTRL0_GPDCE | PMSC_CTRL0_KHZCLEN);
     dwt_write32bitoffsetreg(PMSC_ID, PMSC_CTRL0_OFFSET, reg);
     // Enable LEDs to blink and set default blink time.
     reg = PMSC_LEDC_BLNKEN | PMSC_LEDC_BLINK_TIME_DEF;
     // Make LEDs blink once if requested.
     if (mode & DWT_LEDS_INIT_BLINK)
+    {
       reg |= PMSC_LEDC_BLINK_NOW_ALL;
+    }
     dwt_write32bitoffsetreg(PMSC_ID, PMSC_LEDC_OFFSET, reg);
     // Clear force blink bits if needed.
     if(mode & DWT_LEDS_INIT_BLINK)
+    {
       reg &= ~PMSC_LEDC_BLINK_NOW_ALL;
       dwt_write32bitoffsetreg(PMSC_ID, PMSC_LEDC_OFFSET, reg);
+    }
     aosThdMSleep(500);
+  }
-cb40108
+            Thomas Schöpping
-            88449987
+  /*! UT2: Initialization  of the DW1000 module */
   reset_DW1000();
   chprintf(stream, "initialise the instance for DW1000 \n");
   aosThdMSleep(100);
   int x_init = instance_init(h_dw1000data->dw1000d) ;
   if (x_init != 0){
-cb40108
+    chprintf(stream, "init error with return value: %d \n", x_init);
+  }
   else {
-            88449987
+    chprintf(stream, "succeed init! \n");
-cb40108
+            Thomas Schöpping
-            88449987
+  aosThdMSleep(100);
-cb40108
+  if (x_init == 0){
     aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
-            88449987
+  /*! UT3: High speed SPI Testing */
   setHighSpeed_SPI(true, h_dw1000data->dw1000d);
   chprintf(stream, "expected ID (HS SPI): 0xDECA0130\n");
   actual_devID = instancereaddeviceid();
   chprintf(stream, "Read ID (HS SPI): 0x%x\n", actual_devID);
   aosThdMSleep(100);
   if (actual_devID == DWT_DEVICE_ID){
-cb40108
+    aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
-            88449987
+  /*! UT4: Configuration of UWB module
    * If all the five unit tests are passed, the module is ready to run.
    * Note that the interrupt IRQn should be tested separately.
    */
-cb40108
+  port_EnableEXT_IRQ();
   reset_DW1000();
   chprintf(stream, "initialise the configuration for UWB application \n");
   aosThdSleep(1);
-            88449987
+  int uwb_init = UWB_Init(h_dw1000data->dw1000d);
   if (uwb_init != 0){
-cb40108
+    chprintf(stream, "UWB config error with return value: %d \n", uwb_init);
+  }
   else {
-            88449987
+    chprintf(stream, "succeed UWB config process \n", uwb_init);
-cb40108
+            Thomas Schöpping
   if (uwb_init == 0){
     aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
-            88449987
+  /************** End of UNIT_TEST_SNIPPETS_DW1000 *****************/
-cb40108
+            Thomas Schöpping
 #else /* defined(UNIT_TEST_SNIPPETS_DW1000) */
   /*! RUN THE STATE MACHINE DEMO APP (RTLS) */
   chprintf(stream, "initialise the State Machine \n");
   aosThdSleep(2);
   /* Initialize UWB system with user defined configuration  */
-            88449987
+  int uwb_init = UWB_Init(h_dw1000data->dw1000d);
-cb40108
+            Thomas Schöpping
-            88449987
+  if (uwb_init != 0){
-cb40108
+    chprintf(stream, "error in UWB config with return value: %d \n", uwb_init);
+  }
   else {
     chprintf(stream, "succeed the init of UWB config \n");
+  }
   aosThdSleep(1);
   chprintf(stream, "running the RTLS demo application ... \n");
   /*! Run the localization system demo app as a thread */
   while(1){
     instance_run();
 //    aosThdUSleep(10);
-            88449987
+//    aosThdMSleep(1);
-cb40108
+            Thomas Schöpping
 #endif  /* defined(UNIT_TEST_SNIPPETS_DW1000) */
   return result;
-            e05848a6
+            Robin Ewers
-cb40108
+            Thomas Schöpping
 #endif /* (AMIROOS_CFG_TESTS_ENABLE == true) && defined(AMIROLLD_CFG_DW1000) && (AMIROLLD_CFG_DW1000 == 1) */