using Tango.MachineStudio.Dispensers.ViewModels;
using Tango.Core.DI;
namespace Tango.MachineStudio.Dispensers
{
/// <summary>
/// This class contains static references to all the view models in the
/// application and provides an entry point for the bindings.
/// </summary>
public static class ViewModelLocator
{
/// <summary>
/// Initializes a new instance of the ViewModelLocator class.
/// </summary>
static ViewModelLocator()
{
TangoIOC.Default.Register<MainViewVM>();
}
public static MainViewVM MainViewVM
{
get
{
return TangoIOC.Default./*
* CommunicationTask.c
*
* Created on: 8 ����� 2018
* Author: shlomo
*/
#include "include.h"
#include "drivers/Uart_Comm/uart.h"
#include "communicationTask.h"
#include <Container.h>
#include <Utilities/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
}
}
