Ce este un microcontroler

June 4, 2025
18,343 Comments

 
Ce este un microcontroler ?
Un microcontroler este un circuit integrat care conține un procesor, memorie și periferice, toate integrate într-un singur chip. Acesta este folosit pentru a controla diverse dispozitive electronice, fiind esențial în aplicații de automatizare, robotica, electronică de consum și multe altele.
 
Care este structura interna a unui microcontroler ?
Unitate Centrală de Procesare (CPU): Este inima microcontrolerului, responsabilă cu executarea instrucțiunilor și coordonarea operatiunilor.
 
Memorie
Memorie RAM (Random Access Memory: Folosită pentru stocarea temporară a datelor în timpul execuției programului.
Memorie Flash sau EEPROM: Pentru stocarea permanentă a codului și a datelor care trebuie păstrate și după oprirea alimentării.
Interfețe de intrare/ieșire (I/O): Permite comunicarea cu alte dispozitive externe, cum ar fi senzori, motoare sau LED-uri.
Periferice: Acestea pot include convertoare analogic-digitale (ADC), temporizatoare, comunicare serială (UART, SPI, I2C).
Unități de suport: Pot include module pentru generarea de semnale PWM, pentru controlul unor funcții specifice sau pentru gestionarea alimentarii.
 
Cum se poate programa un microcontroler ?
Programarea unui microcontroler se face în general folosind un limbaj de programare, cele mai utilizate fiind C și Assembly. Pasii generali sunt urmatorii:
Scrierea Codului: Folosind un mediu de dezvoltare (IDE) specific pentru microcontrolerul ales (de exemplu, MPLAB pentru PIC, Arduino IDE pentru Arduino).
Compilarea: Codul scris este compilat pentru a fi transformat intr-un fișier binar pe care microcontrolerul il poate intelege.
Incărcarea Programului: Utilizând un programator (hardware care facilitează transferul codului), codul este încărcat în memoria flash a microcontrolerului.
Testare și Debugging: Verificarea și ajustarea programului pentru a se asigura că funcția dorită este realizată corect.
 
Un exemplu de aplicație practica cu microcontroler !
Un exemplu comun este un sistem de automatizare a iluminatului. Acest sistem poate folosi un microcontroler (de exemplu, Arduino) pentru a controla iluminatul într-o cameră pe baza detecției mișcării.
 
Funcționare
Un senzor de mișcare (PIR) detectează prezența unei persoane.
– Microcontrolerul primește semnal de la senzor și activează un releu care pornește luminile.
– Când nu mai este detectată mișcare pentru un anumit timp, microcontrolerul oprește lumina.

Acest tip de aplicație este eficient atât pentru confortul utilizatorului, cât și pentru economisirea energiei.

Codul sursa în limbajul C++ pt un sistem de automatizare a iluminatului care folosește un microcontroler Arduino, un senzor de mișcare PIR, si un releu.

Principalul de funcționare este urmatorul:
Senzorul de mișcare PIR detectează mișcarea unei persoane.
Microcontrolerul primește semnalul de la senzorul PIR și activează un releu care aprinde luminile.
Când nu mai este detectata mișcarea după un anumit timp stabilit ,microcontrolerul acționează releul iar acesta întrerupe circuitul de alimentare a becurilor.
 
Un exemplu de cod sursă în C++ pentru un sistem de automatizare a iluminatului folosind un microcontroler Arduino, un senzor de mișcare PIR și un releu.
 
Cod sursă

// Definirea pinilor
const int pirPin = 2; // Pinul pentru senzorul PIR
const int relayPin = 13; // Pinul pentru releu
const unsigned long timeout = 10000; // Timpul (în milisecunde) după care se va opri lumina (10 secunde)

unsigned long lastMotionTime;
bool lightOn = false;

void setup() {
pinMode(pirPin, INPUT); // Setăm pinul PIR ca intrare
pinMode(relayPin, OUTPUT); // Setăm pinul releu ca ieșire
digitalWrite(relayPin, LOW); // Inițial, releul este oprit (lumina este stinsă)
Serial.begin(9600); // Inițializarea comunicării seriale pentru debugging
}

void loop() {
int pirState = digitalRead(pirPin); // Citim starea senzorului PIR

if (pirState == HIGH) {
Serial.println("Mișcare detectată!"); // Dacă se detectează mișcare

// Dacă lumina nu este deja aprinsă, aprindem lumina
if (!lightOn) {
digitalWrite(relayPin, HIGH);
lightOn = true;
lastMotionTime = millis(); // Actualizăm timpul ultimei mișcări
} else {
lastMotionTime = millis(); // Actualizăm timpul ultimei mișcări
}
} else {
// Dacă nu s-a detectat mișcare și lumina este aprinsă
if (lightOn && (millis() - lastMotionTime >= timeout)) {
Serial.println("Mișcare neîntâlnită. Oprire lumina.");
digitalWrite(relayPin, LOW); // Oprim lumina
lightOn = false; // Setăm starea luminii ca stinsă
}
}

delay(100); // Întârziere pentru a evita citiri false
}

 
Explicația codului
Acest cod este scris pentru o aplicație bazată pe Arduino care folosește un senzor PIR (Passive Infrared Sensor) pentru a detecta mișcarea și un releu pentru a controla o sursă de lumină. Iată o explicație detaliată a fiecărei părți a codului:

1. Definirea pinilor și variabilelor:


const int pirPin = 2; // Pinul pentru senzorul PIR
const int relayPin = 13; // Pinul pentru releu
const unsigned long timeout = 10000; // Timpul (în milisecunde) după care se va opri lumina (10 secunde)

unsigned long lastMotionTime; // Timpul ultimei detecții de mișcare
bool lightOn = false; // Starea curentă a luminii (aprinsă/stinsă)
```

- `pirPin` //este pinul la care este conectat senzorul PIR.
- `relayPin` //este pinul la care este conectat releul.
- `timeout` //definește timpul în milisecunde după care lumina se va opri dacă nu se detectează mișcare.
- `lastMotionTime` //reține timpul ultimei detecții de mișcare.
- `lightOn` //indică dacă lumina este aprinsă sau stinsă.

 
Funcția `setup()

void setup() {
pinMode(pirPin, INPUT); // Setăm pinul PIR ca intrare
pinMode(relayPin, OUTPUT); // Setăm pinul releu ca ieșire
digitalWrite(relayPin, LOW); // Inițial, releul este oprit (lumina este stinsă)
Serial.begin(9600); // Inițializarea comunicării seriale pentru debugging
}
```
//Configurează pinul PIR ca intrare și pinul releu ca ieșire.
//Inițializează releul în stare oprită (lumina este stinsă) și deschide comunicarea serială
//pentru a permite debugul.

 
Funcția `loop()

void loop() {
int pirState = digitalRead(pirPin); // Citim starea senzorului PIR

if (pirState == HIGH) { // Dacă se detectează mișcare
Serial.println("Mișcare detectată!");

if (!lightOn) { // Dacă lumina nu este deja aprinsă
digitalWrite(relayPin, HIGH); // Aprindem lumina
lightOn = true;
lastMotionTime = millis(); // Actualizăm timpul ultimei mișcări
} else {
lastMotionTime = millis(); // Actualizăm timpul ultimei mișcări
}
} else {
// Dacă nu s-a detectat mișcare și lumina este aprinsă
if (lightOn && (millis() - lastMotionTime >= timeout)) {
Serial.println("Mișcare neîntâlnită. Oprire lumina.");
digitalWrite(relayPin, LOW); // Oprim lumina
lightOn = false; // Setăm starea luminii ca stinsă
}
}

delay(100); // Întârziere pentru a evita citiri false
}

// Citeste starea senzorului PIR.
// Dacă senzorul detectează mișcare (`pirState == HIGH`), se verifică dacă lumina este aprinsă sau nu.
// Dacă lumina nu este aprinsă, aceasta se aprinde și se actualizează `lastMotionTime`.
// Dacă lumina este deja aprinsă, se actualizează doar `lastMotionTime`.
// Dacă nu se detectează mișcare și lumina este aprinsă, se verifică dacă a trecut timpul `timeout`.

// Dacă da, se oprește lumina.
// O întârziere de 100 ms este inclusă pentru a preveni citirile false.




weebly reliable statistics