rx_helper.cpp

/********************************* Includes **********************************/
#include "rx_helper.h"
#include "Notification.h"
#include "cmsis_os.h"
#include "robotGoal.h"
#include "robotState.h"
#include "Communication.h"
#include "usart.h"

/****************************** Public Variables *****************************/
extern osThreadId CommandTaskHandle;
extern osThreadId IMUTaskHandle;
extern osThreadId PCUARTHandle;

/***************************** Private Variables *****************************/
static uint8_t robotGoalData[sizeof(RobotGoal)];
static uint8_t *robotGoalDataPtr;
static uint8_t buffRx[92];
static uint8_t startSeqCount;
static uint8_t totalBytesRead;

static HAL_StatusTypeDef status;
static uint32_t notification;

/********************************  Functions  ********************************/
/*****************************************************************************/
/*  StartRxTask Helper Functions                                             */
/*                                                                           */
/*                                                                           */
/*                                                                           */
/*                                                                           */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
void initializeVars(void) {
    //sending
    robotGoal.id = 0;
    robotGoalDataPtr = robotGoalData;
    startSeqCount = 0;
    totalBytesRead = 0;
    //receiving
    robotState.id = 0;
    robotState.start_seq = UINT32_MAX;
    robotState.end_seq = 0;
}

void initiateDMATransfer(void) {
    HAL_UART_Receive_DMA(&huart5, (uint8_t*) buffRx, sizeof(buffRx));
}

void waitForNotificationRX(void) {
    do {
        xTaskNotifyWait(0, NOTIFIED_FROM_RX_ISR, &notification, portMAX_DELAY);
    } while ((notification & NOTIFIED_FROM_RX_ISR) != NOTIFIED_FROM_RX_ISR);
}

void updateStatusToPC(void) {
    do {
        xSemaphoreTake(PCUARTHandle, 1);
        status = HAL_UART_Receive_DMA(&huart5, (uint8_t*) buffRx,
                sizeof(buffRx));
        xSemaphoreGive(PCUARTHandle);
    } while (status != HAL_OK);
}

void receiveDataBuffer(void) {
    for (uint8_t i = 0; i < sizeof(buffRx); i++) {
        if (startSeqCount == 4) {
            // This control block is entered when the header sequence of
            // 0xFFFFFFFF has been received; thus we know the data we
            // receive will be in tact

            *robotGoalDataPtr = buffRx[i];
            robotGoalDataPtr++;
            totalBytesRead++;

            if (totalBytesRead == sizeof(RobotGoal)) {
                // If, after the last couple of receive interrupts, we have
                // received sizeof(RobotGoal) bytes, then we copy the data
                // buffer into the robotGoal structure and wake the control
                // thread to distribute states to each actuator
                memcpy(&robotGoal, robotGoalData, sizeof(RobotGoal));
                robotState.id = robotGoal.id;

                // Reset the variables to help with reception of a RobotGoal
                robotGoalDataPtr = robotGoalData;
                startSeqCount = 0;
                totalBytesRead = 0;

                xTaskNotify(CommandTaskHandle, NOTIFIED_FROM_TASK, eSetBits);// Wake control task
                xTaskNotify(IMUTaskHandle, NOTIFIED_FROM_TASK, eSetBits);// Wake MPU task
                continue;
            }
        } else {
            // This control block is used to verify that the data header is in tact
            if (buffRx[i] == 0xFF) {
                startSeqCount++;
            } else {
                startSeqCount = 0;
            }
        }
    }

}

/* end - RxHelperFunctions */

/* end Helpers */