AMiRo-OS

//#include <string.h>

///*

// * EEPROM (AT24C01B)

// */

//static int _utShellCmdCb_AlldAt24c01b(BaseSequentialStream* stream, int argc, char* argv[])

//{

//  (void)argc;

//  (void)argv;

//  aosUtRun(stream, &moduleUtAlldAt24c01b, NULL);

//  return AOS_OK;

//}

//static ut_at24c01bdata_t _utAlldAt24c01bData = {

//  /* driver   */ &moduleLldEeprom,

//  /* timeout  */ MICROSECONDS_PER_SECOND,

//};

//aos_unittest_t moduleUtAlldAt24c01b = {

//  /* name           */ "AT24C01B",

//  /* info           */ "1kbit EEPROM",

//  /* test function  */ utAlldAt24c01bFunc,

//  /* shell command  */ {

//    /* name     */ "unittest:EEPROM",

//    /* callback */ _utShellCmdCb_AlldAt24c01b,

//    /* next     */ NULL,

//  },

//  /* data           */ &_utAlldAt24c01bData,

//};

///*

// * INA219 (power monitor)

// */

//static int _utShellCmdCb_AlldIna219(BaseSequentialStream* stream, int argc, char* argv[])

//{

//  (void)argc;

//  (void)argv;

//  aosUtRun(stream, &moduleUtAlldIna219, "VLED (4.2V)");

//  return AOS_OK;

//}

//static ut_ina219data_t _utIna219Data = {

//  /* driver           */ &moduleLldPowerMonitorVled,

//  /* expected voltage */ 4.2f,

//  /* tolerance        */ 0.2f,

//  /* timeout */ MICROSECONDS_PER_SECOND,

//};

//aos_unittest_t moduleUtAlldIna219 = {

//  /* name           */ "INA219",

//  /* info           */ "power monitor",

//  /* test function  */ utAlldIna219Func,

//  /* shell command  */ {

//    /* name     */ "unittest:PowerMonitor",

//    /* callback */ _utShellCmdCb_AlldIna219,

//    /* next     */ NULL,

//  },

//  /* data           */ &_utIna219Data,

//};

///*

// * Status LED

// */

//static int _utShellCmdCb_AlldLed(BaseSequentialStream* stream, int argc, char* argv[])

//{

//  (void)argc;

//  (void)argv;

//  aosUtRun(stream, &moduleUtAlldLed, NULL);

//  return AOS_OK;

//}

//aos_unittest_t moduleUtAlldLed = {

//  /* name           */ "LED",

//  /* info           */ NULL,

//  /* test function  */ utAlldLedFunc,

//  /* shell command  */ {

//    /* name     */ "unittest:StatusLED",

//    /* callback */ _utShellCmdCb_AlldLed,

//    /* next     */ NULL,

//  },

//  /* data           */ &moduleLldStatusLed,

//};

///*

// * Power switch driver (MIC9404x)

// */

//static int _utShellCmdCb_Mic9404x(BaseSequentialStream* stream, int argc, char* argv[])

//{

//  // evaluate arguments

//  if (argc == 2) {

//    if (strcmp(argv[1], "1.8V") == 0) {

//      moduleUtAlldMic9404x.data = &moduleLldPowerSwitchV18;

//      aosUtRun(stream, &moduleUtAlldMic9404x, "1.8V");

//      moduleUtAlldMic9404x.data = NULL;

//      return AOS_OK;

//    }

//    else if (strcmp(argv[1], "3.3V") == 0) {

//      moduleUtAlldMic9404x.data = &moduleLldPowerSwitchV33;

//      aosUtRun(stream, &moduleUtAlldMic9404x, "3.3V");

//      moduleUtAlldMic9404x.data = NULL;

//      return AOS_OK;

//    }

//// The 4.2V switch is disabled due to a hardware bug.

////    else if (strcmp(argv[1], "4.2V") == 0) {

////      moduleUtAlldMic9404x.data = &moduleLldPowerSwitchV42;

////      aosUtRun(stream, &moduleUtAlldMic9404x, "4.2V");

////      moduleUtAlldMic9404x.data = NULL;

////      return AOS_OK;

////    }

//    else if (strcmp(argv[1], "5.0V") == 0) {

//      moduleUtAlldMic9404x.data = &moduleLldPowerSwitchV50;

//      aosUtRun(stream, &moduleUtAlldMic9404x, "5.0V");

//      moduleUtAlldMic9404x.data = NULL;

//      return AOS_OK;

//    }

//    else if (strcmp(argv[1], "VSYS") == 0) {

//      moduleUtAlldMic9404x.data = &moduleLldPowerSwitchVsys;

//      aosUtRun(stream, &moduleUtAlldMic9404x, "VSYS");

//      moduleUtAlldMic9404x.data = NULL;

//      return AOS_OK;

//    }

//  }

//  // print help

//  chprintf(stream, "Usage: %s OPTION\n", argv[0]);

//  chprintf(stream, "Options:\n");

//  chprintf(stream, "  1.8V\n");

//  chprintf(stream, "    Test power switch for 1.8V supply.\n");

//  chprintf(stream, "  3.3V\n");

//  chprintf(stream, "    Test power switch for 3.3V supply.\n");

//// The 4.2V switch is disabled due to a hardware bug.

////  chprintf(stream, "  4.2V\n");

////  chprintf(stream, "    Test power switch for 4.2V supply.\n");

//  chprintf(stream, "  5.0V\n");

//  chprintf(stream, "    Test power switch for 5.0V supply.\n");

//  chprintf(stream, "  VSYS\n");

//  chprintf(stream, "    Test power switch for VSYS supply.\n");

//  return AOS_INVALIDARGUMENTS;

//}

//aos_unittest_t moduleUtAlldMic9404x = {

//  /* info           */ "MIC9404x",

//  /* name           */ "power swicth driver",

//  /* test function  */ utAlldMic9404xFunc,

//  /* shell command  */ {

//    /* name     */ "unittest:PowerSwitch",

//    /* callback */ _utShellCmdCb_Mic9404x,

//    /* next     */ NULL,

//  },

//  /* data           */ NULL,

//};

///*

// * LED PWM driver (TLC5947)

// */

//static int _utShellCmdCb_Tlc5947(BaseSequentialStream* stream, int argc, char* argv[])

//{

//  (void)argc;

//  (void)argv;

//  aosUtRun(stream, &moduleUtAlldTlc5947, NULL);

//  return AOS_OK;

//}

//aos_unittest_t moduleUtAlldTlc5947 = {

//  /* info           */ "TLC5947",

//  /* name           */ "LED PWM driver",

//  /* test function  */ utAlldTlc5947Func,

//  /* shell command  */ {

//    /* name     */ "unittest:Lights",

//    /* callback */ _utShellCmdCb_Tlc5947,

//    /* next     */ NULL,

//  },

//  /* data           */ &moduleLldLedPwm,

//};

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2019  Thomas Schöpping et al.

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/>.

*/

#include <amiroos.h>

#if (AMIROOS_CFG_TESTS_ENABLE == true) || defined(__DOXYGEN__)

#include <module_test_DW1000.h>

#include <aos_test_DW1000.h>

/******************************************************************************/

/* LOCAL DEFINITIONS                                                          */

/******************************************************************************/

/******************************************************************************/

/* EXPORTED VARIABLES                                                         */

/******************************************************************************/

/******************************************************************************/

/* LOCAL TYPES                                                                */

/******************************************************************************/

/******************************************************************************/

/* LOCAL VARIABLES                                                            */

/******************************************************************************/

static aos_test_dw1000data_t _data = {

  /* UWB data     */ &moduleLldDw1000,

  /* event source */ &aos.events.io,

  /* event flags  */ MODULE_OS_IOEVENTFLAGS_DW1000_IRQn,

};

static AOS_TEST(_test, "DW1000", NULL, moduleTestDw1000ShellCb, aosTestDw1000Func, &_data);

/******************************************************************************/

/* LOCAL FUNCTIONS                                                            */

/******************************************************************************/

/******************************************************************************/

/* EXPORTED FUNCTIONS                                                         */

/******************************************************************************/

int moduleTestDw1000ShellCb(BaseSequentialStream* stream, int argc, char* argv[], aos_testresult_t* result)

{

  (void)argc;

  (void)argv;

  if (result != NULL) {

    *result = aosTestRun(stream, &_test, NULL);

  } else {

    aosTestRun(stream, &_test, NULL);

  }

  return AOS_OK;

}

#endif /* (AMIROOS_CFG_TESTS_ENABLE == true) */

/*

AMiRo-OS is an operating system designed for the Autonomous Mini Robot (AMiRo) platform.

Copyright (C) 2016..2019  Thomas Schöpping et al.

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/>.

*/

#ifndef MODULE_TEST_LED_H

#define MODULE_TEST_LED_H

#include <amiroos.h>

#if (AMIROOS_CFG_TESTS_ENABLE == true) || defined(__DOXYGEN__)

/******************************************************************************/

/* CONSTANTS                                                                  */

/******************************************************************************/

/******************************************************************************/

/* SETTINGS                                                                   */

/******************************************************************************/

/******************************************************************************/

/* CHECKS                                                                     */

/******************************************************************************/

/******************************************************************************/

/* DATA STRUCTURES AND TYPES                                                  */

/******************************************************************************/

/******************************************************************************/

/* MACROS                                                                     */

/******************************************************************************/

/******************************************************************************/

/* EXTERN DECLARATIONS                                                        */

/******************************************************************************/

#if defined(__cplusplus)

extern "C" {

#endif /* defined(__cplusplus) */

  int moduleTestDw1000ShellCb(BaseSequentialStream* stream, int argc, char* argv[], aos_testresult_t* result);

#if defined(__cplusplus)

}

#endif /* defined(__cplusplus) */

/******************************************************************************/

/* INLINE FUNCTIONS                                                           */

/******************************************************************************/

#endif /* (AMIROOS_CFG_TESTS_ENABLE == true) */

#endif /* MODULE_TEST_LED_H */