s32 CAN_remove_message(PeripheryMessageBuffer * const buffer,
PeripheryMessage *message)
{
#ifndef NO_CB
OUT_DEBUG_2("CAN_remove_message()\r\n");
#endif
if (buffer && message) {
s32 ret = CAN_clear_all_msg_chunks(message);
if (ret < RETURN_NO_ERRORS) {
OUT_DEBUG_1("CAN_clear_all_msg_chunks() = %d error\r\n", ret);
return ret;
}
// -- remove message item
if (message->pPrev) // if not first message in the buffer
message->pPrev->pNext = message->pNext;
else // if first
buffer->pFirstMsg = message->pNext;
if (message->pNext) // if not last
message->pNext->pPrev = message->pPrev;
else // if last
buffer->pLastMsg = message->pPrev;
buffer->buffer_size--;
Ql_MEM_Free(message);
}
return RETURN_NO_ERRORS;
}
s32 CREATE_SINGLE_OBJECT_FROM_DB_FILE(char *db_filename, void **pObject, u32 object_size, u8 object_id)
{
// if (*pObject != NULL) {
// OUT_DEBUG_1("The object of \"%s\" type already exists in RAM.\r\n", db_filename);
// return ERR_DB_TABLE_ALREADY_EXISTS_IN_RAM;
// }
if (*pObject == NULL)
*pObject = Ql_MEM_Alloc(object_size); // in bytes
if (*pObject == NULL) {
OUT_DEBUG_1("Failed to get %d bytes from HEAP\r\n", object_size);
return ERR_GET_NEW_MEMORY_FAILED;
}
OUT_DEBUG_2("CREATE_SINGLE_OBJECT_FROM_DB_FILE(\"%s\") on address %p\r\n", db_filename, *pObject);
s32 offset = object_size * (object_id);
s32 ret = readFromDbFile(db_filename, *pObject, object_size, offset); // to read with offset
if (ret < RETURN_NO_ERRORS) {
Ql_MEM_Free(*pObject);
*pObject = NULL;
OUT_DEBUG_1("readFromDbFile() = %d error for \"%s\" file.\r\n", ret, db_filename);
return ret;
}
return RETURN_NO_ERRORS;
}
s32 CAN_clear_all_msg_chunks(PeripheryMessage *message)
{
#ifndef NO_CB
OUT_DEBUG_2("CAN_clear_all_msg_chunks()\r\n");
#endif
while (message->pkt_chain_head) {
CANPkt *temp = message->pkt_chain_head->pNext;
Ql_MEM_Free(message->pkt_chain_head);
message->pkt_chain_head = temp;
}
message->total_data_len = 0;
message->last_pkt_id = 0;
message->pkt_chain_head = NULL;
message->pkt_chain_tail = NULL;
return RETURN_NO_ERRORS;
}
void proc_main_task(s32 taskId)
{
s32 ret;
u32 cnt = 0;
char Buff[10]="0.345";
char* pStr;
// Register & open UART port
ret = Ql_UART_Register(UART_PORT1, CallBack_UART_Hdlr, NULL);
if (ret < QL_RET_OK)
{
Ql_Debug_Trace("Fail to register serial port[%d], ret=%d\r\n", UART_PORT1, ret);
}
ret = Ql_UART_Open(UART_PORT1, 115200, FC_NONE);
if (ret < QL_RET_OK)
{
Ql_Debug_Trace("Fail to open serial port[%d], ret=%d\r\n", UART_PORT1, ret);
}
APP_DEBUG("OpenCPU: float test !\r\n\r\n"); /* Print out message through DEBUG port */
test_float();
test_dis();
// Start message loop of this task
while (TRUE)
{
Ql_OS_GetMessage(&msg);
switch(msg.message)
{
case MSG_ID_USER_START:
break;
default:
break;
}
}
Ql_MEM_Free(pStr);
}
s32 CREATE_TABLE_FROM_DB_FILE(char *db_filename, void **pBuffer, u32 *db_file_size)
{
// if (*pBuffer != NULL) {
// OUT_DEBUG_1("The table of \"%s\" type already exists in RAM.\r\n", db_filename);
// return ERR_DB_TABLE_ALREADY_EXISTS_IN_RAM;
// }
u32 local_size = 0; // will be used if "db_file_size" parameter is not specified (is NULL)
u32 *size = db_file_size ? db_file_size : &local_size;
s32 ret = Ql_FS_GetSize(db_filename);
if (ret < 0) return ret;
else *size = ret;
if (*pBuffer == NULL)
*pBuffer = Ql_MEM_Alloc(*size); // in bytes
if (*pBuffer == NULL) {
if (*size != 0) {
OUT_DEBUG_1("Failed to get %d bytes from HEAP\r\n", *size);
return ERR_GET_NEW_MEMORY_FAILED;
} else {
OUT_DEBUG_1("DB file \"%s\" is empty\r\n", db_filename);
return ERR_DB_FILE_IS_EMPTY;
}
}
OUT_DEBUG_2("CREATE_TABLE_FROM_DB_FILE(\"%s\") on address %p\r\n", db_filename, *pBuffer);
ret = readFromDbFile(db_filename, *pBuffer, *size, 0); // to read entire file
if (ret < RETURN_NO_ERRORS) {
Ql_MEM_Free(*pBuffer);
*pBuffer = NULL;
OUT_DEBUG_1("readFromDbFile() = %d error for \"%s\" file.\r\n", ret, db_filename);
return ret;
}
Ar_System_writeSizeAllFiles((u32) ret + Ar_System_readSizeAllFiles());
return RETURN_NO_ERRORS;
}
s32 rx_handler_groupsState(PultMessageRx *pMsg)
{
OUT_DEBUG_2("rx_handler_groupsState\r\n");
ArmingGroup_tbl *pGroups = getArmingGroupTable(NULL);
ArmingGroup *pGroup = 0;
u16 dataLen;
u16 firstGroupPKT = pMsg->complex_msg_part[0];
u16 groupCountPKT = pMsg->complex_msg_part[1];
OUT_DEBUG_7("firstGroupPKT: %d, groupCountPKT: %d, pZones->size: %d\r\n",
firstGroupPKT, groupCountPKT, pGroups->size);
if(firstGroupPKT == 0){
firstGroupPKT = 1;
groupCountPKT = pGroups->size;
}
else {
// first zone
if(firstGroupPKT > pGroups->size)
firstGroupPKT = pGroups->size;
// zones count
if(((firstGroupPKT-1) + groupCountPKT) > pGroups->size)
groupCountPKT = pGroups->size - (firstGroupPKT - 1);
}
OUT_DEBUG_7("firstGroupPKT: %d, groupCountPKT: %d\r\n",
firstGroupPKT, groupCountPKT);
// buffer size
dataLen = groupCountPKT / 2;
if(groupCountPKT % 2) dataLen++;
// create buffer
u8 *data = Ql_MEM_Alloc(dataLen + 2);
if(!data)
{
OUT_DEBUG_1("Failed to get %d bytes from HEAP\r\n", dataLen + 2);
u8 data_err[2] = {RCE_MemoryAllocationError,0};
reportToPultComplex(data_err, 2, PMC_CommandReject, PMQ_AuxInfoMsg);
return ERR_GET_NEW_MEMORY_FAILED;
}
for(u8 j = 0; j < dataLen + 2; ++j){
data[j] = 0;
}
u16 indexData = 0;
u8 tempData;
u8 k;
data[0] = firstGroupPKT;
data[1] = groupCountPKT;
for (u16 i = (firstGroupPKT - 1); i <= (groupCountPKT + firstGroupPKT - 2); ++i) {
pGroup = &pGroups->t[i];
k = i - (firstGroupPKT - 1);
indexData = k / 2 + 2;
// --- Set bits
// bit0: 1-Normal/0-Others
// bit1: reserved
// bit2: 1-Armrd /0-Others
// bit3: 1-Used /0-Others
tempData = 0;
if(TRUE == Ar_GroupState_isArmed(pGroup)){
tempData = tempData | 4;
}
if(TRUE == Ar_System_isZonesInGroupNormal(pGroup))
tempData = tempData | 1;
// ---
tempData = tempData | 8;
if(k % 2)
tempData = tempData << 4;
data[indexData] = data[indexData] | tempData;
}
// for (u16 ii = 0; ii <(dataLen + 2); ++ii) {
// OUT_DEBUG_7("data[%d]: %d \r\n",
// ii, data[ii]);
// }
reportToPultComplex(data, sizeof(data), PMC_Response_GroupsState, PMQ_AuxInfoMsg);
Ql_MEM_Free(data);
return RETURN_NO_ERRORS;
}
s32 rx_handler_loopsState(PultMessageRx *pMsg)
{
OUT_DEBUG_2("rx_handler_loopsState \r\n");
Zone_tbl *pZones = getZoneTable(NULL);
Zone *pZone = 0;
ArmingGroup *pGroup = 0;
u16 dataLen;
u16 dataLen_1;
u16 dataLen_2;
u16 dataLen_3;
u16 firstZonePKT = pMsg->complex_msg_part[0];
u16 zoneCountPKT = pMsg->complex_msg_part[1];
u16 detailLevel = pMsg->complex_msg_part[2];
// ----------------------------------------------------------------------
u8 zoneEnabled;
u8 zoneState;
u8 zoneGroupID;
u8 zoneArmed;
u8 zoneType;
u8 zoneLastEventType;
OUT_DEBUG_7("firstZonePKT: %d, zoneCountPKT: %d, detailLevel: %d, pZones->size: %d\r\n",
firstZonePKT, zoneCountPKT, detailLevel, pZones->size);
if(firstZonePKT == 0){
firstZonePKT = 1;
zoneCountPKT = pZones->size;
}
else {
// first zone
if(firstZonePKT > pZones->size)
firstZonePKT = pZones->size;
// zones count
if(((firstZonePKT-1) + zoneCountPKT) > pZones->size)
zoneCountPKT = pZones->size - (firstZonePKT - 1);
}
OUT_DEBUG_7("firstZonePKT: %d, zoneCountPKT: %d\r\n",
firstZonePKT, zoneCountPKT);
//data len
dataLen_1 = zoneCountPKT / 8;
if(zoneCountPKT % 8) dataLen_1++;
dataLen_2 = zoneCountPKT / 2;
if(zoneCountPKT % 2) dataLen_2++;
dataLen_3 = zoneCountPKT * 2;
OUT_DEBUG_7("finis -> dataLen_1: %d, dataLen_2: %d, dataLen_3: %d\r\n",
dataLen_1, dataLen_2, dataLen_3);
// buffer size
switch (detailLevel){
case 1:
case 49:
dataLen = dataLen_1;
detailLevel = 1;
break;
case 2:
case 50:
dataLen = dataLen_2;
detailLevel = 2;
break;
case 3:
case 51:
default:
dataLen = dataLen_3;
detailLevel = 3;
break;
}
//----------------------------------
OUT_DEBUG_7("dataLen: %d, detailLevel: %d\r\n",
dataLen, detailLevel);
// create buffer
u8 *data = Ql_MEM_Alloc(dataLen + 3);
if(!data)
{
OUT_DEBUG_1("Failed to get %d bytes from HEAP\r\n", dataLen + 3);
u8 data_err[2] = {RCE_MemoryAllocationError,0};
reportToPultComplex(data_err, 2, PMC_CommandReject, PMQ_AuxInfoMsg);
return ERR_GET_NEW_MEMORY_FAILED;
}
else{//++++++++++++++++++++++++++++++++++++++++++++
for(u8 j = 0; j < dataLen + 3; ++j){
data[j] = 0;
}
data[0] = firstZonePKT;
data[1] = zoneCountPKT;
data[2] = detailLevel;
u16 indexData = 0;
u8 counterBit = 0; // from 0 to 7
u8 zoneStateBuffer = 0;
u8 zoneTetradaBuffer = 0;
u8 rorTemplate = 0;
u8 tempByte = 0;
u8 triadaByte =0;
u8 k;
for (u16 i = (firstZonePKT - 1); i <= (zoneCountPKT + firstZonePKT - 2); ++i) {
pZone = &pZones->t[i];
zoneEnabled = (pZone->enabled == TRUE)? 1 : 0;
zoneState =(pZone->zoneDamage_counter == 0)? 1 : 0;
zoneGroupID = pZone->group_id;
pGroup = getArmingGroupByID(pZone->group_id);
if(!pGroup){
zoneArmed = 0;
}
else {
zoneArmed = (TRUE == Ar_GroupState_isArmed(pGroup))? 1 : 0;
}
zoneType = pZone->zone_type;
zoneLastEventType = pZone->last_event_type;
//fill buffer
switch (detailLevel){
case 1:
// поставить zoneArmed
// в data[indexData]
// на место counterBit
// все из i растет
k = i - (firstZonePKT - 1);
indexData = k / 8 + 3;
counterBit = k - (k / 8) * 8;
// OUT_DEBUG_7("i: %d, k: %d, indexData: %d , counterBit: %d \r\n",
// i, k, indexData, counterBit);
tempByte = zoneState << counterBit;
data[indexData] = (data[indexData] | tempByte);
break;
case 2:
// в data[indexData]
k = i - (firstZonePKT - 1);
indexData = k / 2 + 3;
//===================
// формируем triadaByte
triadaByte = 0;
triadaByte = triadaByte | zoneEnabled;
triadaByte = triadaByte << 1;
triadaByte = triadaByte | zoneArmed;
triadaByte = triadaByte << 2;
switch (zoneLastEventType) {
case ZONE_EVENT_BREAK:
triadaByte = triadaByte | 1;
break;
case ZONE_EVENT_SHORT:
triadaByte = triadaByte | 2;
break;
case ZONE_EVENT_FITTING:
triadaByte = triadaByte | 3;
break;
case ZONE_EVENT_NORMAL:
default:
triadaByte = triadaByte | 0;
}
//===================
if(k % 2) triadaByte = triadaByte << 4;
data[indexData] = (data[indexData] | triadaByte);
break;
case 3:
default:
// в data[indexData]
k = i - (firstZonePKT - 1);
indexData = k * 2 + 3;
data[indexData] = zoneType << 4;
//===================
// формируем triadaByte
triadaByte = 0;
triadaByte = triadaByte | zoneEnabled;
triadaByte = triadaByte << 1;
triadaByte = triadaByte | zoneArmed;
triadaByte = triadaByte << 2;
switch (zoneLastEventType) {
case ZONE_EVENT_BREAK:
triadaByte = triadaByte | 1;
break;
case ZONE_EVENT_SHORT:
triadaByte = triadaByte | 2;
break;
case ZONE_EVENT_FITTING:
triadaByte = triadaByte | 3;
break;
case ZONE_EVENT_NORMAL:
default:
triadaByte = triadaByte | 0;
}
//===================
data[indexData] = data[indexData] | triadaByte;
data[indexData + 1] = zoneGroupID;
break;
}
// OUT_DEBUG_7("pZone[%d]->enabled: %d , state: %d , group_id: %d, zoneArmed: %d , zoneType: , %d zoneLastEventType: %d \r\n",
// i, zoneEnabled, zoneState, zoneGroupID, zoneArmed, zoneType, zoneLastEventType);
}
// for (u16 ii = 0; ii <(dataLen + 3); ++ii) {
// OUT_DEBUG_7("data[%d]: %d \r\n",
// ii, data[ii]);
// }
reportToPultComplex(data, dataLen + 3, PMC_Response_LoopsState, PMQ_AuxInfoMsg);
Ql_MEM_Free(data);
}//++++++++++++++++++++++++++++++++++++++++++
//-----------------------------------------------------------------------
return RETURN_NO_ERRORS;
}
void pultRxBuffer_msg_cleanup_callback(PultMessageRx *msg)
{ if (msg && msg->bComplex && msg->complex_msg_part) Ql_MEM_Free(msg->complex_msg_part); }
