Added a spinlock semaphore for resource sharing

coder137 · coder137 · commit 8187d8f25630 · 2021-01-04T01:30:32.000-08:00
- Added image of the spinlock semaphore
- In osSemaphoreWait we burn CPU cycles when signal has not been received
- Updated main.c with semaphore example
diff --git a/Semaphore/README.md b/Semaphore/README.md
@@ -8,14 +8,22 @@
 
 ![No Semphore for UART](images/example1_no_semaphore.PNG)
 
-- In the above example we are writing data to the UART from thread 1 and thread 2
+- In this example we are writing data to the UART from thread 1 and thread 2
 - As you can see in the image above when writing to the UART Task1/Task2 might be pre-empted before the entire data can be written to the UART
 - The above problem of shared resources can be solved using Semaphores
 - Semaphores are essentially signals that can signal certain parts of the code when something is done/needs to be done.
 
 # Spinlock Semaphore
 
-> TODO,
+- Wait for a signal to be raised to gain access to a shared resource
+- During a **wait** this shared resource burns CPU cycles till it gets a signal from another thread.
+
+![Spinlock Semaphore for UART](images/example2_spinlock_semaphore.PNG)
+
+- In this example since UART is a common resource between the thread1 and thread2 we use a form of communication between the two threads
+- When the first thread has access to the UART the second thread is in the **wait** state (semaphore value is 0)
+- Once the first thread is done writing data to the UART it gives a **signal** to the second thread.
+- Conversely now the first thread is in the **wait** state. Once the second thread is done writing data to the UART it gives a **signal** to the first thread.
 
 # Cooperative Semaphore
 
diff --git a/Semaphore/application/CMakeLists.txt b/Semaphore/application/CMakeLists.txt
@@ -1,6 +1,10 @@
 target_sources(${USER_PROJECT_TARGET} PRIVATE
+  # Scheduler
   osKernel.c
   osKernel.S
+
+  # Semaphore
+  osSemaphore.c
 )
 target_include_directories(${USER_PROJECT_TARGET} PRIVATE
   .
diff --git a/Semaphore/application/main.c b/Semaphore/application/main.c
@@ -1,4 +1,5 @@
 #include "osKernel.h"
+#include "osSemaphore.h"
 
 #include "gpio/gpio.h"
 #include "uart/uart.h"
@@ -11,18 +12,23 @@ static UART_s uart_config;
 
 // * Add these variables to the debug watch window
 static uint32_t i, j, k;
+static uint32_t semaphore_t1, semaphore_t2;
 
 void t1(void) {
   while (1) {
+    osSemaphoreWait(&semaphore_t1);
     i++;
     uart__write_string(&uart_config, "Hello World from Thread 1\r\n");
+    osSemaphoreSignal(&semaphore_t2);
   }
 }
 
 void t2(void) {
   while (1) {
+    osSemaphoreWait(&semaphore_t2);
     j++;
     uart__write_string(&uart_config, "Hello World from Thread 2\r\n");
+    osSemaphoreSignal(&semaphore_t1);
   }
 }
 
@@ -33,6 +39,9 @@ void t3(void) {
 }
 
 int main(void) {
+  osSemaphoreInit(&semaphore_t1, 1);
+  osSemaphoreInit(&semaphore_t2, 0);
+
   main__uart_init();
   uart__write_string(&uart_config, "Hello World\r\n");
 
diff --git a/Semaphore/application/osSemaphore.c b/Semaphore/application/osSemaphore.c
@@ -0,0 +1,22 @@
+#include "osSemaphore.h"
+
+#include "stm32l4xx.h"
+
+void osSemaphoreInit(uint32_t *semaphore, uint32_t value) {
+  *semaphore = value;
+}
+
+void osSemaphoreWait(uint32_t *semaphore) {
+  while (*semaphore <= 0) {
+  }
+
+  __disable_irq();
+  *semaphore -= 1;
+  __enable_irq();
+}
+
+void osSemaphoreSignal(uint32_t *semaphore) {
+  __disable_irq();
+  *semaphore += 1;
+  __enable_irq();
+}
diff --git a/Semaphore/application/osSemaphore.h b/Semaphore/application/osSemaphore.h
@@ -0,0 +1,11 @@
+#ifndef OS_SEMAPHORE_H_
+#define OS_SEMAPHORE_H_
+
+#include <stdint.h>
+
+void osSemaphoreInit(uint32_t *semaphore, uint32_t value);
+
+void osSemaphoreWait(uint32_t *semaphore);
+void osSemaphoreSignal(uint32_t *semaphore);
+
+#endif
diff --git a/Semaphore/images/example2_spinlock_semaphore.PNG b/Semaphore/images/example2_spinlock_semaphore.PNG

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,10 @@`
`1`	`1`	`target_sources(${USER_PROJECT_TARGET} PRIVATE`
	`2`	`+ # Scheduler`
`2`	`3`	`osKernel.c`
`3`	`4`	`osKernel.S`
	`5`	`+`
	`6`	`+ # Semaphore`
	`7`	`+ osSemaphore.c`
`4`	`8`	`)`
`5`	`9`	`target_include_directories(${USER_PROJECT_TARGET} PRIVATE`
`6`	`10`	`.`