Nov 2020: uTasker i.MX RT V1.4.12 is productive - with complete secure loading concept.
Follow uTasker updates at www.twitter.com/uTasker !!
Online Forum registration has now been disabled. Please send an email to an address at the bottom of the home page with your preferred user name and email address if you would like an account.
Return to uTasker main site: www.utasker.com
Show Posts
This section allows you to view all posts made by this member. Note that you can only see posts made in areas you currently have access to.
I think that the following may work:
len = fnRead( PortIDInternalQueue, ucRxMessage, ucRxMessage[MSG_CONTENT_LENGTH]);
fnWrite(SerialID, ucRxMessage, len);
In your method:
fnRead( PortIDInternalQueue, ucRxMessage, SMALL_MESSAGE);
will read all messages in the input queue into ucRxMessage.
len = uStrlen(ucRxMessage); will then probably give the length of the first string in the queue (although there are proabably several strings waiting there)
//include
#include "config.h"
//Global variables
static QUEUE_HANDLE PortIDInternalQueue; // queue ID for task input
//Prototypes
void fnDummyQueueTask(TTASKTABLE *ptrTaskTable);
//functions
void fnRxMessage(TTASKTABLE *ptrTaskTable) // scheduled once every 2s
{
unsigned char ucRxMessage[SMALL_MESSAGE] = {0};
static QUEUE_HANDLE SerialID;
int len = 0;
while ( fnRead( PortIDInternalQueue, ucRxMessage, HEADER_LENGTH + 1 )) // read the queued inputs every 2s.
{
SerialID = ucRxMessage[MSG_CONTENT_COMMAND];
switch(ucRxMessage[MSG_SOURCE_TASK]) // Source of message
{
case TASK_TX_MESSAGE:
{
fnRead( PortIDInternalQueue, ucRxMessage, SMALL_MESSAGE);
len = uStrlen(ucRxMessage);
fnWrite(SerialID, ucRxMessage, len);
}
}
}
}
void fnDummyQueueTask(TTASKTABLE *ptrTaskTable)
{
PortIDInternalQueue = ptrTaskTable->TaskID; // remember the input handle but don't read the queue
}
//Includes
#include "config.h"
//defines
//Global varables
//Prototypes
void fnSendToDummy(unsigned char ucCommand, unsigned char *ucData, unsigned char ucLength);
QUEUE_HANDLE fnConfigureUART(unsigned char mode);
//functions
void fnTxMessage(TTASKTABLE *ptrTaskTable)
{
static unsigned int uiState;
unsigned char ucRxUART[SMALL_MESSAGE] = {0};
static QUEUE_HANDLE SerialID;
if(uiState == 0)
{
SerialID = fnConfigureUART(FOR_I_O);
uTaskerStateChange(TASK_TX_MESSAGE, UTASKER_STOP);
uiState = 1;
}
if(fnRead(SerialID, (unsigned char *)ucRxUART, SMALL_MESSAGE) != 0)
fnSendToDummy(SerialID, (unsigned char *)ucRxUART, uStrlen(ucRxUART));
else
fnSendToDummy(SerialID, (unsigned char *)"empty\r", uStrlen("empty\r"));
}
void fnSendToDummy(unsigned char ucCommand, unsigned char *ucData, unsigned char ucLength)
{
unsigned char ucTxMessage[ HEADER_LENGTH + SMALL_MESSAGE + 1];
ucTxMessage[ MSG_DESTINATION_NODE ] = INTERNAL_ROUTE;
ucTxMessage[ MSG_SOURCE_NODE ] = INTERNAL_ROUTE;
ucTxMessage[ MSG_DESTINATION_TASK ] = TASK_DUMMY;
ucTxMessage[ MSG_SOURCE_TASK ] = TASK_TX_MESSAGE;
ucTxMessage[ MSG_CONTENT_LENGTH ] = ucLength;
ucTxMessage[ MSG_CONTENT_COMMAND ] = ucCommand;
if (fnWrite(INTERNAL_ROUTE, ucTxMessage, 0))
fnWrite(INTERNAL_ROUTE, ucData, ucLength);
}
QUEUE_HANDLE fnConfigureUART(unsigned char mode)
{
TTYTABLE tInterfaceParameters; //table for passing information to driver
QUEUE_HANDLE SerialPortID;
tInterfaceParameters.Channel = 0; // serial 0, 1, 2, 3, 4, etc.
tInterfaceParameters.ucSpeed = SERIAL_BAUD_19200; // baud rate
tInterfaceParameters.Rx_tx_sizes.RxQueueSize = RX_BUFFER_SIZE; // input buffer size
tInterfaceParameters.Rx_tx_sizes.TxQueueSize = TX_BUFFER_SIZE;
tInterfaceParameters.Task_to_wake = TASK_TX_MESSAGE;
tInterfaceParameters.usConfig = (CHAR_8| NO_PARITY | ONE_STOP | NO_HANDSHAKE | MSG_MODE);
tInterfaceParameters.ucMessageTerminator = '\r';
if (SerialPortID = fnOpen( TYPE_TTY, mode, &tInterfaceParameters )) // open or change the channel with defined configurations (initially inactive)
fnDriver( SerialPortID, (RX_ON | TX_ON ), 0 ); // enable RX
return SerialPortID;
}
{ "1_Tx", fnTxMessage, NO_QUE, 0, 0, UTASKER_GO},
{ "2_Rx", fnRxMessage, NO_QUE, 0, (DELAY_LIMIT)(10 * SEC), UTASKER_STOP},
{ "3_Dummy", fnDummyQueueTask, (2 * 1024), 0, 0, UTASKER_STOP},
. (Had to close it under proceses using ctrl+alt+del)//includes
#include "config.h"
//Prototypes
void setUart(unsigned char mode);
// Global variables
static QUEUE_HANDLE SerialPortID; // quehandler for serialport 0
//call functions
void fnSerialTest(TTASKTABLE *ptrTaskTable) // my task task in polling mode (at the moment)
{
static int iState = 0;
if (iState== 0)
{
setUart(FOR_I_O); //Rx & Tx
iState = 1;
}
fnWrite(SerialPortID, (unsigned char *)"Hello world", uStrlen("Hello world"));
}
void setUart(unsigned char mode)
{
TTYTABLE tInterfaceParameters; //table for passing information to driver
tInterfaceParameters.Channel = 0; // serial 0, 1, 2, 3, 4, etc.
tInterfaceParameters.ucSpeed = SERIAL_BAUD_19200; // baud rate
tInterfaceParameters.Rx_tx_sizes.RxQueueSize = RX_BUFFER_SIZE; // input buffer size
tInterfaceParameters.Rx_tx_sizes.TxQueueSize = TX_BUFFER_SIZE; // outpu buffer size
tInterfaceParameters.Task_to_wake = TASK_MYUART;
tInterfaceParameters.usConfig = (CHAR_8 | NO_PARITY | ONE_STOP | NO_HANDSHAKE | CHAR_MODE);
if ( (SerialPortID = fnOpen(TYPE_TTY, mode, &tInterfaceParameters)) != 0 ) // open or change the channel with defined configurations (initially inactive)
fnDriver( SerialPortID, (RX_ON | TX_ON), 0 ); // enable RX & TX
}
#define TASK_MYUART 'u'
...
extern void fnSerialTest(TTASKTABLE *ptrTaskTable);
...
TASK_MYUART, //ctNodes
...
{ "uart", fnSerialTest, NO_QUE, 0, 0, UTASKER_GO}, //ctTaskTable
#define SERIAL_PORT_0 '1'
This is correct since I use channel zero and com1 for communication.if ( (SerialPortID = fnOpen(TYPE_TTY, mode, &tInterfaceParameters)) != 0 )
fnOpen() doesn't return to this line. Instad it returns toif ((SerialPortID = fnOpen( TYPE_TTY, ucDriverMode, &tInterfaceParameters )) != 0)
in application.c.
_sopen_s(&iFileIni, FLASH_FILE, (_O_BINARY | _O_TRUNC | _O_CREAT | _O_RDWR), 0, _S_IREAD | _S_IWRITE);