Software implementation of an oscillator in C - c

Question

I have been developing a control software in C language. I have decided to spent
some time with development general function blocks usable in other programs which I will develop in future (some type of library). My software is divided into two main parts from application point of view. One part is the control part
(PI controller, modulator, phase locked loop etc.) and the second one is logic
part (finite state machine of the application etc.). The logic part works with logic signals. These signals are procesed by software implementation of logic gates and flip-flops. My goal is to also implement some software version of an oscillator. I mean some function block which is able to produce oscillations between 0 and 1 with prescribed period and duty cycle at its output. In principle I can have several such oscillators in one program. So I have
decided to implement the oscillator in following manner. The oscillations production is done by a function and each instance of the oscillator is implemented by an instance of previously defined structure. The structure contains as main items the oscillations period, duty cycle and oscillator execution period i.e. execution period of the RTOS task in which the instance of the oscillator is placed. Based on the oscillations period and task execution period produces the oscillator function the oscillations
void OSC(uint32_t output, Osc_t *p){
// p->T is the task execution period in ms
// p->period is the desired oscillations period in ms
// p->counter is the internal state of the oscillator
p->delay_count = (uint16_t)((p->period)/(2*p->T));
if(++(p->counter) >= p->delay_count){
p->counter = 0;
NegLogicSignal(output);
}
}
}
Below is the structure which contains the state of individual oscillator instances
typedef struct{
float period; // period of the oscillations (ms)
float T; // function execution period (ms)
uint16_t counter; // initial number of execution periods
uint16_t delay_count; // number of execution periods corresponding to half
// period
}Osc_t;
and the usage of oscillator function is following
Debug_LED_Oscillator_state.T = 1; // T = 1 ms
Debug_LED_Oscillator_state.period = 500; // period 0.5 s = 500 ms
OSC(LDbgLedOsc, &Debug_LED_Oscillator_state);
My problem is that I had to place one of my oscillators in the fastest task (task with execution period 1 ms)
because I wasn't able to achieve the period 500 ms (half period 250 ms) in another tasks because the rest of my tasks have inapproprite execution periods for 500 ms (20 ms and 100 ms i.e. 250/20 = 12.5 - not an integer value and 250/100 = 2.5 - also not an integer value). The problem is that I have the rest of application logic in another task.
The intended use is to produce logic signal for LEDs blinking pattern. The problem is that I had to move the oscillator to logically different task only because I am not able to achieve desired timing accuracy in the logicaly appropriate task (because of non integer values of the quotient half_period/execution_period). I am thinking about different implementation which enables place the oscillator to logicaly appropriate task and achieve the desired timing accuracy.
I have thought following solution. I will define set of global variables (uint16_t Timer_1ms, uint16_t Timer_5ms etc.). These global variables will be incremented in highest priority task (in my case Task_1ms). I will redefine OSC function
void OSC(uint32_t output, Osc_t *p){
float act_time;
taskENTER_CRITICAL();
switch(p->timer_type){
case TMR_1MS:
act_time = Timer_1ms;
break;
case TMR_5MS:
act_time = Timer_5ms;
break;
}
taskEXIT_CRITICAL();
if(p->init){
SetLogicSignal(output);
switch(p->timer_type){
case TMR_1MS:
p->delta = ((p->period)/(2*1*p->T));
break;
case TMR_5MS:
p->delta = ((p->period)/(2*5*p->T));
break;
}
p->stop_time = (act_time + p->delta);
p->init = FALSE;
}
if(act_time >= (p->stop_time)){
NegLogicSignal(output);
p->stop_time = (act_time + p->delta);
}
}
and oscillator structure
// oscillator state
typedef struct{
float period; // period of the oscillations (ms)
float T; // function execution period (ms)
float delta; // half_period in timer counts
float stop_time; // timer counts when to negate the output
BOOL init; // force initialization of the timer
timer_e timer_type;
}Osc_t;
I have tried this solution and it seems to be not functional. Does anybody have an idea why? Thanks in advance for any sugestions.

Answer 1

Threads of RTOS are very useful when you perform tasks with soft deadline. Soft deadline means that if the execution delays the system will not fail. In your case, the oscillator has a hard deadline e.g. if the duty cycle of PWM is not precise and stable the motor will not be having the desirable constant angular velocity. In this case you have to use the available Timer/Counter peripheral of the MCU.
You can set a timer to interrupt the CPU on a given interval and toggle the output in the ISR (Interrupt Service Routine). Using this approach the load of time-counting is moved from the CPU to the timer peripheral, allowing both precise oscillating output and smooth execution of other tasks.
You do not make clear which RTOS or MCU/CPU you are using, but all of them have timer/counter peripherals. If not supported directly from the RTOS, look in the CPU vendor datasheet.