Added some examples

Signed-off-by: Frederic.Pillon <[email protected]>

Author: fpistm

examples/frBlink/frBlink.ino

@@ -0,0 +1,82 @@
+/*
+ * Example to demonstrate thread definition, semaphores, and thread sleep.
+ */
+#include <STM32FreeRTOS.h>
+
+// Define the LED pin is attached
+const uint8_t LED_PIN = LED_BUILTIN;
+
+// Declare a semaphore handle.
+SemaphoreHandle_t sem;
+//------------------------------------------------------------------------------
+/*
+ * Thread 1, turn the LED off when signalled by thread 2.
+ */
+// Declare the thread function for thread 1.
+static void Thread1(void* arg) {
+  UNUSED(arg);
+  while (1) {
+
+    // Wait for signal from thread 2.
+    xSemaphoreTake(sem, portMAX_DELAY);
+
+    // Turn LED off.
+    digitalWrite(LED_PIN, LOW);
+  }
+}
+//------------------------------------------------------------------------------
+/*
+ * Thread 2, turn the LED on and signal thread 1 to turn the LED off.
+ */
+// Declare the thread function for thread 2.
+static void Thread2(void* arg) {
+  UNUSED(arg);
+  pinMode(LED_PIN, OUTPUT);
+
+  while (1) {
+    // Turn LED on.
+    digitalWrite(LED_PIN, HIGH);
+
+    // Sleep for 200 milliseconds.
+    vTaskDelay((200L * configTICK_RATE_HZ) / 1000L);
+
+    // Signal thread 1 to turn LED off.
+    xSemaphoreGive(sem);
+
+    // Sleep for 200 milliseconds.
+    vTaskDelay((200L * configTICK_RATE_HZ) / 1000L);
+  }
+}
+//------------------------------------------------------------------------------
+void setup() {
+  portBASE_TYPE s1, s2;
+
+  Serial.begin(9600);
+
+  // initialize semaphore
+  sem = xSemaphoreCreateCounting(1, 0);
+
+  // create task at priority two
+  s1 = xTaskCreate(Thread1, NULL, configMINIMAL_STACK_SIZE, NULL, 2, NULL);
+
+  // create task at priority one
+  s2 = xTaskCreate(Thread2, NULL, configMINIMAL_STACK_SIZE, NULL, 1, NULL);
+
+  // check for creation errors
+  if (sem== NULL || s1 != pdPASS || s2 != pdPASS ) {
+    Serial.println(F("Creation problem"));
+    while(1);
+  }
+
+  // start scheduler
+  vTaskStartScheduler();
+  Serial.println("Insufficient RAM");
+  while(1);
+}
+
+//------------------------------------------------------------------------------
+// WARNING idle loop has a very small stack (configMINIMAL_STACK_SIZE)
+// loop must never block
+void loop() {
+  // Not used.
+}

examples/frBlinkPrint/frBlinkPrint.ino

@@ -0,0 +1,94 @@
+// Simple demo of three threads
+// LED blink thread, print thread, and idle loop
+#include <STM32FreeRTOS.h>
+
+const uint8_t LED_PIN = LED_BUILTIN;
+
+volatile uint32_t count = 0;
+
+// handle for blink task
+TaskHandle_t blink;
+
+//------------------------------------------------------------------------------
+// high priority for blinking LED
+static void vLEDFlashTask(void *pvParameters) {
+  pinMode(LED_PIN, OUTPUT);
+
+  // Flash led every 200 ms.
+  for (;;) {
+    // Turn LED on.
+    digitalWrite(LED_PIN, HIGH);
+
+    // Sleep for 50 milliseconds.
+    vTaskDelay((50L * configTICK_RATE_HZ) / 1000L);
+
+    // Turn LED off.
+    digitalWrite(LED_PIN, LOW);
+
+    // Sleep for 150 milliseconds.
+    vTaskDelay((150L * configTICK_RATE_HZ) / 1000L);
+  }
+}
+//------------------------------------------------------------------------------
+static void vPrintTask(void *pvParameters) {
+  while (1) {
+    // Sleep for one second.
+    vTaskDelay(configTICK_RATE_HZ);
+
+    // Print count for previous second.
+    Serial.print(F("Count: "));
+    Serial.print(count);
+
+    // Print unused stack for threads.
+    Serial.print(F(", Unused Stack: "));
+    Serial.print(uxTaskGetStackHighWaterMark(blink));
+    Serial.print(' ');
+    Serial.print(uxTaskGetStackHighWaterMark(0));
+    Serial.print(' ');
+    Serial.println(uxTaskGetStackHighWaterMark(xTaskGetIdleTaskHandle()));
+
+    // Zero count.
+    count = 0;
+  }
+}
+//------------------------------------------------------------------------------
+void setup() {
+  Serial.begin(9600);
+  // wait for Leonardo
+  while(!Serial) {}
+
+  // create blink task
+  xTaskCreate(vLEDFlashTask,
+    "Task1",
+    configMINIMAL_STACK_SIZE + 50,
+    NULL,
+    tskIDLE_PRIORITY + 2,
+    &blink);
+
+  // create print task
+  xTaskCreate(vPrintTask,
+    "Task2",
+    configMINIMAL_STACK_SIZE + 100,
+    NULL,
+    tskIDLE_PRIORITY + 1,
+    NULL);
+
+  // start FreeRTOS
+  vTaskStartScheduler();
+
+  // should never return
+  Serial.println(F("Die"));
+  while(1);
+}
+//------------------------------------------------------------------------------
+// WARNING idle loop has a very small stack (configMINIMAL_STACK_SIZE)
+// loop must never block
+void loop() {
+  while(1) {
+    // must insure increment is atomic
+    // in case of context switch for print
+    noInterrupts();
+    count++;
+    interrupts();
+  }
+}

examples/frJitter/frJitter.ino

@@ -0,0 +1,78 @@
+// test of jitter in sleep for one tick
+//
+// idle loop prints min and max time between sleep calls
+//
+// Note: access to shared variables tmin and tmax is not atomic
+// so glitches are possible if context switch happens during idle loop
+// access to these variables.
+//
+#include <STM32FreeRTOS.h>
+
+volatile  uint16_t tmax = 0;
+volatile  uint16_t tmin = 0XFFFF;
+//------------------------------------------------------------------------------
+static void vJitter(void *pvParameters) {
+  // initialize tlast
+  vTaskDelay(1);
+  uint32_t tlast = micros();
+  while (true) {
+    vTaskDelay(1);
+    // get wake time
+    uint32_t tmp = micros();
+    uint16_t diff = tmp - tlast;
+    if (diff < tmin) tmin = diff;
+    if (diff > tmax) tmax = diff;
+    tlast = tmp;
+  }
+}
+//------------------------------------------------------------------------------
+uint8_t np = 10;
+static void vPrintTask(void *pvParameters) {
+  for (;;) {
+    // delay one second
+    vTaskDelay(configTICK_RATE_HZ);
+    Serial.print(tmin);
+    Serial.write(',');
+    Serial.println(tmax);
+    if (np++ >= 10) {
+      np = 0;
+      tmin = 0XFFFF;
+      tmax = 0;
+      Serial.write("clear\r\n");
+    }
+  }
+}
+//------------------------------------------------------------------------------
+void setup() {
+  Serial.begin(9600);
+  while (!Serial);
+  delay(1000);
+
+  // create high priority thread
+  xTaskCreate(vJitter,
+    "Task1",
+    configMINIMAL_STACK_SIZE,
+    NULL,
+    tskIDLE_PRIORITY + 2,
+    NULL);
+
+  // create print task
+  xTaskCreate(vPrintTask,
+    "Task2",
+    configMINIMAL_STACK_SIZE + 100,
+    NULL,
+    tskIDLE_PRIORITY + 1,
+    NULL);
+
+  // start FreeRTOS
+  vTaskStartScheduler();
+
+  // should never return
+  Serial.println("Die");
+  while(1);
+}
+//------------------------------------------------------------------------------
+void loop() {
+  // Not used - idle loop has a very small, configMINIMAL_STACK_SIZE, stack
+  // loop must never block
+}