path: root/Software/Embedded_SW/Embedded/Communication/CommunicationTask.c

/*
 * CommunicationTask.c
 *
 *  Created on: 8 ����� 2018
 *      Author: shlomo
 */

#include "include.h"
#include "drivers/Uart_Comm/uart.h"
#include "communicationTask.h"
#include <Container.h>
#include "delay.h"
#include "modules/Diagnostics/Diagnostics.h"
#include "drivers/Uart_Comm/uart.h"


Mailbox_Handle          CommunicationRxMsgQ = NULL;
Mailbox_Handle          CommunicationTxMsgQ = NULL;
#define COMMUNICATION_NUM_MSGS 50
typedef struct CommRxMessage{
    //uint16_t messageId;
    uint16_t msgSize;
    uint32_t BuffId;
}CommRxMessageStruc;
typedef struct CommTxMessage{
    //uint16_t messageId;
    uint16_t msgSize;
    char *Buff;
}CommTxMessageStruc;

int CommType = isUART;

struct serialBuffer {
  char *buffer;
  size_t used;
  size_t size;
} typedef SerialBuffer;
#define SHORT_BUFFER_SIZE 100
char CommShortRxBuffer[10][SHORT_BUFFER_SIZE];
char CommRxBuffer[2][COMM_MAX_BUFFER_SIZE];
SerialBuffer inBuffer[12];
bool SerialBufferUsed[12] = {false,false,false,false,false,false,false,false,false,false,false,false};
uint32_t initArray(size_t initialSize)
{
  if (initialSize >= COMM_MAX_BUFFER_SIZE) return 0xFF;
  if (initialSize > SHORT_BUFFER_SIZE)
  {
      if ((SerialBufferUsed[10] == true)&&(SerialBufferUsed[11] == true))
      {
          return 0xFF;
      }
      else
      {
          if (SerialBufferUsed[10] == false)
          {
              SerialBufferUsed[10] = true;
              inBuffer[10].buffer = CommRxBuffer;
              inBuffer[10].used = 0;
              inBuffer[10].size = initialSize;
              //Report("initArray", __FILE__, 10, inBuffer[10].size, RpWarning,   (int)0, 0);
              return 10;
          }
          else if (SerialBufferUsed[11] == false)
          {
              SerialBufferUsed[11] = true;
              inBuffer[11].buffer = CommRxBuffer;
              inBuffer[11].used = 0;
              inBuffer[11].size = initialSize;
              //Report("initArray", __FILE__, 10, inBuffer[10].size, RpWarning,   (int)0, 0);
              return 11;
          }
          else return 0xFF;
      }
  }
  else
  {
      int i,j;
      for (i = 0; i < 10; i++)
      {
          if (SerialBufferUsed[i] == false)
              break;
      }
      if (i == 10)
          {
              for (j = 0; j < 10; j++)
                  Report("initArray all buffers busy", __FILE__, j, inBuffer[j].size, RpWarning,   (int)SerialBufferUsed[j], 0);
              return 0xFF;
          }
      else
      {
          SerialBufferUsed[i] = true;
          inBuffer[i].buffer = (char *)&CommShortRxBuffer[i];
          inBuffer[i].used = 0;
          inBuffer[i].size = initialSize;
          //Report("initArray", __FILE__, i, inBuffer[i].size, RpWarning,   (int)0, 0);
          return i;
      }
  }
  /*SerialBuffer *a = &inBuffer;
  a->buffer = CommRxBuffer;
  a->used = 0;
  a->size = initialSize;
  return initialSize;*/
}

bool insertArray(uint32_t buffer,char element)
{
    /*if (buffer>=12)
    {
        LOG_ERROR(buffer,"insertArray");
		return false;
    }*/
    SerialBuffer *a = &inBuffer[buffer];
  // a->used is the number of used entries, because a->array[a->used++] updates a->used only *after* the array has been accessed.
  // Therefore a->used can go up to a->size
  a->buffer[a->used++] = element;
  return true;
}

void freeArray(uint32_t buffer)
{
    //Report("freeArray", __FILE__, buffer, inBuffer[buffer].size, RpWarning,   (int)0, 0);

     SerialBufferUsed[buffer] = false;
}

uint32_t CommunicationTaskInit(void)
{
    USBCDCD_init();
    Init_U0();

    return OK;
}
uint32_t CommTxMsgCounter = 0;
uint32_t CommRxMsgCounter = 0;
uint32_t CommunicationTaskMessageReceived(uint32_t buffer,uint16_t msgSize)
{
    CommRxMessageStruc CommRxMessage;
    CommRxMsgCounter++;

    //CommRxMessage.messageId = 1;
    CommRxMessage.msgSize = msgSize;
    CommRxMessage.BuffId = buffer;
    if (CommunicationRxMsgQ != NULL)
        /*retcode =*/ Mailbox_post(CommunicationRxMsgQ , &CommRxMessage, BIOS_NO_WAIT);

    return OK;

}

/******************************************************************************
 *  ======== communicationTask ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this communication task is created statically in system initialization, in blocking mode
 *  over one of the chosen ommunication methods (USB or Blutooth).
 ******************************************************************************/
uint32_t cLength[51] = {0};
byte cindex = 0;
void communicationTask(UArg arg0, UArg arg1)
{

    CommRxMessageStruc CommRxMessage;


    //ui32RxCount = 0;
    CommunicationRxMsgQ = Mailbox_create(sizeof(CommRxMessageStruc), 20, NULL,NULL);

    /* Block while the device is NOT connected to the USB */
//    Semaphore_pend(initConnectionSem, BIOS_WAIT_FOREVER);

    while(1)
    {
        Mailbox_pend(CommunicationRxMsgQ , &CommRxMessage, BIOS_WAIT_FOREVER);
        /*switch (CommRxMessage.messageId)
        {
            case 1:*/
            cLength[cindex] = CommRxMessage.msgSize;
            if (cindex++>=50)
            cindex = 0;
            receive_callback(inBuffer[CommRxMessage.BuffId].buffer,inBuffer[CommRxMessage.BuffId].used);
            freeArray(CommRxMessage.BuffId);
       /*         break;
            default:
                break;
        }*/
    }

}
int UnSentMessages=0, deliveryfailure = 0;
bool CommunicationTaskSendMessage(char* buffer,size_t length)
{
    CommTxMessageStruc CommTxMessage;
    CommTxMsgCounter++;
    bool retcode = true;

    //CommTxMessage.messageId = 1;
    CommTxMessage.msgSize = length;
    CommTxMessage.Buff = buffer;
    UnSentMessages++;
    if (CommunicationTxMsgQ != NULL)
        retcode = Mailbox_post(CommunicationTxMsgQ , &CommTxMessage, BIOS_NO_WAIT);
    if (retcode == false)
    {
        my_free(buffer);
        deliveryfailure++;
//        CommunicationMailboxFlush();
    }


    return retcode;
}
int memoryrelease = 0;
void CommunicationMailboxFlush(void)
{
    int i;
    CommTxMessageStruc CommTxMessage;
    for (i=0;i<COMMUNICATION_NUM_MSGS;i++)
    {
        if (Mailbox_pend(CommunicationTxMsgQ , &CommTxMessage, BIOS_NO_WAIT))
        {
            UnSentMessages--;
            LOG_ERROR(CommTxMessage.msgSize,"Flushing CommTxMessage");
            my_free(CommTxMessage.Buff);
            memoryrelease+=CommTxMessage.msgSize;
        }
    }
}
int32_t SetCommunicationPath(bool UARTorUSB)
{
    CommType = UARTorUSB;
    return OK;
}
/*#define  MAX_CONT_LOG 199

uint16_t cSendSize[MAX_CONT_LOG+1] = {0};
uint32_t cSendTime[MAX_CONT_LOG+1] = {0};
uint16_t cSendindex = 0;
*/
/******************************************************************************
 *  ======== communicationTask ========
 *  Task for this function is created statically. See the project's .cfg file.
 *  this communication task is created statically in system initialization, in blocking mode
 *  over one of the chosen Communication methods (USB or Bluetooth).
 ******************************************************************************/
void communicationTxTask(UArg arg0, UArg arg1)
{

    CommTxMessageStruc CommTxMessage;
    //initArray(1);
    CommunicationTxMsgQ = Mailbox_create(sizeof(CommTxMessageStruc), COMMUNICATION_NUM_MSGS, NULL,NULL);

    while(1)
    {
        Mailbox_pend(CommunicationTxMsgQ , &CommTxMessage, BIOS_WAIT_FOREVER);
        UnSentMessages--;
        if ( CommTxMessage.msgSize > COMM_MAX_BUFFER_SIZE)
        {
            LOG_ERROR(CommTxMessage.msgSize , "message too long");
        }
        else
        {
                if (CommType == isUSB)
                    USBCDCD_sendData(CommTxMessage.Buff, CommTxMessage.msgSize,10);
                else if (CommType == isUART)
                    Uart_Tx(CommTxMessage.Buff, CommTxMessage.msgSize);
        }
/*        cSendSize[cSendindex] = CommTxMessage.msgSize;
        cSendTime[cSendindex] = msec_millisecondCounter;

        if (cSendindex++>=MAX_CONT_LOG)
            cSendindex = 0;
*/
        if (diagnosticscontainer_buffer == CommTxMessage.Buff)
            diagnosticscontainer_buffer = 0;
        my_free(CommTxMessage.Buff);
        //delayms(1); //wait 5 milliseconds between messages
    }

}