Ministère de l'éducation, de la culture et de la recherche

de la République de Moldova
Université technique de Moldavie
Faculté d’Ordinateur, Informatique et Microélectronique
Filière francophone “Informatique”

IoT

Travail pratique nr.2

Thème: Sisteme de Operare

Effectué par l’étudiant(e) de gr FI-181 : Damean Alexandra

Vérifié par le professeur : Bîrnaz Adrian

Chișinau 2021
Scopul lucrării și sarcinile propuse :
Realizarea unei aplicații pentru MCU care va rula minim 3 task-uri in doua versiuni -
Secvential si cu FreeRTOS

Aplicația va rula minim 3 task-uri printre care :

 Button Led - Schimbare stare LED la detecția unei apăsări pe buton.

 un al doilea Led Intermitent în faza în care LED-ul de la primul Task e stins
 Incrementare/decrementare valoare a unei variabile la apăsarea a doua butoane care va
reprezenta numărul de recurențe/timp în care ledul de la al doilea task se va afla într-o stare
 Task-ul de Idle se va utiliza pentru afișarea stărilor din program, cum ar fi, afișare stare LED,
și afișare mesaj la detecția apăsării butoanelor, o implementare fiind ca la apăsarea butonului
sa se seteze o variabila, iar la afișare mesaj - resetare, implementând mecanismul
provider/consumer.

Teorie :
FreeRTOS este un sistem de operare open source, în timp real, pentru microcontrolere, care
face ca dispozitivele de dimensiuni mici, cu consum redus, să fie ușor de programat, implementat,
securizat, conectat și administrat.
Distribuit gratuit sub licența open source MIT, FreeRTOS include un nucleu și un set tot
mai mare de biblioteci software adecvate pentru utilizare în sectoare și aplicații industriale. Aceasta
include conectarea în siguranță a dispozitivelor dvs. mici, cu consum redus de energie, la serviciile
AWS Cloud precum AWS IoT Core sau la dispozitive Edge mai puternice care rulează AWS IoT
Greengrass .
FreeRTOS este construit cu accent pe fiabilitate și ușurință în utilizare și oferă
predictibilitatea lansărilor de asistență pe termen lung.
Un microcontroler conține un procesor simplu, limitat de resurse, care poate fi găsit pe
multe dispozitive, inclusiv aparate, senzori, trackere de fitness, automatizare industrială și
automobile. Multe dintre aceste dispozitive mici pot beneficia de conectarea la cloud sau local la
alte dispozitive, dar au o putere de calcul și o capacitate de memorie limitate și îndeplinesc de obicei
sarcini simple și funcționale.
 Microcontrolerele rulează frecvent sisteme de operare care pot să nu aibă funcționalitate
încorporată pentru a se conecta la rețelele locale sau la cloud, ceea ce face ca aplicațiile IoT să fie o
provocare. FreeRTOS vă ajută să rezolvați această problemă oferind nucleului să ruleze dispozitive
cu consum redus de energie, precum și biblioteci software care facilitează conectarea în siguranță la
cloud sau la alte dispozitive marginale, astfel încât să puteți colecta date de la acestea pentru
aplicații IoT și să luați măsuri.
FreeRTOS include suport pentru Transport Layer Security (TLS v1.2) și PKCS # 11 pentru
a vă ajuta dispozitivele să se conecteze în siguranță la AWS. De asemenea, puteți programa cu
ușurință capabilitățile obișnuite IoT pe dispozitivul dvs., inclusiv biblioteci de software care vă ajută
să configurați dispozitivele într-o rețea locală utilizând opțiuni de conectivitate comune, cum ar fi
Wi-Fi sau Ethernet, sau să vă conectați la un dispozitiv mobil utilizând Bluetooth Low Energy.
FreeRTOS include, de asemenea, o bibliotecă de actualizare over-the-air (OTA) pentru a
actualiza de la distanță dispozitivele cu îmbunătățiri ale caracteristicilor sau patch-uri de securitate și
o caracteristică de semnare a codului pentru a vă asigura că codul dispozitivului dvs. nu este
compromis în timpul implementării și actualizărilor OTA.

FreeRTOS oferă tot ce aveți nevoie pentru a programa cu ușurință dispozitive conectate
bazate pe microcontroler și a colecta date de la acestea pentru aplicații IoT. Puteți începe alegând un
microcontroler calificat FreeRTOS din catalogul de dispozitive partener AWS . Apoi, puteți utiliza
consola AWS sau GitHub pentru a selecta și descărca biblioteci relevante FreeRTOS sau integrări
de referință IoT pre-validate. Accesați pagina noastră de începere pentru a afla mai multe despre
toate opțiunile.

Puteți conecta în siguranță dispozitivele FreeRTOS la servicii cloud precum AWS IoT
Core, la un dispozitiv local de margine sau la un dispozitiv mobil prin Bluetooth Low Energy și le
puteți actualiza de la distanță utilizând funcția de actualizare OTA disponibilă cu AWS IoT Device
Management. O integrare cu AWS IoT Device Defender facilitează raportarea cu privire la valorile
de pe partea dispozitivului pentru a detecta anomaliile atunci când aceste valori se abat de la
comportamentul așteptat.

Source Code FreeRTOS:

#include <Arduino.h>
#include <Arduino_FreeRTOS.h>
#include <semphr.h>
#include <stdio.h>

#const int tumblerButtonPin 2

#const int plusButtonPin 6
#const int minusButtonPin 7

SemaphoreHandle_t xSerialSemaphore;

bool tumbler = true;

const int ledPin = 13;

const int togglingLedPin = 12;

unsigned long relativeTime;
int togglingDelay = 500;

static FILE uartout = {0} ;

static int my_putChar( char ch, FILE * stream)

{
Serial.write( ch );
return 0;
}

void toggleLed(int delay) {

if (millis() >= relativeTime && !tumbler) {
digitalWrite(togglingLedPin, !digitalRead(togglingLedPin));
relativeTime = millis() + delay;
}
}

void TaskTumblerButtonHandler(void *pvParameters);

void TaskPlusButtonHandler(void *pvParameters);

void TaskMinusButtonHandler(void *pvParameters);

void TaskTogglingProcess(void *pvParameters);

void setup() {
fdev_setup_stream (&uartout, my_putChar, NULL, _FDEV_SETUP_RW);

pinMode(tumblerButtonPin, INPUT);
pinMode(plusButtonPin, INPUT);
pinMode(minusButtonPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(togglingLedPin, OUTPUT);
Serial.begin(9600);
 relativeTime = millis();
stdout = &uartout ;
printf("Start");

while (!Serial) {
if (xSerialSemaphore == NULL) {
xSerialSemaphore = xSemaphoreCreateMutex();
if ((xSerialSemaphore) != NULL)
xSemaphoreGive((xSerialSemaphore));
}
}

xTaskCreate(
TaskTumblerButtonHandler, "TaskTumblerButtonHandler", 128, NULL, 2, NULL);
xTaskCreate(
TaskPlusButtonHandler, "TaskPlusButtonHandler", 128, NULL, 2, NULL);
xTaskCreate(
TaskMinusButtonHandler, "TaskMinusButtonHandler", 128, NULL, 2, NULL);
xTaskCreate(
TaskTogglingProcess, "TaskTogglingProcess", 128, NULL, 2, NULL);
}

void loop() {

void TaskTumblerButtonHandler(void *pvParameters __attribute__((unused))) {

int buttonState = 0;
int lastButtonState = 0;
int counter = 0;

while (1) {
buttonState = digitalRead(tumblerButtonPin);
if (buttonState != lastButtonState) {
counter++;
if (counter % 2 == 0) {
tumbler = !tumbler;
if (xSemaphoreTake(xSerialSemaphore, (TickType_t) 5) == pdTRUE) {
printf("on");
xSemaphoreGive(xSerialSemaphore);
}
if (counter >= 100000000) {
counter = 0;
}
} else {
if (xSemaphoreTake(xSerialSemaphore, (TickType_t) 5) == pdTRUE) {
printf("off");
xSemaphoreGive(xSerialSemaphore);
}
}
vTaskDelay(4);
}
lastButtonState = buttonState;
vTaskDelay(1);
}
}

void TaskPlusButtonHandler(void *pvParameters __attribute__((unused))) {

int plusButtonState = 0;
 int lastPlusButtonState = 0;
int plusCounter = 0;

while (1) {
plusButtonState = digitalRead(plusButtonPin);
if (plusButtonState != lastPlusButtonState) {
// was pressed
plusCounter++;
if (plusCounter % 2 == 0) {
togglingDelay += 100;
if (xSemaphoreTake(xSerialSemaphore, (TickType_t) 5) == pdTRUE) {
printf("Plus button pressed \n");
printf("%d \n", togglingDelay);
xSemaphoreGive(xSerialSemaphore);
}
if (plusCounter >= 100000000) {
plusCounter = 0;
}
}
vTaskDelay(4);
}
lastPlusButtonState = plusButtonState;
vTaskDelay(1);
}
}

void MinusButtonHandler(void *pvParameters __attribute__((unused))) {

int minusButtonState = 0;
int lastMinusButtonState = 0;
int minusCounter = 0;

while (1) {
minusButtonState = digitalRead(minusButtonPin);
if (minusButtonState != lastMinusButtonState) {
// was pressed
minusCounter++;
if (minusCounter % 2 == 0) {
if (togglingDelay > 0) {
togglingDelay -= 100;
}
if (xSemaphoreTake(xSerialSemaphore, (TickType_t) 5) == pdTRUE) {
printf("Minus button pressed \n");
printf("%d \n", togglingDelay);
xSemaphoreGive(xSerialSemaphore);
}
if (minusCounter >= 100000000) {
minusCounter = 0;
}
}
vTaskDelay(4);
}
lastMinusButtonState = minusButtonState;
vTaskDelay(1);
}
}

void TogglingProcess(void *pvParameters) {

while (1) {
if (tumbler) {
 digitalWrite(ledPin, HIGH);
digitalWrite(togglingLedPin, LOW);
} else {
digitalWrite(ledPin, LOW);
}

toggleLed(togglingDelay);
vTaskDelay(1);
}
}

timer.h
#include <Arduino.h>
#include <Arduino_FreeRTOS.h>

#define tumblerButtonPin 2
#define plusButtonPin 6
#define minusButtonPin 7

// sudo chmod a+rw /dev/ttyACM0

// on off button
int buttonState = 0;
int lastButtonState = 0;
int counter = 0;
bool tumbler = true;

// frequency buttons

// plus
int plusButtonState = 0;
int lastPlusButtonState = 0;
int plusCounter = 0;

// minus
int minusButtonState = 0;
int lastMinusButtonState = 0;
int minusCounter = 0;

// simple led
const int ledPin = 13;

// toggling led
const int togglingLedPin = 12;
unsigned long relativeTime;
int togglingDelay = 500;

//int buttonPushCounter = 0;

void toggleLed(int delay) {

if (millis() >= relativeTime && !tumbler) {
digitalWrite(togglingLedPin, !digitalRead(togglingLedPin));
relativeTime = millis() + delay;
 }
}

void setup() {
pinMode(tumblerButtonPin, INPUT);
pinMode(plusButtonPin, INPUT);
pinMode(minusButtonPin, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(togglingLedPin, OUTPUT);
Serial.begin(9600);
relativeTime = millis();
Serial.println("Start");
}

void loop() {

// on off button
buttonState = digitalRead(tumblerButtonPin);
if (buttonState != lastButtonState) {
counter ++;
if (counter % 2 == 0) {
tumbler = !tumbler;
Serial.println("on");
if (counter >= 100000000) {
counter = 0;
}
} else {
Serial.println("off");

}
delay(50);
}
lastButtonState = buttonState;

// plus button
plusButtonState = digitalRead(plusButtonPin);
if (plusButtonState != lastPlusButtonState) {
// was pressed
plusCounter++;
if (plusCounter % 2 == 0) {
togglingDelay += 100;
Serial.println("Plus button pressed");
Serial.print(togglingDelay);
Serial.print("\n");
if (plusCounter >= 100000000) {
plusCounter = 0;
}
}
delay(50);
}
lastPlusButtonState = plusButtonState;

// minus button
minusButtonState = digitalRead(minusButtonPin);
if (minusButtonState != lastMinusButtonState) {
// was pressed
minusCounter++;
if (minusCounter%2 ==0) {
if (togglingDelay > 0) {
 togglingDelay -= 100;
}
Serial.println("Minus button pressed");
Serial.print(togglingDelay);
Serial.print("\n");
if (minusCounter >= 100000000) {
minusCounter = 0;
}
}
delay(50);
}
lastMinusButtonState = minusButtonState;

if (tumbler) {
digitalWrite(ledPin, HIGH);
digitalWrite(togglingLedPin, LOW);
} else {
digitalWrite(ledPin, LOW);
}

toggleLed(togglingDelay);
}

Result:
Video: https://youtu.be/Cu7JI5pQx24
Concluzie :
În această lucrare de laborator am lucrat cu Sistemul de operare FreeTos, care este
destinat pentru programarea micropocesoarelor. Am studiat si folosit task-urile. Am realizat 3
task-rui care presupuneau, schimabrea ledului, incrementarea si decrementarea valorii unui led
la apasarea butonului.
Bibliografie :
https://commons.wikimedia.org/wiki/File:Freertos.svg

https://www.freertos.org/RTOS-RISC-V-FreedomStudio-QMEU.html

https://jaywang.info/using-native-freertos-in-stm32-microcontrollers/