#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);
}
}