Semaphore in C++

[LUrba.1]

I have a problem with operating the traffic light from the class method - every time the program crashes at that point.

Here is a simplified example for understanding what I'm writing about:

Class:

class IO_control
{
int num;
 
public:
 osSemaphoreId semaphoreHandle;
 int *outputs; 
 IO_control(int num,int outputs,osSemaphoreId semaphoreHandle);
 virtual ~IO_control();
 
 void SetOutputs();
 void UnsetOutputs();
};
 
 
/***********************************************/
 
 
IO_control::IO_control(int num, int *outputs,osSemaphoreId semaphoreHandle)
{
 this->num = num;
 this->outputs = outputs;
 this->semaphoreHandle = semaphoreHandle;
}
 
IO_control::~IO_control(){}
 
void IO_control::SetOutputs()
{
 osSemaphoreWait(semaphoreHandle, osWaitForever);
 *outputs |= num;
 osSemaphoreRelease(semaphoreHandle);
}
 
void IO_control::UnsetOutputs()
{
 osSemaphoreWait(semaphoreHandle, osWaitForever);
 *outputs &= ~(num);
 osSemaphoreRelease(semaphoreHandle);
}

I have three tasks that fight over one variable i_o_CAN.data_out, specifically four instances of the class + sending a message

two set it - the third copies it to the CAN message

typedef struct can_I_O_struct
 {
 union
 {
 int data_out;
 uint8_t out_arr[4];
 };
 
 union
 {
 int data_in;
 uint8_t in_arr[4];
 };
 } I_O_struct_can;
 
 
 I_O_struct_can i_o_CAN;
 
 osSemaphoreId CAN_IO_semaphoreHandle;
 
 IO_control out1(1,&i_o_CAN.data_out,CAN_IO_semaphoreHandle);
 IO_control out2(2,&i_o_CAN.data_out,CAN_IO_semaphoreHandle);
 IO_control out3(3,&i_o_CAN.data_out,CAN_IO_semaphoreHandle);
 IO_control out4(4,&i_o_CAN.data_out,CAN_IO_semaphoreHandle);
 
 void Task01(void const * argument)
 {
 for(;;)
 {
 out1.SetOutputs();
 osDelay(50);
 out1.UnsetOutputs();
 osDelay(1000);
 out2.SetOutputs();
 osDelay(50);
 out2.UnsetOutputs();
 osDelay(1000);
 }
 }
 
 
 void Task02(void const * argument)
 {
 for(;;)
 {
 out3.SetOutputs();
 osDelay(50);
 out3.UnsetOutputs();
 osDelay(2000);
 out4.SetOutputs();
 osDelay(50);
 out4.UnsetOutputs();
 osDelay(2000);
 }
 }
 
 void TaskCAN_Tx(void const * argument)
 {
 int tmp = 0;
 TxHeader2.StdId = 0x180;
 TxHeader2.DLC = 4;
 for(;;)
 {
 osSemaphoreWait(CAN_IO_semaphoreHandle, osWaitForever);
 if (i_o_CAN.data_out != tmp)
 {
 tmp = i_o_regs_can.data_out;
 TxData2[0] = i_o_CAN.out_arr[0];
 TxData2[1] = i_o_CAN.out_arr[1];
 TxData2[2] = i_o_CAN.out_arr[2];
 TxData2[3] = i_o_CAN.out_arr[3]; 
 if (HAL_CAN_AddTxMessage (&hcan2, &TxHeader2, TxData2, &TxMailbox2)!= HAL_OK)
 {
 Error_Handler ();
 } 
 }
 osSemaphoreRelease(CAN_IO_semaphoreHandle);
 }
 }

when I adjust it so that I operate the traffic lights directly from the tasks, it works

void IO_control::SetOutputs()
{
 *outputs |= num;
}
 
void IO_control::UnsetOutputs()
{
 *outputs &= ~(num);
}
 
//////////////////////////////////////////////////////////////////////
 
 void Task01(void const * argument)
 {
 for(;;)
 {
 osSemaphoreWait(CAN_IO_semaphoreHandle, osWaitForever);
 out1.SetOutputs();
 osSemaphoreRelease(CAN_IO_semaphoreHandle);
 osDelay(50);
 osSemaphoreWait(CAN_IO_semaphoreHandle, osWaitForever);
 out1.UnsetOutputs();
 osSemaphoreRelease(CAN_IO_semaphoreHandle);
 osDelay(1000);
 osSemaphoreWait(CAN_IO_semaphoreHandle, osWaitForever);
 out2.SetOutputs();
 osSemaphoreRelease(CAN_IO_semaphoreHandle);
 osDelay(50);
 osSemaphoreWait(CAN_IO_semaphoreHandle, osWaitForever);
 out2.UnsetOutputs();
 osSemaphoreRelease(CAN_IO_semaphoreHandle);
 osDelay(1000);
 }
 }

but in reality it's not that simple and I need to access the traffic light from insatnaci - in addition, it's a lot of useless code

[Amel NASRI]

Hi @Luděk Urbani�?​ ,

Which product please?

-Amel

[LUrba.1]

STM32F205

but the problem is not related to hardware or freertos

I've found that it's a matter of C++ and bad passing of the reference to the class.

This is a functional solution:

class IO_control {
 int num;
 
 public:
 osSemaphoreId & semaphoreHandle;
 int * outputs;
 IO_control (int num, int * outputs, osSemaphoreId & semaphoreHandle);
 virtual ~IO_control();
 
 void SetOutputs();
 void UnsetOutputs();
};
/***********************************************/
IO_control::IO_control (int _num, int * _outputs, osSemaphoreId & _semaphoreHandle) :
 num(_num), semaphoreHandle(_semaphoreHandle), outputs(_outputs) {
}