---

#define _POSIX_C_SOURCE 200112L
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#include <time.h>
#include <string.h>
#include <stdatomic.h>

//gcc -std=c11 -pthread dfa1.c  -std=gnu99 -o timer_fsm

static int state = 0;
sem_t tick_sem;
sem_t ack_sem;
atomic_int running = 1;

// Состояния автомата (остатки от деления на 3)
typedef enum {
    REM_0 = 0,  // Число делится на 3
    REM_1 = 1,  // Остаток 1
    REM_2 = 2  // Остаток 2
} MState;

// a. Функция перехода автомата
MState transition(MState current, char bit) {
    // Если бит передан как символ '0' или '1', преобразуем в число 0 или 1
    int b = (bit == '1') ? 1 : 0;
    // Главное правило: (старый_остаток * 2 + новый_бит) % 3
    int next_remainder = (current * 2 + b) % 3;
    return (MState)next_remainder;
}
// a. Функция перехода автомата проверки деления на 3
MState dispatcher_tick(const char* input, int i, int length, MState current_state) {
    char bit = input[i];
    if (i <= length){
    return transition(current_state, bit);
    } else {
      return  bit;
    }   
}

// a. Функция перехода автомата проверки деления на 3
MState call_dispatcher_tick(const char* input, MState current_state, MState current_state_R) {
  int length = strlen(input);
  current_state = current_state - 1;

  if ((current_state >= length) && (current_state_R == REM_0)) {
      // Основание 2 означает двоичную систему
      char* endptr;
      unsigned long long decimal_value = strtoull(input, &endptr, 2);
      printf("Утверждение: Число %lld ДЕЛИТСЯ на 3.\n",  decimal_value);
      return -1;
  } else if  ((current_state > length) && (current_state_R != REM_0)) {
      char* endptr;
      unsigned long long decimal_value = strtoull(input, &endptr, 2);                   
      printf("Утверждение: Число %%lld НЕ делится на 3 (остаток %d).\n", decimal_value, current_state_R);
      return -1;
  }
  return dispatcher_tick(input, (current_state - 1), length, current_state_R);
}

void* thread1(void* arg) {
    long long interval_ms = *(long long*)arg;
   
    while (1) {
        // Ожидание интервала
        struct timespec start;
        clock_gettime(CLOCK_MONOTONIC, &start);
        long long target_ns = (long long)start.tv_sec * 1000000000LL +
                            start.tv_nsec + interval_ms * 1000000LL;
       
        struct timespec target;
        target.tv_sec = target_ns / 1000000000LL;
        target.tv_nsec = target_ns % 1000000000LL;
       
        clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &target, NULL);
       
        // Такт
        state++;
        printf("Такт %d\n", state);

        // Ожидание с таймаутом
        struct timespec ts_wait;
        clock_gettime(CLOCK_REALTIME, &ts_wait);
        ts_wait.tv_sec += 1;
       
        if (sem_timedwait(&ack_sem, &ts_wait) != 0) {
            // Таймаут - возможно, поток 2 уже завершился
            if (!atomic_load(&running)) break;
        }
        sem_post(&tick_sem);
 
    }
    return NULL;
}

void* thread2(void* arg) {
    int last_state = -1;
    MState current_state_R = REM_0;
    // Входная последовательность
    const char* input = "10010100000001111001110011010001101001000010101010101010101";   
    while (1) {
        sem_wait(&tick_sem);
        if (state != last_state) {
            printf("Поток 2 обработал такт %d\n", state);
                    current_state_R = call_dispatcher_tick(input, state, current_state_R);
                  if (current_state_R == (-1)) {
                    printf("Поток 2 завершается: достигнут конец строки\n");
                    atomic_store(&running, 0);
                    sem_post(&ack_sem);
                    break;
                }
            last_state = state;
        }
        sem_post(&ack_sem);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    long long interval = 150;
    struct timespec start, end;
    // Фиксируем реальное время (TIME_UTC)
    clock_gettime(CLOCK_MONOTONIC, &start);
        long long begin_ns = (long long)start.tv_sec * 1000000000LL +
                            start.tv_nsec + interval * 1000000LL;
   
    sem_init(&tick_sem, 0, 0);
    sem_init(&ack_sem, 0, 0);
   
    pthread_create(&t1, NULL, thread1, &interval);
    pthread_create(&t2, NULL, thread2, NULL);
   
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
       
    sem_destroy(&tick_sem);
    sem_destroy(&ack_sem);

    pthread_cancel(t1);
    pthread_cancel(t2);

    clock_gettime(CLOCK_MONOTONIC, &start);
        long long end_ns = (long long)start.tv_sec * 1000000000LL +
                            start.tv_nsec + interval * 1000000LL;

    // Считаем разницу
    double elapsed = end_ns - begin_ns;
    printf("Реальное время: %.9f сек\n", elapsed);
   
    return 0;
}

---