====== 12. Cvičení: Práce na projektu ======

Obsahem cvičení je samostatná práce na projektu a konzultace (projektu, témat z přednášek...).

<note important>Studenti z probíhajícího cvičení mají přednostní přístup k deskám.</note>

===== Ukázková kód použití vláken =====


  * Ukázkový kód využívající posix threads pro vícevláknovou aplikaci. Ukazuje možné rozdělení projektu do vláken
    * ''main'' - hlavní vlákno
    * ''input_thread'' - vstupní vlákno
    * ''output_thread'' - výstupní vlákno
    * V tomto případě je vykreslování na LCD realizováno kontinuelně a ne on-demand. Variant řešení je samozřejmě více. Template si klade za cíl hlavně ukázat práci s posixovými vlákny.
    * <code bash>
#define _POSIX_C_SOURCE 200112L

#include <stdlib.h>
#include <stdio.h>
#include <stdint.h>
#include <time.h>
#include <unistd.h>
#include <stdbool.h>

#include <pthread.h>

#include "mzapo_parlcd.h"
#include "mzapo_phys.h"
#include "mzapo_regs.h"
#include "serialize_lock.h"

#define IMG_SIZE 320*480

//type definition of struct for shared data between threads
typedef struct { 
  bool quit;
  unsigned char *parlcd_mem_base;
  uint16_t * fb_read;
  uint16_t * fb_write;
} data_t;

void * input_thread(void * data);
void * output_thread(void * data);

//mutexes for double buffering of frames
pthread_mutex_t mtx_fb; 

int main(int argc, char *argv[])
{

  // Serialize execution of applications
  // Try to acquire lock the first 
  if (serialize_lock(1) <= 0) {
    printf("System is occupied\n");

    if (1) {
      printf("Waiting\n");
      // Wait till application holding lock releases it or exits
      serialize_lock(0);
    }
  }

  printf("Hello world\n");

  //initialize the two frame buffers
  uint16_t fb0[IMG_SIZE]; 
  uint16_t fb1[IMG_SIZE]; 

  //initialize the shared data
  data_t shared_data;
  shared_data.quit = false;
  shared_data.fb_read = &fb0;
  shared_data.fb_write = &fb1;

  //map the memory
  shared_data.parlcd_mem_base = map_phys_address(PARLCD_REG_BASE_PHYS, PARLCD_REG_SIZE, 0);
  if (shared_data.parlcd_mem_base == NULL){
    exit(1);
  }

  //prepare the threads
  enum {INPUT, OUTPUT, NUM_THREADS};
  const char *thread_names[] = {"input", "output"}; 
  void* (*thread_functions[])(void *) = {input_thread, output_thread};

  //initialize the threads and mutex
  pthread_t threads[NUM_THREADS];
  pthread_mutex_init(&mtx_fb, NULL);

  //spawn the threads
  for (int i = 0; i < NUM_THREADS; ++i){
    int res = pthread_create(&threads[i], NULL, thread_functions[i], &shared_data);
    fprintf(stdout, "INFO: Create thread '%s' %s\n", thread_names[i], (res == 0 ? "OK" : "FAIL") );
    //TODO:correctly exit if some thread does not initialize
  }

  //main loop
  uint16_t color = 0x0000;

  while(!shared_data.quit){
    //simulate some long calculations 
    usleep(10000);

    //write the frame buffer
    for (int i = 0; i < IMG_SIZE; i++) {
      //write to the write buffer     
      shared_data.fb_write[i] = color;
    }
    color+=1;
    
    //swap the buffers - first need to acquire the mutex for write read buffer
    pthread_mutex_lock(&mtx_fb);
    //..now swap them
    uint16_t * tmp = shared_data.fb_read;
    shared_data.fb_read = shared_data.fb_write;
    shared_data.fb_write = tmp;
    //..and unlock the read buffer for display
    pthread_mutex_unlock(&mtx_fb);

  }
  shared_data.quit = true;

  //joining the threads
  for (int i = 0; i < NUM_THREADS; ++i) {
      fprintf(stdout, "INFO: Call join to the thread %s\n", thread_names[i]);
      int r = pthread_join(threads[i], NULL);
      fprintf(stdout, "INFO: Joining the thread %s has been %s\n", thread_names[i], (r == 0 ? "OK" : "FAIL"));
   }

  printf("Goodbye world\n");

  // Release the lock 
  serialize_unlock();

  return 0;
}


//------------------------------------------------------------
void * input_thread(void * data){
  data_t * shared_data = (data_t *) data;
  
  while(!shared_data->quit){
    //TODO: sample the input once in a while
    char c = getchar();
    if (c == 'q'){
      shared_data->quit = true;
    }
    
    //sleep for some time
    usleep(10000);
  }
}

//------------------------------------------------------------
void * output_thread(void * data){
  data_t * shared_data = (data_t *) data;

  //initialize the display
  parlcd_hx8357_init(shared_data->parlcd_mem_base);

  uint16_t fb_p = NULL;
  //draw in infinite loop
  while(!shared_data->quit){

    //lock the output frame buffer so no one can write into it
    pthread_mutex_lock(&mtx_fb);
    //reset the cursor
    parlcd_write_cmd(shared_data->parlcd_mem_base, 0x2c);
    //write the buffer
    for (int i = 0; i < IMG_SIZE; ++i) {
        parlcd_write_data(
          shared_data->parlcd_mem_base, shared_data->fb_read[i]);
    }
    //unlock the buffer 
    pthread_mutex_unlock(&mtx_fb);

    //sleep for some time
    usleep(10000);
  }
}
</code>