Programare embedded - lucrul cu biți și regiștri

0b10110100      // binar   - se vede fiecare bit
0xB4            // hexa    - compact: B=1011, 4=0100
180             // zecimal - nu spune nimic despre biti

// toate trei sunt IDENTICE pentru compilator

1                 ->  0000 0001     (bitul 0)
1 << 1            ->  0000 0010     (bitul 1)
1 << 2            ->  0000 0100     (bitul 2)
1 << 5            ->  0010 0000     (bitul 5)
1 << 7            ->  1000 0000     (bitul 7)

~(1 << 5)         ->  1101 1111     (toti biti 1, mai putin bitul 5)

(1 << 3) | (1 << 1)  ->  0000 1010  (bitii 3 SI 1 deodata)

#define BIT(n)              (1UL << (n))

#define SET_BIT(reg, n)     ((reg) |=  BIT(n))
#define CLR_BIT(reg, n)     ((reg) &= ~BIT(n))
#define TGL_BIT(reg, n)     ((reg) ^=  BIT(n))
#define CHK_BIT(reg, n)     (((reg) &  BIT(n)) != 0)

// scrie o valoare de 0 sau 1 intr-un bit, fara ramificatie
#define WRT_BIT(reg, n, v)  ((reg) = ((reg) & ~BIT(n)) | ((v) ? BIT(n) : 0))

// exemple de utilizare
SET_BIT(DDRB,  PB5);        // pinul 13 devine iesire
SET_BIT(PORTB, PB5);        // pinul 13 pe HIGH
CLR_BIT(PORTB, PB5);        // pinul 13 pe LOW
TGL_BIT(PORTB, PB5);        // comuta pinul 13

if (CHK_BIT(PIND, PD2)) {   // butonul NU este apasat (pull-up)
    // ...
}

// Sa zicem ca bitii 3, 4, 5 ai portului B formeaza un "camp" de 3 biti
// (o valoare de la 0 la 7 trimisa catre un circuit exterior), iar bitii
// 0, 1, 2 comanda cu totul altceva si NU trebuie atinsi.

// GRESIT: sterge tot restul registrului
PORTB = 0b00101000;                    // campul are valoarea 5... dar bitii 0-2 s-au pierdut!

// CORECT: se sterge doar campul, apoi se scrie valoarea
PORTB &= ~((1 << PB5) | (1 << PB4) | (1 << PB3));   // 1. curata campul
PORTB |=  (1 << PB5);                                 // 2. scrie valoarea noua

// Forma generala, cu masca si deplasare
#define FIELD_SET(reg, mask, shift, val) \
    ((reg) = ((reg) & ~((mask) << (shift))) | (((val) & (mask)) << (shift)))

// exemplu: scrie valoarea 5 in campul de 3 biti care incepe la pozitia 3
FIELD_SET(PORTB, 0x07, 3, 5);

// Se izoleaza campul cu ȘI, apoi se aduce la pozitia 0 prin deplasare
uint8_t jumatateaDeJos = (PORTB & 0x0F);          // bitii 0-3, incep la pozitia 0

// camp care NU incepe de la pozitia 0: intai deplasare, apoi masca
uint8_t campul3biti    = (PORTB >> 3) & 0x07;     // bitii 3-5

uint8_t bitulDeSus     = (PORTB >> 5) & 0x01;     // un singur bit, pozitia 5

#define FIELD_GET(reg, mask, shift)  (((reg) >> (shift)) & (mask))

PORTB |= (1 << PB5);

; se traduce in:
    in   r24, 0x05      ; 1. CITESTE PORTB in registrul r24
    ori  r24, 0x20      ; 2. MODIFICA: SAU cu masca 0b00100000
    out  0x05, r24      ; 3. SCRIE r24 inapoi in PORTB

// GRESIT: reactiveaza intreruperile chiar daca apelantul le avea oprite
cli();
valoare = contor;
sei();                      // <-- presupune ca erau active. Nu e garantat!

// CORECT: se salveaza si se restaureaza starea exacta
uint8_t sreg = SREG;        // SREG contine bitul I (Global Interrupt Enable)
cli();
valoare = contor;           // sectiune critica: nimic nu o poate intrerupe
SREG = sreg;                // restaureaza EXACT starea anterioara

// CEL MAI BINE: macro din biblioteca standard AVR
#include <util/atomic.h>

ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    valoare = contor;       // salvarea si restaurarea se fac automat
}

// In fisierele antet ale AVR:
#define PORTB   (*(volatile uint8_t *)0x25)
//               │  │                  └── adresa fizica a registrului
//               │  └── conversie la pointer spre octet volatil
//               └── dereferentiere: lucram cu VALOAREA de la acea adresa

// Deci PORTB |= 0x20;  inseamna:
*(volatile uint8_t *)0x25 |= 0x20;

// Acelasi lucru se poate scrie explicit:
volatile uint8_t *portb = (volatile uint8_t *)0x25;
*portb |= (1 << 5);

// ---------- AVR / ATmega328P (Arduino Uno) ----------
DDRB  |= (1 << PB5);            // pin ca iesire
PORTB |= (1 << PB5);            // pin pe HIGH
PORTB &= ~(1 << PB5);           // pin pe LOW

// ---------- STM32 (seria F1/F4, registre directe) ----------
RCC->APB2ENR |= (1 << 3);       // porneste ceasul portului C
GPIOC->CRH   |= (1 << 20);      // configureaza pinul 13 ca iesire
GPIOC->BSRR   = (1 << 13);      // pin pe HIGH  (registru dedicat, ATOMIC)
GPIOC->BSRR   = (1 << 29);      // pin pe LOW   (bitul 13 + 16)

// ---------- ESP32 ----------
GPIO.enable_w1ts   = (1 << 2);  // pin ca iesire
GPIO.out_w1ts      = (1 << 2);  // pin pe HIGH  (write-1-to-set, ATOMIC)
GPIO.out_w1tc      = (1 << 2);  // pin pe LOW   (write-1-to-clear)

// ---------- PIC (seria 16F) ----------
TRISB &= ~(1 << 5);             // pin ca iesire (0 = iesire la PIC!)
LATB  |=  (1 << 5);             // pin pe HIGH
LATB  &= ~(1 << 5);             // pin pe LOW

// Legati 6 LED-uri pe pinii 8...13, adica pe bitii 0...5 ai portului B.
// Bara de LED-uri devine "afisajul binar" al oricarei valori pe 6 biti.

void arata(uint8_t v) {
  PORTB = v & 0x3F;     // bitii 0-5 ai valorii ajung pe cele 6 LED-uri
  _delay_ms(1500);      // pauza, ca sa aveti timp sa cititi bara
}

int main(void) {
  DDRB = 0x3F;                    // toti cei 6 pini, iesiri

  uint8_t reg = 0b00001010;
  arata(reg);                     // initial : 001010

  reg |=  (1 << 5);   arata(reg); // set b5 : 101010
  reg &= ~(1 << 1);   arata(reg); // clr b1 : 101000
  reg ^=  (1 << 3);   arata(reg); // tgl b3 : 100000

  // TESTAREA unui bit: LED-ul de pe pinul 7 arata raspunsul
  DDRD |= (1 << PD7);
  if (reg & (1 << 5)) PORTD |=  (1 << PD7);   // bitul 5 este SETAT
  else                PORTD &= ~(1 << PD7);   // bitul 5 este sters

  while (1) { }
}

// 1. Numararea bitilor setati (algoritmul lui Kernighan)
uint8_t numaraBiti(uint8_t v) {
  uint8_t n = 0;
  while (v) {
    v &= (v - 1);            // sterge cel mai din dreapta bit setat
    n++;
  }
  return n;
}

// 2. Testarea daca o valoare este putere a lui 2
bool estePutereDe2(uint8_t v) {
  return v && !(v & (v - 1));
}

// 3. Inversarea ordinii bitilor
uint8_t inverseazaBiti(uint8_t v) {
  uint8_t r = 0;
  for (uint8_t i = 0; i < 8; i++) {
    r = (r << 1) | (v & 1);
    v >>= 1;
  }
  return r;
}

// 4. Schimbarea a doua valori fara variabila temporara
void interschimba(uint8_t *a, uint8_t *b) {
  *a ^= *b;  *b ^= *a;  *a ^= *b;
}

// 5. Extragerea nibble-ului superior si inferior
uint8_t nibbleSus(uint8_t v)  { return (v >> 4) & 0x0F; }
uint8_t nibbleJos(uint8_t v)  { return  v       & 0x0F; }

// ============ NIVELUL 1: biblioteca Arduino ============
// avantaj: lizibil imediat   dezavantaj: lent, neportabil
void blinkArduino() {
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
}

// ============ NIVELUL 2: registre AVR, cu nume ============
// avantaj: rapid, explicit   dezavantaj: legat de AVR
void blinkRegistri() {
  DDRB  |=  (1 << PB5);
  PORTB |=  (1 << PB5);
  _delay_ms(500);
  PORTB &= ~(1 << PB5);
  _delay_ms(500);
}

// ============ NIVELUL 3: strat de abstractizare propriu ============
// avantaj: rapid SI portabil - se schimba doar acest bloc la portare
#if defined(__AVR__)
  #define LED_DIR_REG   DDRB
  #define LED_OUT_REG   PORTB
  #define LED_PIN_NR    PB5
#elif defined(ESP32)
  #define LED_DIR_REG   GPIO.enable
  #define LED_OUT_REG   GPIO.out
  #define LED_PIN_NR    2
#endif

#define LED_INIT()    (LED_DIR_REG |=  (1UL << LED_PIN_NR))
#define LED_ON()      (LED_OUT_REG |=  (1UL << LED_PIN_NR))
#define LED_OFF()     (LED_OUT_REG &= ~(1UL << LED_PIN_NR))
#define LED_TOGGLE()  (LED_OUT_REG ^=  (1UL << LED_PIN_NR))

void blinkPortabil() {
  LED_INIT();
  LED_ON();     _delay_ms(500);
  LED_OFF();    _delay_ms(500);
}

// Nu avem inca monitorul serial (lucrarea 6), deci nu tiparim durata:
// o facem VIZIBILA. Fiecare metoda tine aprins un LED-martor cat timp
// ruleaza bucla. Cu cat metoda e mai rapida, cu atat martorul clipeste
// mai scurt. Pe osciloscop, latimea impulsului ESTE durata masurata.

#define N 20000

int main(void) {
  DDRB |= (1 << PB0);                             // pinul care se comuta
  DDRD |= (1 << PD5) | (1 << PD6) | (1 << PD7);   // cei trei martori

  uint16_t i;
  while (1) {
    PORTD |= (1 << PD7);                          // varianta cu functie
    for (i = 0; i < N; i++) { digitalWrite(8, HIGH); digitalWrite(8, LOW); }
    PORTD &= ~(1 << PD7);
    _delay_ms(300);

    PORTD |= (1 << PD6);                          // varianta cu registru
    for (i = 0; i < N; i++) { PORTB |= (1 << PB0); PORTB &= ~(1 << PB0); }
    PORTD &= ~(1 << PD6);
    _delay_ms(300);

    PORTD |= (1 << PD5);                          // comutare prin scriere in PINB
    for (i = 0; i < N; i++) { PINB = (1 << PB0); PINB = (1 << PB0); }
    PORTD &= ~(1 << PD5);
    _delay_ms(300);
  }
}