> For the complete documentation index, see [llms.txt](https://panav.gitbook.io/robotics-handbook/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://panav.gitbook.io/robotics-handbook/embedded-systems-for-robotics/microcontrollers/microcontrollers-advanced-theory.md).
# Microcontrollers (Advanced Theory)
### **1. Registers: The CPU's Fast Storage**
Registers are small, high-speed memory locations within the CPU used to store data, addresses, or control flags during operations. They enable rapid access to critical information, reducing latency compared to external memory.
### **Types of Registers**
| Register Type | Purpose | Example (ARM Cortex-M) |
| ------------------------ | ---------------------------------------------------------------------- | ------------------------------- |
| **General-Purpose** | Store intermediate results or operands for arithmetic/logic operations | R0-R12 (ARM) |
| **Program Counter (PC)** | Holds the address of the next instruction to execute | PC (E.g., `0x08000100`) |
| **Stack Pointer (SP)** | Points to the top of the stack for saving context during interrupts | MSP (Main SP), PSP (Process SP) |
| **Status Register** | Tracks CPU state (e.g., carry, zero, overflow flags) | APSR (Application Status Reg) |
| **Control Registers** | Configure peripherals (e.g., timers, PWM, UART) | TIM2\_CR1 (Timer 2 Control Reg) |
**Example:**\
To enable a timer interrupt on an STM32:
```
cTIM2_DIER |= (1 << 0); // Enable update interrupt for Timer 2
```
### **2. Interrupts: Real-Time Responsiveness**
Interrupts allow the CPU to pause current tasks and handle urgent events (e.g., sensor input, timer overflow). They ensure timely responses in applications like robotics and IoT.
### **Interrupt Workflow**
1. **Event Trigger:** A peripheral (e.g., timer, ADC) raises an interrupt flag.
2. **Priority Check:** The Interrupt Controller (NVIC) prioritizes interrupts.
3. **Context Save:** CPU pushes registers (PC, SP, status) onto the stack.
4. **ISR Execution:** Jumps to the Interrupt Service Routine (ISR) to handle the event.
5. **Context Restore:** Registers are popped, and the CPU resumes prior tasks.
**Example (Arduino External Interrupt):**
```
cppvoid setup() {
attachInterrupt(digitalPinToInterrupt(2), buttonPress, FALLING);
}
void buttonPress() {
// Handle button press
}
```
### **3. Pulse Width Modulation (PWM): Precision Control**
 
PWM generates variable-width pulses to control power delivery. The **duty cycle** (ON-time vs. period) determines the effective voltage.
### **PWM Configuration**
* **Frequency:** Set by the timer’s auto-reload register (e.g., 1 kHz → 1 ms period).
* **Duty Cycle:** Determined by the capture/compare register (CCR).
**Formula:**
Duty Cycle (%)=(CCR ValueARR Value)×100Duty Cycle (%)=(ARR ValueCCR Value)×100
**Example (STM32 PWM for Motor Control):**
```
cTIM3->ARR = 999; // 1 kHz frequency (assuming 1 MHz clock)
TIM3->CCR1 = 300; // 30% duty cycle
TIM3->CCER |= TIM_CCER_CC1E; // Enable PWM output
```
### **4. Memory Architecture**
Microcontrollers use Harvard or Von Neumann architectures to manage instructions and data.
### **Harvard Architecture**
* **Separate Buses:** Instructions and data have dedicated buses (faster, parallel access).
* **Common in MCUs:** STM32, PIC, AVR.
### **Von Neumann Architecture**
* **Shared Bus:** Single bus for instructions/data (simpler, slower).
* **Example:** Legacy systems (e.g., Intel 8051).
### **5. Peripherals and Interfaces**
| Peripheral | Function | Example Use Case |
| ------------------- | ------------------------------------------------------------ | ---------------------------- |
| **Timers/Counters** | Generate PWM, measure intervals, count events | Motor speed control |
| **ADC/DAC** | Convert analog signals to digital (ADC) and vice versa (DAC) | Sensor reading, audio output |
| **UART/SPI/I2C** | Serial communication protocols | GPS module, OLED display |
| **GPIO** | General-purpose input/output pins | Button input, LED control |
**Example (ADC for Temperature Sensor):**
```
cADC1->CR2 |= ADC_CR2_ADON; // Enable ADC
ADC1->CR2 |= ADC_CR2_SWSTART; // Start conversion
while (!(ADC1->SR & ADC_SR_EOC)); // Wait for conversion
int temp = ADC1->DR; // Read digital value
```
### **6. Clock Systems**
Clocks synchronize operations. Common sources:
* **Internal RC Oscillator:** Low accuracy, low power (e.g., 8 MHz).
* **External Crystal:** High accuracy (e.g., 16 MHz for Arduino).
* **PLL:** Multiplies clock speed (e.g., STM32’s 72 MHz from 8 MHz).
**Clock Tree Example (STM32):**
```
textHSI → PLL → SYSCLK → APB1/APB2
```
### **7. Power Management**
* **Sleep Modes:** Reduce power during inactivity (e.g., STOP, STANDBY).
* **Peripheral Clocks:** Disable unused peripherals to save power.
**Example (Arduino Low-Power Mode):**
```
cpp#include
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
sleep_cpu();
```
### **8. Real-World Application: Robotic Arm Control**
1. **Sensors:** Potentiometers (ADC) measure joint angles.
2. **PWM:** Control servo motors for precise movement.
3. **Interrupts:** Handle emergency stop button presses.
4. **UART:** Send/receive commands from a PC.
**Code Snippet (Servo Control):**
```
cppvoid setServoAngle(int angle) {
int pulseWidth = map(angle, 0, 180, 1000, 2000); // 1-2 ms pulse
digitalWrite(servoPin, HIGH);
delayMicroseconds(pulseWidth);
digitalWrite(servoPin, LOW);
}
```