MINISTERUL EDUCAŢIEI, CULTURII ȘI CERCETĂRII

Universitatea Tehnică a Moldovei

Facultatea Calculatoare Informatică şi Microelectronică
Departamentul Ingineria Software și Automatică

Raport
Disciplina: Internetul Lucrurilor(IoT)
Tema: “Sisteme de operare”

Student: _____________ Mereuță Ana, TI-192

Coordonator: _____________ Lupan Cristian, asist. univ.

Chişinău 2022
1. Descrierea problemei
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.

2. Materiale și metode
Materialele care au fost utilizate în cadrul acestei lucrări de laborator sunt următoarele: placă de dezvoltare
Arduino UNO R3, LED, LED RGB, Button, potențiometru, rezistor, fire de conexiune.
Tinkercad este un program de modelare 3D online gratuit, care rulează într-un browser web. De când a
devenit disponibil în 2011, a devenit o platformă populară pentru crearea de modele pentru imprimarea 3D,
precum și o introducere de bază la geometria solidă constructivă în școli.
Componentele de bază ale Tinkercad, sunt alcătuite dintr-o baterie, buton, rezistor, LED, condensator.
Ansamblurile de circuite sunt circuite simple, prefabricate. Unele dintre ansamblurile de circuite disponibile
sunt circuitul de strălucire, circuitul de mișcare și rotirea circuitului.
Proteus Design Suite este o suită de instrumente software folosită în principal pentru automatizarea
designului electronic. Software-ul este utilizat în principal de către ingineri și tehnicieni în proiectarea
electronică pentru a crea scheme și imprimeuri electronice pentru fabricarea plăcilor de circuit imprimat.

3. Schema

4. Codul sursă:
#define LED_BLUE_PIN 13
#define LED_RED_PIN 12
#define BUTTON_LED1_PIN 11
#define BUTTON_PLUS_PIN 10
#define BUTTON_MINUS_PIN 9

#define RGB_RED_PIN A2
#define RGB_GREEN_PIN A1
#define RGB_BLUE_PIN A0

#define INPUT_RED_PIN A3
#define INPUT_GREEN_PIN A4
#define INPUT_BLUE_PIN A5
bool blueLedState = false;
bool redLedState = false;

int redLedDelayValue = 1;
int redLedDelayTimer = 0;
bool timerRunning = true;

int redValue = 0;
int greenValue = 0;
int blueValue = 0;

LiquidCrystal lcd(7, 6, 5, 4, 3, 2);

void setup() {
pinMode(LED_BLUE_PIN, OUTPUT);
pinMode(LED_RED_PIN, OUTPUT);
pinMode(BUTTON_LED1_PIN, INPUT);
pinMode(BUTTON_PLUS_PIN, INPUT);
pinMode(BUTTON_MINUS_PIN, INPUT);

pinMode(RGB_RED_PIN, OUTPUT);
pinMode(RGB_GREEN_PIN, OUTPUT);
pinMode(RGB_BLUE_PIN, OUTPUT);
pinMode(INPUT_RED_PIN, INPUT);
pinMode(INPUT_GREEN_PIN, INPUT);
pinMode(INPUT_BLUE_PIN, INPUT);
lcd.begin(16, 2);
}
void readPotentiometersValues() {
redValue = map(analogRead(INPUT_RED_PIN), 0, 1023, 0, 255);
greenValue = map(analogRead(INPUT_GREEN_PIN), 0, 1023, 0, 255);
blueValue = map(analogRead(INPUT_BLUE_PIN), 0, 1023, 0, 255);
}
void setRgbLedColor() {
analogWrite(RGB_RED_PIN, redValue);
analogWrite(RGB_GREEN_PIN, greenValue);
analogWrite(RGB_BLUE_PIN, blueValue);
}
char cstr[3];
char * convertIntToString(int value) {
itoa(value, cstr, 10);
return cstr;
}

Secvențial:
 Pentru a implementa logica în mod secvențial, au fost implementate mai multe funcții, care se apelează la
rând în metoda loop.

Aceasta arată în felul următor:

void loop() {
isButtonPressed(BUTTON_LED1_PIN);
isButtonPressed(BUTTON_PLUS_PIN);
isButtonPressed(BUTTON_MINUS_PIN);

readPotentiometersValues();
setRgbLedColor();

redLedLoop();
showOnScreen();
}
void isButtonPressed(int buttonPin) {
if (!digitalRead(buttonPin)) {
return;
}

switch (buttonPin)
{
case BUTTON_LED1_PIN:
firstButtonAction();
break;
case BUTTON_PLUS_PIN:
secondThirdButtonAction(+1);
break;
case BUTTON_MINUS_PIN:
secondThirdButtonAction(-1);
break;
}

while (digitalRead(buttonPin));
}
void firstButtonAction() {
blueLedState = !blueLedState;
digitalWrite(LED_BLUE_PIN, blueLedState);
}
void secondThirdButtonAction(int value) {
if (redLedDelayValue == 1 && value < 0) {
return;
}

redLedDelayValue += value;
}
void redLedLoop() {
if(!blueLedState) {
timerRunning = true;
}

if (blueLedState && timerRunning) {

timerRunning = false;
digitalWrite(LED_RED_PIN, redLedState);
redLedDelayTimer = 0;
return;
}
 if (!timerRunning) return;

if (redLedDelayTimer >= redLedDelayValue * 10) {

redLedState = !redLedState;
redLedDelayTimer = 0;
}
redLedDelayTimer++;
delay(10);
}
void showOnScreen() {
delay(100);
lcd.clear();

String blueLedText = blueLedState ? "ON" : "OFF";

String redLedText = redLedState ? "ON" : "OFF";

lcd.println(blueLedText + " " + redLedText + " " + (redLedDelayValue * 10) + " " +
redLedDelayTimer);

lcd.setCursor(0, 1);
lcd.print(redValue);
lcd.print(" ");
lcd.print(greenValue);
lcd.print(" ");
lcd.print(blueValue);
lcd.print(" ");
}
FreeRTOS:
xTaskCreate(vATaskFirstButton, "FirstButton", 128, NULL, 1, NULL);
xTaskCreate(vATaskChangeRedLedDelay, "ChangeRedLedDelay", 128, NULL, 1, NULL);
xTaskCreate(vATaskBlinkRedLed, "BlinkRedLed", 128, NULL, 1, NULL);
xTaskCreate(vATaskSetRgbLed, "SetRgbLed", 128, NULL, 1, NULL);
xTaskCreate(vATaskShowOnLcd, "ShowOnLcd", 128, NULL, 1, NULL);:
void vATaskFirstButton(void *pvParameters) {
do {
if (digitalRead(BUTTON_LED1_PIN)) {
blueLedState = !blueLedState;
digitalWrite(LED_BLUE_PIN, blueLedState);
}

while (digitalRead(BUTTON_LED1_PIN));
vTaskDelay(100 / portTICK_PERIOD_MS);
} while(true);
}
void vATaskChangeRedLedDelay(void *pvParameters) {

do {
if (digitalRead(BUTTON_MINUS_PIN) && redLedDelayValue > 1) {
redLedDelayValue--;
}

if(digitalRead(BUTTON_PLUS_PIN)) {
redLedDelayValue++;
}

redLedDelayTicks = redLedDelayValue * 1000 / portTICK_PERIOD_MS;

 while (digitalRead(BUTTON_PLUS_PIN) || digitalRead(BUTTON_MINUS_PIN));

vTaskDelay(100 / portTICK_PERIOD_MS);
} while(true);
}
void vATaskBlinkRedLed(void *pvParameters) {
do {
if (blueLedState == false) {
redLedState = !redLedState;
digitalWrite(LED_RED_PIN, redLedState);
}
vTaskDelay(redLedDelayTicks);
} while(true);
}
void vATaskSetRgbLed(void *pvParameters) {
do {
readPotentiometersValues();
setRgbLedColor();
vTaskDelay(100 / portTICK_PERIOD_MS);
} while (true);
}
void vATaskShowOnLcd(void *pvParameters) {
String blueLedText = "";
String redLedText = "";

do {
lcd.clear();
blueLedText = blueLedState ? "ON" : "OFF";
redLedText = redLedState ? "ON" : "OFF";

lcd.println(blueLedText + " " + redLedText + " " + (redLedDelayValue * 10));

lcd.setCursor(0, 1);
lcd.print(redValue);
lcd.print(" ");
lcd.print(greenValue);
lcd.print(" ");
lcd.print(blueValue);
lcd.print(" ");

vTaskDelay(100 / portTICK_PERIOD_MS);
} while(true);
}
5. Rezultatul

Figura 2 – Starea inițială

 Figura 3 – Led-ul albastru este aprins

Figura 5 – Modificarea timpului în care led-ul roșu rămâne într-o stare

Figura 6 – Modificarea culorii led-ului RGB