/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 @ 080149cf

History | View | Annotate | Download (11.535 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>
-            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
+  }
+}
 /*! @brief entry point to the IRQn event in DW1000 module
+ *
  * */
 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 Check the current value of GPIO pin and return the value */
 apalGpioState_t port_CheckEXT_IRQ(void) {
   apalGpioState_t  val;
   apalGpioRead(moduleGpioDw1000Irqn.gpio, &val);
   return val;
+}
 /*! @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
+            Thomas Schöpping
   //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:
-cb40108
+            Thomas Schöpping
   aosThdMSleep(2);
+}
 /*! @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;
+  }
   result = instance_init(drv) ;
   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
+            Robin Ewers
-cb40108
+            Thomas Schöpping
-            e05848a6
+aos_utresult_t utAlldDw1000Func(BaseSequentialStream* stream, aos_unittest_t* ut) {
-cb40108
+  aosDbgCheck(ut->data != NULL);
-            e05848a6
+            Robin Ewers
-cb40108
+  aos_utresult_t result = {0, 0};
-            e05848a6
+            Robin Ewers
-cb40108
+  chprintf(stream, "init DW1000...\n");
   dwt_initialise(DWT_LOADUCODE, (DW1000Driver*) ut->data);
   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)
-            e05848a6
+            Robin Ewers
-cb40108
+  uint32_t actual_deviceId;
-            e05848a6
+            Robin Ewers
-cb40108
+  port_DisableEXT_IRQ();
-            e05848a6
+            Robin Ewers
-cb40108
+  setHighSpeed_SPI(false, (DW1000Driver*) ut->data);
   chprintf(stream, "expected device ID (LS SPI): 0xDECA0130 \n");
   aosThdMSleep(5);
   actual_deviceId = instancereaddeviceid();
   chprintf(stream, "actual read ID: 0x%x\n", actual_deviceId);
   aosThdMSleep(5);
-            e05848a6
+            Robin Ewers
-cb40108
+  //if the read of device ID fails, the DW1000 could be asleep
   if(DWT_DEVICE_ID != actual_deviceId){
-            e05848a6
+            Robin Ewers
-cb40108
+    clear_SPI_chip_select();
     aosThdMSleep(1);
     set_SPI_chip_select();
     aosThdMSleep(7);
     actual_deviceId = instancereaddeviceid() ;
     if(DWT_DEVICE_ID != actual_deviceId){
       chprintf(stream, "SPI is not working or Unsupported Device ID\n");
       chprintf(stream, "actual device ID is: 0x%x\n", actual_deviceId);
       chprintf(stream, "expected device ID: 0xDECA0130 \n");
       aosThdMSleep(5);
+    }
-            e05848a6
+            Robin Ewers
-cb40108
+    //clear the sleep bit - so that after the hard reset below the DW does not go into sleep
     dwt_softreset();
+  }
   /*! UT1: Low speed SPI result */
   if (actual_deviceId == DWT_DEVICE_ID){
     aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
   reset_DW1000();
   chprintf(stream, "initialise instance for DW1000 \n");
   aosThdSleep(1);
   int x_init = instance_init((DW1000Driver*) ut->data) ;
   if (0 != x_init){
     chprintf(stream, "init error with return value: %d \n", x_init);
     aosThdSleep(1);
+  }
   else {
     chprintf(stream, "init success with return value: %d \n", x_init);
     aosThdSleep(1);
+  }
   /*! UT2: Initialization  result*/
   if (x_init == 0){
     aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
   setHighSpeed_SPI(true, (DW1000Driver*) ut->data);
   chprintf(stream, "expected device ID (HS SPI): 0xDECA0130\n");
   actual_deviceId = instancereaddeviceid();
   chprintf(stream, "actual read ID: 0x%x\n", actual_deviceId);
   aosThdMSleep(1);
   /*! UT3: High speed SPI result*/
   if (actual_deviceId == DWT_DEVICE_ID){
     aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
   port_EnableEXT_IRQ();
   reset_DW1000();
   chprintf(stream, "initialise the configuration for UWB application \n");
   aosThdSleep(1);
   int uwb_init = UWB_Init((DW1000Driver*) ut->data);
   if (0 != uwb_init){
     chprintf(stream, "UWB config error with return value: %d \n", uwb_init);
     aosThdSleep(1);
+  }
   else {
     chprintf(stream, "UWB config success with return value: %d \n", uwb_init);
     aosThdSleep(1);
+  }
   /*! UT4: UWB configuration result
    * If all the four unit tests are passed, the module is ready to run.
    * Note that the interrupt IRQn should be tested separately.
    */
   if (uwb_init == 0){
     aosUtPassed(stream, &result);
   } else {
     aosUtFailed(stream, &result);
+  }
   /************** End of UNIT_TEST_SNIPPETS_DW1000*****************/
 #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  */
   int uwb_init = UWB_Init((DW1000Driver*) ut->data);
   if (0 != uwb_init){
     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");
   aosThdSleep(1);
   /*! Run the localization system demo app as a thread */
   while(1){
     instance_run();
 //    aosThdUSleep(10);
+  }
 #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) */