Diff: main.cpp

Revision:

1:4cd93767691a

Parent:

0:4a8b751dbe7c

Child:

2:c5fb78148ccc

--- a/main.cpp	Mon May 02 15:26:28 2016 +0000
+++ b/main.cpp	Tue May 03 10:39:27 2016 +0000
@@ -1,6 +1,6 @@
 #include <stdlib.h>
-#include <pthread.h>
-#include <semaphore.h>
+//#include <pthread.h>
+//#include <semaphore.h>
 #include "buffer.h"
 
 #include "mbed.h"
@@ -26,36 +26,37 @@
 static TempSensor *temp_sensor1 = mems_expansion_board->ht_sensor;
 static TempSensor *temp_sensor2 = mems_expansion_board->pt_sensor;
 
-typedf int buffer_item;
-#define BUFFER_SIZE 75
+/*
+/ this is will make sure the contant valid of how much data will be sorted or not as this
+/could help when the data range.
+*/
+const int amountOfSample = 150;
+
+
+const int BUFFER_SIZE = 75;
 
 // mutex lock
-pthread_mutex_t mutex;
+Mutex *bufferLock;
 
-//semaphores
-sem_t full, empty;
+
 
 //buffer
-buffer_item buffer[BUFFER_SIZE];
+char buffer_item[BUFFER_SIZE][200];
 
-//buffer counter
-int counter;
 
-pthread_t tid; //thread id
+Thread  tid; //thread id
 pthread_attr_t attr; //set of thread attributes
 
 void *producer(void *param); //producer thread
 void *consumer(void *param); //consumer thread
 
-volatile  char memorySample[150][200];
+
+
+volatile char memorySample[amountOfSample][200];
 
 char values[20][20];
 
-/*
-/ this is will make sure the contant valid of how much data will be sorted or not as this
-/could help when the data range.
-*/
-int amountOfSample = 150;
+
 
 
 uint8_t id;
@@ -254,12 +255,20 @@
         int getBufferStartPointer (void)
         {
              return bufferStartPointer;
+             key = 1;
         } 
         void setBufferStartPointer (int newBufferStartPointer ){
             
             bufferStartPointer = newBufferStartPointer;
             
-        }       
+        } 
+        void plusOne(void){ 
+            if(bufferStartPointer + 1 == BUFFER_SIZE){
+                bufferStartPointer = 0;
+            }else{
+                bufferStartPointer = bufferStartPointer + 1;
+                }
+        }    
 };
 
 
@@ -271,6 +280,7 @@
         */
         int bufferEndPointer;
         
+        
         BufferEndPointer(){
             bufferEndPointer = 0;
         }
@@ -283,7 +293,61 @@
             
             bufferEndPointer = newBufferEndPointer;
             
-        }       
+        } 
+        
+          void plusOne(void){ 
+            if(bufferEndPointer + 1 == BUFFER_SIZE){
+                bufferEndPointer = 0;
+            }else{
+                bufferEndPointer = bufferEndPointer + 1;
+                }
+        }        
+};
+
+class BufferSize: public KeyLocks
+{
+    
+    public:
+            int bufferSize;
+            Semaphore *EmptyBuffer;
+            Semaphore *fullBuffer;
+            
+            BufferSize(){
+                EmptyBuffer = new Semaphore(0);
+                sapceAvailable = new Semaphore(BUFFER_SIZE);
+                bufferSize = 0;
+                
+            }
+            
+            void increaseBufferSize(){
+                bufferSize = bufferSize + 1;
+            }
+            
+            void deincreaseBufferSize(){
+                bufferSize = bufferSize - 1;
+            }
+            
+            int getBufferSize(){
+                return bufferSize;
+            }
+            
+            int getEmptyBuffer(){
+                return EmptyBuffer -> wait();
+            }
+            
+            int getFullBuffer(){
+                return fullBuffer -> wait();
+            }
+            
+            void releaseEmptyBuffer(){
+                return EmptyBuffer -> release();
+            }
+            
+            void releaseFullBuffer(){
+                return fullBuffer -> release();
+            }
+    
+    
 };
 
 void initialiseBufferData(){
@@ -304,95 +368,39 @@
 }
 
 //producer thread
-void *producer(void *param){
-   buffer_item item;
+void *producer(char newItem[], BufferEndPointer *endPointer, BufferSize *bufferSize){
+   
+   while(!bufferSize->lock()){};
    
-   while(TRUE){
+   int size = bufferSize -> getBufferSize();
+   
+   while(size < BUFFER_SIZE){
        //sleep for random amount of time
-       int rNum = rand() / RAND_DIVISOR;
-       sleep(rNum);
-       
-       //generate random number
-       item = rand();
        
-       //get empty lock
-       sem_wait(&empty);
-       //get mutex lock
-       pthread_mutex_lock(&mutex);
+       //get the buffer
+       bufferLock->lock(); 
+
+           
+        while(!endPointer->lock()){};
        
-       if(insert_item(item)){
-           fprint(stderr, "Producer report error condition\n");
-        }
-        else{
-            printf("producer produced %d\n", item);
-        }
-        //release mutex lock
-        pthread_mutex_unlock(&mutex);
-        //signal full
-        sem_post(&full);
+        endPointer->plusOne();
+        buffer_item[endPointer->getBufferEndPointer()] = newItem[];
+        endPointer->unlock();
+        bufferLock->unlock();
+        while(!bufferSize->lock()){};
+        bufferSize ->increaseBufferSize();
+        size = bufferSize -> getBufferSize();       
+           
+        
     }
 }
 
 //consumer thread
-void *consumer(void {
-   buffer_item item;
+void *consumer(void *param) {
    
-   while(TRUE){
-       //sleep for random amount of time
-       int rNum = rand() / RAND_DIVISOR;
-       sleep(rNum);
-       
-       //get full lock
-       sem_wait(&full);
-       //get mutex lock
-       pthread_mutex_lock(&mutex);
-       if(remove_item(&item)){
-           fprint(stderr, "Consumer report error condition\n");
-        }
-        else{
-            printf("Consumer consumer %d\n", item);
-        }
-        
-        //release mutex ock
-        pthread_mutex_unlock(&mutex);
-        //signal empty
-        sem_post(&empty);
-    }
+  
 }
 
-//add item to buffer
-int insert_item(buffer_item item) {
-    //when buffer not full add item and increase counter
-    if(counter < BUFFER_SIZE){
-        buffer[counter] = item;
-        counter++
-        return 0;
-    }
-    else{ //buffer full error
-        return -1
-    }
-}
-
-//remove item from buffer
-int remove_item(buffer_item *item){
-    //when buffer not empty remove item and decrease counter
-    if(counter > 0){
-        *item = buffer[(counter-1)];
-        counter--;
-        return 0;
-    }
-    else{ //empty buffer error
-        return -1;
-    }
-}
-
-
-
-   
-    
-
-
-
 //this is setting all the function for the treads in the program
 
 
@@ -736,6 +744,7 @@
     SampleDisplay sampleDisplay = SampleDisplay();
     BufferStartPointer bufferStartPointer = BufferStartPointer();
     BufferEndPointer bufferEndPointer = BufferEndPointer();
+    bufferLock = new Mutex();
     
     
     while(1) {