void Error_Handler(void)
{
/* Turn LED4 on */
// BSP_LED_On(LED4);
while(1)
prvNewPrintString(" #@Error@# ",12);
}
void prvPrintTask(void* pvParameters)
{
char* pcStringToPrint;
pcStringToPrint = (char*)pvParameters;
for (;;)
{
prvNewPrintString(pcStringToPrint);
vTaskDelay(rand() & 0x03FF);
}
}
static void prvPrintTask( void *pvParameters )
{
char *pcStringToPrint;
/* Two instances of this task are created so the string the task will send
to prvNewPrintString() is passed in the task parameter. Cast this to the
required type. */
pcStringToPrint = ( char * ) pvParameters;
for( ;; )
{
/* Print out the string using the newly defined function. */
prvNewPrintString( pcStringToPrint );
/* Wait a pseudo random time. Note that rand() is not necessarily
re-entrant, but in this case it does not really matter as the code does
not care what value is returned. In a more secure application a version
of rand() that is known to be re-entrant should be used - or calls to
rand() should be protected using a critical section. */
vTaskDelay( ( rand() & 0x1FF ) );
}
}
/**
* @brief initial register
* @param None
* @retval None
*/
static void Update_Register(void *argument)
{
/* for the test */
//uint8_t buff[6] ={0,0,0,0,0,0};
uint8_t *output_test = "popout\n";
portTickType xLastWakeTime;
portBASE_TYPE xStatus;
xData test2;
uint16_t* temp_int = NULL;
//prvNewPrintString("Hey",3);
xLastWakeTime = xTaskGetTickCount();
prvNewPrintString("Update Reg\n",12);
for(;;)
{
//prvNewPrintString("Hey",3);
/* for Queue Test */
if(xQueue_EPS!=0)
{
//for(;;)
if(uxQueueMessagesWaiting(xQueue_EPS) != 0)
{
//prvNewPrintString("Hey",3);
//prvNewPrintString(output_test,7);
xStatus = xQueueReceive(xQueue_EPS, &test2 ,0);
if(xStatus == pdPASS)
{
//prvNewPrintString("Success ",8);
switch(test2.refRegister)
{
case ref_envEPS_Battery_Voltage:
temp_int = (type_envEPS_Battery_Voltage *)test2.ptrRegister;
/*get register value from Queue*/
envEPS_Battery_Voltage = *temp_int;
break;
default:
prvNewPrintString("Something Wrong",15);
}
/* Print to Screen*/
//sprintf (buff, "%d", *temp_int);
//prvNewPrintString(buff,6);
free(temp_int);
//Register(Port) 8
hk_test.bv = envEPS_Battery_Voltage;
//Register(Port) 14
}
else
prvNewPrintString("Fail",4);
//vTaskDelayUntil( &xLastWakeTime, 1000 );
}
else
{
prvNewPrintString("Empty ",6);
break;
}
}
//vTaskDelayUntil( &xLastWakeTime, (1000/portTICK_RATE_MS) );
//prvNewPrintString(output_test,7);
vTaskDelayUntil( &xLastWakeTime, 1000 );
}
}
/**
* @brief EPS I2C Task
* @param argument: I2C's Handle
* @retval None
*/
static void I2C_2_Slave_Mode(void *argument)
{
I2C_HandleTypeDef* I2CHandle;
uint8_t priTransferDataBuffer[50];
uint8_t* default_string = "012345678996543210";
I2CHandle = (I2C_HandleTypeDef*) argument;
prvNewPrintString("EPS I2C Task\n",13);
for(;;)
{
//prvNewPrintString("Hello",5);
/*##-2- Slave receive request from master ################################*/
while(HAL_I2C_Slave_Receive_IT(I2CHandle, priTransferDataBuffer, TRANSFERBUFFERSIZE)!= HAL_OK)
vTaskDelay(1);
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it? busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(I2CHandle) != HAL_I2C_STATE_READY)
{
vTaskDelay(1);
//prvNewPrintString("Chuck",5);
}
if(priI2C_NewCommand_2==1)
{
priI2C_NewCommand_2 =0;
//get command number and command arguments from master device
I2C_transfer_slave_2.priCommand = priTransferDataBuffer[0];
I2C_transfer_slave_2.priRequestPtr = priTransferDataBuffer+1;
switch(I2C_transfer_slave_2.priCommand)
{
case 0x08:
I2C_transfer_slave_2.priErrorcode = 0;
//reply data
I2C_transfer_slave_2.priSizeofReply = 2+43;
priTransferDataBuffer[0] = I2C_transfer_slave_2.priCommand;
priTransferDataBuffer[1] = I2C_transfer_slave_2.priErrorcode;
memcpy( (void *)(priTransferDataBuffer+2), (void *)&hk_test, 43);
break;
case 0x09:
output_test.output_byte = *(I2C_transfer_slave_2.priRequestPtr);
//print result
//HAL_UART_Transmit(&UartHandle, &output_test, 1 , 1000);
/* Flush Tx/Rx buffers */
Flush_Buffer(priTransferDataBuffer,TRANSFERBUFFERSIZE);
break;
default:
priTransferDataBuffer[0] = 0xff;
priTransferDataBuffer[1] = 0xEE;
memcpy( (void *)(priTransferDataBuffer+2), (void *)default_string, 18);
}
}
}
}
/**
* @brief INMS I2C Task
* @param argument: I2C's Handle
* @retval None
*/
static void I2C_2_Slave_Mode(void *argument)
{
I2C_HandleTypeDef* I2CHandle;
uint8_t priTransferDataBuffer[TRANSFERBUFFERSIZE];
uint8_t* default_string = "012345678996543210";
I2CHandle = (I2C_HandleTypeDef*) argument;
prvNewPrintString("ADCS I2C Task\n",13);
for(;;)
{
//prvNewPrintString("Hello",5);
/*##-2- Slave receive request from master ################################*/
while(HAL_I2C_Slave_Receive_IT(I2CHandle, priTransferDataBuffer, TRANSFERBUFFERSIZE)!= HAL_OK)
vTaskDelay(1);
/* Before starting a new communication transfer, you need to check the current
state of the peripheral; if it? busy you need to wait for the end of current
transfer before starting a new one.
For simplicity reasons, this example is just waiting till the end of the
transfer, but application may perform other tasks while transfer operation
is ongoing. */
while (HAL_I2C_GetState(I2CHandle) != HAL_I2C_STATE_READY)
{
vTaskDelay(1);
}
if(priI2C_NewCommand_2==1)
{
priI2C_NewCommand_2 =0;
//get command number and command arguments from master device
I2C_transfer_slave_2.priCommand = priTransferDataBuffer[0];
I2C_transfer_slave_2.priRequestPtr = priTransferDataBuffer+1;
/* the format of register output to master device. It can call interface format of subsystm */
switch(I2C_transfer_slave_2.priCommand)
{
/* Channel 1 INMS 5V current*/
case 0xb0:
I2C_transfer_slave_2.priSizeofReply = 4;
memset(priTransferDataBuffer,I2C_transfer_slave_2.priCommand,TRANSFERBUFFERSIZE);
priTransferDataBuffer[0] = (ifb_test.IFB_5V_Current & 0xff00)>>8;
priTransferDataBuffer[1] = ifb_test.IFB_5V_Current & 0xff;
priTransferDataBuffer[2] = 0xff;
break;
/* Channel 0 INMS 3_3V current*/
case 0x90:
I2C_transfer_slave_2.priSizeofReply = 4;
memset(priTransferDataBuffer,I2C_transfer_slave_2.priCommand,TRANSFERBUFFERSIZE);
priTransferDataBuffer[0] = (ifb_test.IFB_3_3V_Current & 0xff00)>>8;
priTransferDataBuffer[1] = ifb_test.IFB_3_3V_Current & 0xff;
priTransferDataBuffer[2] = 0xff;
break;
/* Channel 2 INMS INMS temperature*/
case 0xd0:
I2C_transfer_slave_2.priSizeofReply = 4;
memset(priTransferDataBuffer,I2C_transfer_slave_2.priCommand,TRANSFERBUFFERSIZE);
priTransferDataBuffer[0] = (ifb_test.IFB_INMS_Temp & 0xff00)>>8;
priTransferDataBuffer[1] = ifb_test.IFB_INMS_Temp & 0xff;
priTransferDataBuffer[2] = 0xff;
break;
/* Channel 3 INMS INMS Interface Board temperature*/
case 0xf0:
I2C_transfer_slave_2.priSizeofReply = 4;
memset(priTransferDataBuffer,I2C_transfer_slave_2.priCommand,TRANSFERBUFFERSIZE);
priTransferDataBuffer[0] = (ifb_test.IFB_IFB_Temp & 0xff00)>>8;
priTransferDataBuffer[1] = ifb_test.IFB_IFB_Temp & 0xff;
priTransferDataBuffer[2] = 0xff;
break;
default:
/* send a default string to remind user*/
memcpy( (void *)(priTransferDataBuffer), (void *)default_string, 18);
}
}
}
