Proiectul consta in implementarea unui sistem interactiv de semaforizare pentru o trecere de pietoni, controlat de un microcontroler ATmega328P.

• Ce face: Sistemul gestioneaza traficul dintr-o intersectie simpla, avand un semafor complet pentru masini (Rosu, Galben, Verde) si unul pentru pietoni (Rosu, Verde). Trecerea pietonilor este conditionata de actionarea unui buton si de respectarea unui timp de garda (cooldown) pentru a nu bloca abuziv traficul auto. In plus, sistemul ofera feedback vizual printr-un ecran LCD I2C si feedback sonor printr-un buzzer.
• Care este scopul lui: Scopul principal este simularea unei situatii reale de trafic urban, punand accent pe siguranta pietonilor si fluidizarea circulatiei rutiere prin algoritmi de temporizare.
• Care a fost ideea de la care ati pornit: Am dorit sa transpun o problema clasica din viata de zi cu zi (asteptarea la semafor) intr-un automat de stari (State Machine). Am vrut un proiect care sa combine mai multe tipuri de periferice (GPIO, Timere hardware, comunicare I2C).
• De ce credeti ca este util: La nivel didactic, proiectul ajuta la consolidarea conceptelor de programare low-level (lucrul cu registri, intreruperi, debounce pentru butoane si evitarea functiilor blocante de tip delay). La nivel practic, arhitectura poate fi extinsa pentru sisteme de asistenta a persoanelor cu deficiente de vedere in spatiile publice.

Arhitectura sistemului se bazeaza pe o unitate centrala de procesare (microcontrolerul de pe placa Xplained Mini) care comunica cu mai multe module de Input/Output:

• Modulul de Input (Cerere traversare): Un buton tactil (momentary switch) configurat cu rezistenta de pull-up interna. Apasarea sa este preluata si procesata de microcontroler. Pentru a preveni citirile false (bouncing), se va face debounce software/hardware, iar preluarea comenzii va fi validata doar daca timpul de garda pentru masini a expirat.
• Modulul Output Vizual 1 (Semafoare): Format din 5 LED-uri controlate prin pinii GPIO. Doua stari principale sunt alternate: Trafic Auto Permis (Verde Masini, Rosu Pietoni) si Traversare Permisa (Rosu Masini, Verde Pietoni), legate printr-o stare de tranzitie (Galben Masini).
• Modulul Output Vizual 2 (Interfata Text): Un display LCD 1602 conectat prin interfata I2C (pinii SDA si SCL). Acesta afiseaza starea curenta a intersectiei (“Asteptati…”, “Traversati”, “Timp auto…”) si ofera un contor invers in timpul traversarii.
• Modulul Output Sonor: Un buzzer activ care emite un semnal de avertizare atunci cand semaforul pietonal este verde, pentru a asista persoanele cu deficiente de vedere.

Functionarea de ansamblu este dirijata de un Timer Hardware pe 16 biti (ex. Timer1) configurat in modul CTC, care asigura numararea secundelor si controlul starilor fara a bloca executia programului principal, permitand actualizarea fluenta a ecranului LCD.

Lista de piese:

• 1x Placa de dezvoltare ATmega328P Xplained Mini
• 1x Breadboard (200 / 400 puncte)
• 5x LED-uri 5mm (2x Rosu, 1x Galben, 2x Verde)
• 5x Rezistoare 220 ohmi (pentru limitarea curentului prin LED-uri)
• 1x Buton tactil (Momentary Push Button) 6x6x6 mm
• 1x Display LCD 1602 cu modul I2C integrat
• 1x Buzzer Activ 5V
• Fire de conexiune (Jumper wires: tata-tata si mama-tata)

Scheme electrice:

Mediu de dezvoltare: Microchip Studio (fostul Atmel Studio) / C pur. Librarii si surse 3rd-party:

• Librarie pentru comunicarea I2C/TWI (pentru interfatarea cu LCD-ul).
• Librarie minimala pentru LCD 1602 I2C adaptata pentru AVR.

Algoritmi si structuri:

• Implementarea unui Finite State Machine (FSM) pentru logica semaforului.
• Utilizarea Timer1 pentru generarea de intreruperi la intervale de 1 secunda (sau diviziuni), asigurand functionarea asincrona.
• Rutina de Debounce software pentru buton.

Codul Sursa:

#define F_CPU 16000000UL
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdio.h>
 
#define LED_AUTO_ROSU    PD3
#define LED_AUTO_GALBEN  PD4
#define LED_AUTO_VERDE   PD5
 
#define LED_PIETON_ROSU  PB0
#define LED_PIETON_VERDE PB1
 
#define BUZZER           PB2
#define BUTON            PD2
 
typedef enum {
    STATE_MASINI_VERDE,
    STATE_TRANZITIE_GALBEN,
    STATE_PIETONI_VERDE,
    STATE_COOLDOWN
} StateMachine_t;
 
volatile StateMachine_t current_state = STATE_MASINI_VERDE;
 
volatile uint8_t state_timer = 0;
volatile uint8_t cooldown_timer = 0;
volatile uint8_t cerere_traversare = 0;
volatile uint8_t beep_state = 0;
 
void hardware_init() {
    DDRD |= (1 << LED_AUTO_ROSU) | (1 << LED_AUTO_GALBEN) | (1 << LED_AUTO_VERDE);
    DDRB |= (1 << LED_PIETON_ROSU) | (1 << LED_PIETON_VERDE) | (1 << BUZZER);
 
    DDRD &= ~(1 << BUTON);
    PORTD |= (1 << BUTON);
 
    EICRA |= (1 << ISC01);
    EICRA &= ~(1 << ISC00);
    EIMSK |= (1 << INT0);
 
    TCCR1B |= (1 << WGM12);
    TCCR1B |= (1 << CS12) | (1 << CS10);
    OCR1A = 15625;
    TIMSK1 |= (1 << OCIE1A);
 
    sei();
}
 
void set_leds_masini(uint8_t rosu, uint8_t galben, uint8_t verde) {
    if(rosu) PORTD |= (1 << LED_AUTO_ROSU); else PORTD &= ~(1 << LED_AUTO_ROSU);
    if(galben) PORTD |= (1 << LED_AUTO_GALBEN); else PORTD &= ~(1 << LED_AUTO_GALBEN);
    if(verde) PORTD |= (1 << LED_AUTO_VERDE); else PORTD &= ~(1 << LED_AUTO_VERDE);
}
 
void set_leds_pietoni(uint8_t rosu, uint8_t verde) {
    if(rosu) PORTB |= (1 << LED_PIETON_ROSU); else PORTB &= ~(1 << LED_PIETON_ROSU);
    if(verde) PORTB |= (1 << LED_PIETON_VERDE); else PORTB &= ~(1 << LED_PIETON_VERDE);
}
 
ISR(INT0_vect) {
    if (current_state == STATE_MASINI_VERDE && cooldown_timer == 0) {
        cerere_traversare = 1;
    }
}
 
ISR(TIMER1_COMPA_vect) {
    if (state_timer > 0) {
        state_timer--;
    }
    if (cooldown_timer > 0) {
        cooldown_timer--;
    }
 
    if (current_state == STATE_PIETONI_VERDE) {
        beep_state = !beep_state;
        if (beep_state) {
            PORTB |= (1 << BUZZER);
        } else {
            PORTB &= ~(1 << BUZZER);
        }
    } else {
        PORTB &= ~(1 << BUZZER);
    }
}
 
int main(void) {
    hardware_init();
 
    set_leds_masini(0, 0, 1);
    set_leds_pietoni(1, 0);
 
    while (1) {
        switch (current_state) {
            case STATE_MASINI_VERDE:
                set_leds_masini(0, 0, 1);
                set_leds_pietoni(1, 0);
 
                if (cerere_traversare == 1) {
                    cerere_traversare = 0;
                    state_timer = 3;
                    current_state = STATE_TRANZITIE_GALBEN;
                }
                break;
 
            case STATE_TRANZITIE_GALBEN:
                set_leds_masini(0, 1, 0);
 
                if (state_timer == 0) {
                    state_timer = 10;
                    current_state = STATE_PIETONI_VERDE;
                }
                break;
 
            case STATE_PIETONI_VERDE:
                set_leds_masini(1, 0, 0);
                set_leds_pietoni(0, 1);
 
                if (state_timer == 0) {
                    cooldown_timer = 10;
                    current_state = STATE_COOLDOWN;
                }
                break;
 
            case STATE_COOLDOWN:
                set_leds_masini(0, 0, 1);
                set_leds_pietoni(1, 0);
 
                current_state = STATE_MASINI_VERDE;
                break;
        }
    }
}

• Etapa 1: Alegerea temei, achizitionarea pieselor si redactarea documentatiei initiale.

• Datasheet ATmega328P
• Laboratoarele de PM (in special Lab-urile de GPIO, Timere si Intreruperi)