Embedded Programming - Working with Bits and Registers

0b10110100      // binary  - every bit is visible
0xB4            // hex     - compact: B=1011, 4=0100
180             // decimal - says nothing about the bits

// all three are IDENTICAL to the compiler

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

~(1 << 5)         ->  1101 1111     (every bit 1, except bit 5)

(1 << 3) | (1 << 1)  ->  0000 1010  (bits 3 AND 1 at once)

#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)

// writes a value of 0 or 1 into a bit, with no branch
#define WRT_BIT(reg, n, v)  ((reg) = ((reg) & ~BIT(n)) | ((v) ? BIT(n) : 0))

// usage examples
SET_BIT(DDRB,  PB5);        // pin 13 becomes an output
SET_BIT(PORTB, PB5);        // pin 13 to HIGH
CLR_BIT(PORTB, PB5);        // pin 13 to LOW
TGL_BIT(PORTB, PB5);        // toggle pin 13

if (CHK_BIT(PIND, PD2)) {   // the button is NOT pressed (pull-up)
    // ...
}

// Say bits 3, 4, 5 of port B form a 3-bit "field" (a value from 0 to 7
// sent to an external circuit), while bits 0, 1, 2 control something
// completely different and must NOT be touched.

// WRONG: wipes out the rest of the register
PORTB = 0b00101000;                    // the field is 5... but bits 0-2 are lost!

// CORRECT: clear only the field, then write the value
PORTB &= ~((1 << PB5) | (1 << PB4) | (1 << PB3));   // 1. clear the field
PORTB |=  (1 << PB5);                                 // 2. write the new value

// General form, with mask and shift
#define FIELD_SET(reg, mask, shift, val) \
    ((reg) = ((reg) & ~((mask) << (shift))) | (((val) & (mask)) << (shift)))

// example: write the value 5 into the 3-bit field starting at position 3
FIELD_SET(PORTB, 0x07, 3, 5);

// Isolate the field with AND, then bring it to position 0 by shifting
uint8_t lowerHalf   = (PORTB & 0x0F);          // bits 0-3, already at position 0

// a field that does NOT start at position 0: shift first, mask after
uint8_t threeBitField = (PORTB >> 3) & 0x07;     // bits 3-5

uint8_t topBit       = (PORTB >> 5) & 0x01;     // a single bit, position 5

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

PORTB |= (1 << PB5);

; translates into:
    in   r24, 0x05      ; 1. READ PORTB into register r24
    ori  r24, 0x20      ; 2. MODIFY: OR with mask 0b00100000
    out  0x05, r24      ; 3. WRITE r24 back into PORTB

// WRONG: re-enables interrupts even if the caller had them disabled
cli();
value = counter;
sei();                      // <-- assumes they were enabled. Not guaranteed!

// CORRECT: save and restore the exact prior state
uint8_t sreg = SREG;         // SREG holds the I bit (Global Interrupt Enable)
cli();
value = counter;             // critical section: nothing can interrupt it
SREG = sreg;                 // restores EXACTLY the previous state

// BEST: macro from the standard AVR library
#include <util/atomic.h>

ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
    value = counter;         // saving and restoring happen automatically
}

// In the AVR header files:
#define PORTB   (*(volatile uint8_t *)0x25)
//               │  │                  └── the register's physical address
//               │  └── cast to a pointer to a volatile byte
//               └── dereference: we work with the VALUE at that address

// So PORTB |= 0x20;  means:
*(volatile uint8_t *)0x25 |= 0x20;

// The same thing can be written explicitly:
volatile uint8_t *portb = (volatile uint8_t *)0x25;
*portb |= (1 << 5);

// ---------- AVR / ATmega328P (Arduino Uno) ----------
DDRB  |= (1 << PB5);            // pin as output
PORTB |= (1 << PB5);            // pin to HIGH
PORTB &= ~(1 << PB5);           // pin to LOW

// ---------- STM32 (F1/F4 series, direct registers) ----------
RCC->APB2ENR |= (1 << 3);       // enable port C's clock
GPIOC->CRH   |= (1 << 20);      // configure pin 13 as output
GPIOC->BSRR   = (1 << 13);      // pin to HIGH  (dedicated register, ATOMIC)
GPIOC->BSRR   = (1 << 29);      // pin to LOW   (bit 13 + 16)

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

// ---------- PIC (16F series) ----------
TRISB &= ~(1 << 5);             // pin as output (0 = output on PIC!)
LATB  |=  (1 << 5);             // pin to HIGH
LATB  &= ~(1 << 5);             // pin to LOW

// Connect 6 LEDs to pins 8...13, that is, to bits 0...5 of port B.
// The LED bar becomes the "binary display" of any 6-bit value.

void show(uint8_t v) {
  PORTB = v & 0x3F;     // bits 0-5 of the value reach the 6 LEDs
  _delay_ms(1500);      // pause, so you have time to read the bar
}

int main(void) {
  DDRB = 0x3F;                    // all 6 pins, outputs

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

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

  // TESTING a bit: the LED on pin 7 shows the answer
  DDRD |= (1 << PD7);
  if (reg & (1 << 5)) PORTD |=  (1 << PD7);   // bit 5 is SET
  else                PORTD &= ~(1 << PD7);   // bit 5 is clear

  while (1) { }
}

// 1. Counting the set bits (Kernighan's algorithm)
uint8_t countBits(uint8_t v) {
  uint8_t n = 0;
  while (v) {
    v &= (v - 1);            // clear the rightmost set bit
    n++;
  }
  return n;
}

// 2. Testing whether a value is a power of 2
bool isPowerOf2(uint8_t v) {
  return v && !(v & (v - 1));
}

// 3. Reversing the order of the bits
uint8_t reverseBits(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. Swapping two values with no temporary variable
void swap(uint8_t *a, uint8_t *b) {
  *a ^= *b;  *b ^= *a;  *a ^= *b;
}

// 5. Extracting the upper and lower nibble
uint8_t nibbleHigh(uint8_t v)  { return (v >> 4) & 0x0F; }
uint8_t nibbleLow(uint8_t v)   { return  v       & 0x0F; }

// ============ LEVEL 1: the Arduino library ============
// advantage: readable right away   drawback: slow, not portable
void blinkArduino() {
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);
  delay(500);
  digitalWrite(13, LOW);
  delay(500);
}

// ============ LEVEL 2: AVR registers, with names ============
// advantage: fast, explicit   drawback: tied to AVR
void blinkRegisters() {
  DDRB  |=  (1 << PB5);
  PORTB |=  (1 << PB5);
  _delay_ms(500);
  PORTB &= ~(1 << PB5);
  _delay_ms(500);
}

// ============ LEVEL 3: your own abstraction layer ============
// advantage: fast AND portable - only this block changes when porting
#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 blinkPortable() {
  LED_INIT();
  LED_ON();     _delay_ms(500);
  LED_OFF();    _delay_ms(500);
}

// We do not have the serial monitor yet (lab 6), so we do not print the
// duration: we make it VISIBLE. Each method keeps a marker LED lit for
// as long as its loop runs. The faster the method, the shorter the
// marker blinks. On an oscilloscope, the pulse width IS the measured duration.

#define N 20000

int main(void) {
  DDRB |= (1 << PB0);                             // the pin being toggled
  DDRD |= (1 << PD5) | (1 << PD6) | (1 << PD7);   // the three markers

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

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

    PORTD |= (1 << PD5);                          // toggling by writing to PINB
    for (i = 0; i < N; i++) { PINB = (1 << PB0); PINB = (1 << PB0); }
    PORTD &= ~(1 << PD5);
    _delay_ms(300);
  }
}