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…).

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

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.
    • #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);
        }
      }
courses/b35apo/tutorials/12/start.txt · Last modified: 2024/02/02 18:41 (external edit)