AMiRo-OS

/*

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

Copyright (C) 2016..2018  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 <stdint.h>

#include <hal.h>

#include <module.h>

#include <hal_can.h>

#include <aos_rtcan.h>

#include <ut_lld_rtcan.h>

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

#include <aos_debug.h>

#include <chprintf.h>

#include <aos_thread.h>

/**

 * @brief   Helper function to serialize data.

 *

 * @param[out]  dst   Pointer to the output buffer.

 * @param[in]   src   Data to be serialized.

 * @param[in]   n     Number of bytes to serialize.

 */

inline void _serialize(uint8_t* dst, const uint64_t src, const uint8_t n)

{

  aosDbgCheck(dst != NULL);

  aosDbgCheck(n > 0 && n <= 8);

  for (uint8_t byte = 0; byte < n; ++byte) {

    dst[byte] = (uint8_t)((src >> (byte * 8)) & 0xFF);

  }

  return;

}

/**

 * @brief   Helper function to deserialize data.

 *

 * @param[in] src   Pointer to the buffer of data to be deserialzed.

 * @param[in] n     Number of bytes to deserialize.

 *

 * @return    The deserialized 32 bit data.

 */

inline uint64_t _deserialize(uint8_t* src, const uint8_t n)

{

  aosDbgCheck(src != NULL);

  aosDbgCheck(n > 0 && n <= 8);

  uint64_t result = 0;

  for (uint8_t byte = 0; byte < n; ++byte) {

    result |= ((uint64_t)src[byte]) << (byte * 8);

  }

  return result;

}

/**

 * @brief   RTCAN unit test function.

 *

 * @param[in] stream  Stream for input/output.

 * @param[in] ut      Unit test object.

 *

 * @return            Unit test result value.

 */

aos_utresult_t utLldRtCanFunc(BaseSequentialStream* stream, aos_unittest_t* ut)

{

  aosDbgCheck(ut->data != NULL && ((ut_rtcandata_t*)ut->data)->operation!= NULL);

  // local variables

  // rtcanTransmit and reveive Test necessary

  aos_utresult_t result = {0, 0};

  //aos_getTime irgendwas

  msg_t msg = MSG_TIMEOUT;

  char* operation = ((ut_rtcandata_t*)ut->data)->operation;

  if(strcmp(operation, "send")==0){

    CANTxFrame ctfp;

    ctfp.RTR = CAN_RTR_DATA;

    ctfp.IDE = CAN_IDE_STD;

    ctfp.DLC = 0;

    ctfp.SID = 0x003;

    aos_timestamp_t stamp;

    aosSysGetUptime(&stamp);

    _serialize(ctfp.data8,stamp,4);

    msg = rtcan_transmit(&MODULE_HAL_CAN,CAN_ANY_MAILBOX,&ctfp);

  }else if (strcmp(operation, "receive")==0){

    aosUtInfoMsg(stream,"trying to receive msg");

    CANRxFrame crfp;

    crfp.RTR = CAN_RTR_DATA;

    crfp.IDE = CAN_IDE_STD;

    crfp.DLC = 0;

    crfp.SID = 0x003;

    int empty = can_lld_is_rx_nonempty(&MODULE_HAL_CAN,CAN_ANY_MAILBOX);

    if (empty){

        aosUtInfoMsg(stream,"RX is Empty");

    }

    msg = rtcan_receive(&MODULE_HAL_CAN,CAN_ANY_MAILBOX,&crfp);

    uint64_t recv = _deserialize(crfp.data8,4);

    aosUtInfoMsg(stream,"Received Message has the payload:  %d",recv);

  }

  if(msg == MSG_OK){

    aosUtPassedMsg(stream,&result,"Message sucessfull transmitted");

  }else{

    aosUtFailedMsg(stream,&result,"Timeout while waiting for message transmission");

  }

  return result;

}

#endif /* (AMIROOS_CFG_TESTS_ENABLE == true) && defined(AMIROLLD_CFG_USE_LED) */