Проблема с синхронизацией потоков Pthread

#include "otca.h"
 
//Подключение логики систем
//MAIN PANEL
#include "avionics/main_panel.h"
//TIME LOGIC
#include "avionics/time_logic.h"
 
//Переменные потоков систем
//TIME LOGIC
pthread_t time_logic_thread;
//MAIN PANEL
//acs
pthread_t main_panel_acs_thread;
 
void * OTCA_CORE_SIM(void * opaque){
    PROP_CYCLE CYCLE;
    sem_init(&CYCLE.core_semaphore, 0, 0);
    pthread_mutex_init(&CYCLE.cycle_mutex, NULL);
    pthread_cond_init(&CYCLE.cycle_condition, NULL);
    OTCA_CORE_STRUCT *OTCA_CORE_DATA = (OTCA_CORE_STRUCT*)opaque;
 
    //запуск систем
    //TIME LOGIC
    pthread_create(&time_logic_thread, NULL, time_logic_update, (void *) &CYCLE);
    //MAIN PANEL
    //acs
    pthread_create(&main_panel_acs_thread, NULL, main_panel_acs_update, (void *) &CYCLE);
 
    CYCLE.all_operations = 2;
 
    while (OTCA_INIT_SIM_RUN == 1) {
        //Подготовка отсчета времени цикла
        clock_t cycle_start = clock();
 
        CYCLE.current_opperation = 0;
 
        fprintf(stdout, "### Sim Cycle Started ###\n\n");
 
        //Выдача разрешений на выполнение
        //TIME LOGIC
        time_logic_run();
        time_logic_passed(); //Функция ожидающая прохождения time_logic
        //MAIN PANEL
        //acs
        main_panel_acs_run();
 
        fprintf(stdout, "-- Sim Systems Run --\n");
        //Ожидание завершения симуляции
        sem_wait(&CYCLE.core_semaphore);
        //OTCA_SYSTEM_WAIT();
        //while (1) {
            //pthread_mutex_lock(&CYCLE.cycle_mutex);
            //pthread_cond_wait(&CYCLE.cycle_condition, &CYCLE.cycle_mutex);
            //fprintf(stdout, "-- Here I am and %d\n", CYCLE.current_opperation);
            //pthread_mutex_unlock(&CYCLE.cycle_mutex);
            //break;
        //}
 
        //Подсчет времени обработки симуляции
        OTCA_CORE_DATA->cycle_time = (double)(clock() - cycle_start) / CLOCKS_PER_SEC;
 
        //Ожидание конца симуляции
        Sleep((uint32_t)((OTCA_INIT_SIM_PERIOD - OTCA_CORE_DATA->cycle_time) * 1000));
        fprintf(stdout, "\n### Sim Cycle Passed ###\n\n");
 
    }
 
    //Выгрузка потоков систем
    //TIME LOGIC
    pthread_detach(time_logic_thread);
    //MAIN PANEL
    //acs
    pthread_detach(main_panel_acs_thread);
 
    pthread_cond_destroy(&CYCLE.cycle_condition);
    pthread_mutex_destroy(&CYCLE.cycle_mutex);
 
    return NULL;
}

#include <semaphore.h>
 
#include "otca/properties.h"
#include "otca/functions.h"
 
#include "time_logic.h"
 
//time_logic
sem_t time_logic_work; //разрешающий семафор
sem_t time_logic_wait; //блокирующий семафор
void time_logic_run() {
    sem_post(&time_logic_work);
}
void * time_logic_update(void * opaque) {
    PROP_CYCLE *CYCLE = (PROP_CYCLE*)opaque;
    sem_init(&time_logic_work, 0, 0);
    sem_init(&time_logic_wait, 0, 0);
 
    double time_last = SIM_TIME.total_running_time_sec; // time for previous frame
    double last_m = FLIGHTMODEL_POSITION.M;
 
    while (OTCA_INIT_SIM_RUN) {
        sem_wait(&time_logic_work);
 
        //time calculations
        double time_now = SIM_TIME.total_running_time_sec;
            double passed = fabs(time_now - time_last);
            double curent_m = FLIGHTMODEL_POSITION.M;
            //print(passed)
            if (curent_m - last_m == 0) {
                passed = 0;
            }
            if (passed > 0.1) {
                passed = 0.1;
            }
 
            //TIME.frame_time = passed;
 
            //last variables
            time_last = time_now;
            //last_m = curent_m
 
        fprintf(stdout, "Time logic Passed\n");
        pthread_mutex_lock(&CYCLE->cycle_mutex);
        CYCLE->current_opperation = CYCLE->current_opperation + 1;
        fprintf(stdout, "Time logic data = %d\n",CYCLE->current_opperation);
        if (CYCLE->current_opperation == CYCLE->all_operations) {
            pthread_cond_broadcast(&CYCLE->cycle_condition);
        }
        pthread_mutex_unlock(&CYCLE->cycle_mutex);
        sem_post(&time_logic_wait);
    }
    sem_destroy(&time_logic_work);
    sem_destroy(&time_logic_wait);
    return NULL;
}
void time_logic_passed() {
    sem_wait(&time_logic_wait);
}

#include <semaphore.h>
 
#include "otca/properties.h"
#include "otca/functions.h"
 
#include "main_panel.h"
 
//acs
sem_t main_panel_acs_work; //разрешающий семафор
sem_t main_panel_acs_wait; //блокирующий семафор
void main_panel_acs_run() {
     sem_post(&main_panel_acs_work);
}
void * main_panel_acs_update(void * opaque) {
    PROP_CYCLE *CYCLE = (PROP_CYCLE*)opaque;
    sem_init(&main_panel_acs_work, 0, 0);
    sem_init(&main_panel_acs_wait, 0, 0);
 
    uint8_t sec_mode[] = {0, 0, 0}; // chrono mode. 0 - reset, 1 - run, 2 - hold
 
    double chrono_sec_angle[] = {0, 0, 0}; // chrono sec needle
    double chrono_min_angle[] = {0, 0, 0}; // chrono min needle
    double sec_time[] = {0, 0, 0}; // chrono counter
    double start_sec[] = {0, 0, 0}; //time, when chrono started
 
    //flight timer variables
    double flight_mode[] = {0, 0, 0};
    double flight_time[] = {0, 0, 0};
    double flight_hour_angle[] = {0, 0, 0};
    double flight_min_angle[] = {0, 0, 0};
    double start_flight[] = {0, 0, 0};
 
    uint8_t knob_last = 0;
 
    while (OTCA_INIT_SIM_RUN) {
        sem_wait(&main_panel_acs_work);
 
        //Тут просто логика симуляции, с ней проблем нет
 
        fprintf(stdout, "ACS Logic Passed\n");
        //pthread_mutex_lock(&CYCLE->cycle_mutex);
        CYCLE->current_opperation = CYCLE->current_opperation + 1;
        fprintf(stdout, "ACS data = %d\n",CYCLE->current_opperation);
        if (CYCLE->current_opperation == CYCLE->all_operations) {
            fprintf(stdout, "HAPPY WORK = %d\n",CYCLE->current_opperation);
            sem_post(&CYCLE->core_semaphore);
 
        }
        //pthread_mutex_unlock(&CYCLE->cycle_mutex);
        sem_post(&main_panel_acs_wait);
    }
    sem_destroy(&main_panel_acs_wait);
    sem_destroy(&main_panel_acs_work);
    return NULL;
}
void main_panel_acs_passed() {
    sem_wait(&main_panel_acs_wait);
}

typedef struct PROP_CYCLE {
        int current_opperation;
        int all_operations;
        sem_t core_semaphore;
        pthread_mutex_t cycle_mutex;
        pthread_cond_t cycle_condition;
    } PROP_CYCLE;

void main_panel_init() {
    sem_init(&main_panel_acs_work, 0, 0);
    sem_init(&main_panel_acs_wait, 0, 0);
}

//Функция запуска симуляции
void OTCA_INIT_SIM_START() {
    //Установка переменной управления потоком
    OTCA_INIT_SIM_RUN = 1;
    //Установка переменной периода симуляции
    OTCA_INIT_SIM_PERIOD = 0.02;
    //Инициализация компонентов
    OTCA_INIT_PROP_COMP();
    //Инициализация семафоров
    time_logic_init();
    main_panel_init();
    //Запуск потока core
    pthread_create(&core_thread, NULL, OTCA_CORE_SIM, (void *) &OTCA_CORE_DATA);
}