/*
Consider you are in and industry and you are working on a flow line where you have 3 Tasks.
Task 1, Task 2, Task 3.

Task 1 takes 5s to complete.
Task 2 takes 15s to complete.
Task 3 takes 10s to complete.

You have to include a counter so that whenever the task is completed, counter is incremented.
Each task should be completed 10 times.

Consider that the product from these three tasks have to be combined together, so it is mandatory that all the tasks are completed at the same time, so we dont have any idle time.

Also, after 10 products, a batch is completed. So, indicate the batch completion with an LED. You have to complete 3 batches, so indicate this with 3 separate LEDs.

You have to include a real time clock, along with this, the start time and end time of each batch should also be noted. Also, the start and end time of each task should also be noted and displayed.

A stopwatch should also be included in the project to view the time of tasks.

1 ->implement task to complete

add tasks that take time
5 sec
15 sec
10 sec

2->when one task completed a counter increments
each task count upto 10, i.e each task must be iterated/ completed 10 times

3->when task 1 task 2 and task 3 reaches 10 return a batch
when each task increments 10-> return a batch completed after every task complete by LED1,2,3
when all led blink or every task increment 10/completed 10 times, blink another led4

4->include a real time clock to note start and end time of each batch

5->include a stopwatch to view time of every task(time to complete)

*/

//choose core of the esp32
#include <RTClib.h>

RTC_DS1307 rtc; //creating object of rtc
  DateTime start_time_task1;
  DateTime end_time_task1;
  DateTime start_time_task2;
  DateTime end_time_task2;
  DateTime start_time_task3;
  DateTime end_time_task3;

#if CONFIG_FREERTOS_UNICORE
static const BaseType_t app_cpu=0;
#else 
static const BaseType_t app_cpu=1;
#endif
#define no_of_batches 3
#define Products_in_a_batch 10

//define time for each task
#define task1_t 1000
#define task2_t 3000
#define task3_t 2000

// initialize pins to indicate task completion
static const int led_pin1=0;
static const int led_pin2=2;
static const int led_pin3=15;
static const int led_pin4=4;

//initialize counters to count each task completion
int counter1=0;
int counter2=0;
int counter3=0;
int product=0;
int batch_counter=0;

// initialize task handles
static TaskHandle_t task_1= NULL ;
static TaskHandle_t task_2= NULL ;
static TaskHandle_t task_3= NULL ;

//funciton for task 1
void startTask1(void *parameter)
{
  
  while(1){
    counter1++;
    start_time_task1 = rtc.now();


  vTaskDelay( task1_t/ portTICK_PERIOD_MS);
  
  if (counter1 % Products_in_a_batch==0) // when batch of 10 completes led pin will set to high
  {
    end_time_task1 = rtc.now();

        Serial.print("ST T1: ");
        Serial.println(start_time_task1.timestamp());
        Serial.print("ET T1: ");
        Serial.println(end_time_task1.timestamp());
        Serial.println("Task 1 batch completed");
        digitalWrite(led_pin1, HIGH);
        vTaskDelay( 500/ portTICK_PERIOD_MS);
        digitalWrite(led_pin1, LOW);


  }
  }
}

void startTask2(void *parameter){
  
 while(1){
  counter2++;
  start_time_task2 = rtc.now();
  
 vTaskDelay( task2_t/ portTICK_PERIOD_MS);
 
 if (counter2 % Products_in_a_batch==0){
  end_time_task2 = rtc.now();

        Serial.print("ST T2: ");
        Serial.println(start_time_task2.timestamp());
        Serial.print("ET T2: ");
        Serial.println(end_time_task2.timestamp());
        Serial.println("Task 2 batch completed");
        digitalWrite(led_pin2, HIGH);
        vTaskDelay( 500/ portTICK_PERIOD_MS);
        digitalWrite(led_pin2, LOW);

  }
}
}

void startTask3(void *parameter){
  
  while(1){
    counter3++;
    start_time_task3 = rtc.now();
 vTaskDelay( task3_t/ portTICK_PERIOD_MS);

 
 if (counter3 % Products_in_a_batch==0){
 end_time_task3 = rtc.now();

        Serial.print("ST T3: ");
        Serial.println(start_time_task3.timestamp());
        Serial.print("ET T3: ");
        Serial.println(end_time_task3.timestamp());
        Serial.println("Task 3 batch completed");
        digitalWrite(led_pin3, HIGH);
        vTaskDelay( 500/ portTICK_PERIOD_MS);
        digitalWrite(led_pin3, LOW);;
  }

 }
}

void setup() {
  Serial.begin(9600);

  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    Serial.flush();
    abort();
  }

  pinMode(led_pin1, OUTPUT);
  pinMode(led_pin2, OUTPUT);
  pinMode(led_pin3, OUTPUT);
  pinMode(led_pin4, OUTPUT);
    xTaskCreatePinnedToCore( startTask1,
                                "task 1",
                                2000,
                                NULL,
                                1,
                                &task_1,
                                app_cpu);

    xTaskCreatePinnedToCore( startTask2,
                              "task 2",
                              2000,
                              NULL,
                              2,
                              &task_2,
                              app_cpu);

    xTaskCreatePinnedToCore( startTask3,
                              "task 3",
                              2000,
                              NULL,
                              3,
                              &task_3,
                              app_cpu);

 }


void loop() {
if (counter1==counter2==counter3)
{
  product++;
  Serial.println(product);
}
  if (product % Products_in_a_batch==0 )
{
batch_counter++;
if (batch_counter==3)
{
digitalWrite(led_pin4 , HIGH);

    digitalWrite(led_pin1, LOW);
    digitalWrite(led_pin2, LOW);
    digitalWrite(led_pin3, LOW);
    digitalWrite(led_pin4, LOW);
    
    // Reset task counters for the next batch
    counter1 = 0;
    counter2 = 0;
    counter3 = 0;
}
  }

  delay(1000); // Check every second
}