CSE 421 · Embedded Systems · Dr. Ahmed Osman MahmoudEmbedded MidKit

• 25 marks, all essay — no MCQ this year.كله مقالي؛ السنة اللي فاتت كانت 10 MCQ + 6 + 9 كود.
• Scope: Lectures 1–5 (up to the end of Timers), Sheet 1, Sheet 2.INT0 و USART و ADC Vref برّه.
• No datasheet: prescaler / mode values are given, but you must know the registers and their bits.الجداول بتتدّى، أسماء الريجسترز والبتات لأ — شوف Registers.
• Every code answer starts with #define F_CPU + the #include lines (they carry marks), then the SET / CLEAR / TOGGLE / GET macros.الـ includes عليها درجة؛ والماكروز دي طريقة المعيدة. شوف Sheet 2 Ex 0.
• Last midterm: power 4 · power mode 2 · timer code 9 · theory 10.الكود والحسابات أكتر من نص الدرجة.

• Preload: slides & model answer use 255 − ticks; mathematically it is 256 − ticks (Sheet 2 code uses 256).فرق tick واحد؛ اكتب القانون اللي بتستخدمه صريح.
• Timer1 2 s: slide writes 49910; correct 65536 − 15625 = 49911.فرق tick واحد.
• Vibration example: TCNT1 * (1024/4000) is integer division = 0 in C.غلطة برمجية في السلايد؛ اضرب الأول.
• Mid 2026 Q3 model code stops Timer0 in the ISR and never restarts it.الحل المصحح في Mid 2026 Question 3.
• Heartbeat count0() repeats CS00; correct is CS02 + CS01 + CS00.تكرار غلط في السلايد.

• Embedded system = a combination of computer hardware and software, either fixed in capability or programmable, designed for a specific function within a larger system.نظام هاردوير + سوفتوير معمول عشان يعمل وظيفة محددة، وهو جزء من حاجة أكبر.
• Second definition: information-processing systems integrated into a larger product.تعريف تاني: نظام بيعالج بيانات بس مدفون جوه منتج أكبر.
• Examples: car, train, electronic devices, mobile phone, smart house (lighting/heating).أمثلة: العربية، القطر، الموبايل، البيت الذكي.
• We buy these products not for information processing itself but for driving, transportation, communication, convenience; the ES is an essential part of achieving that purpose.إنت مش بتشتري العربية عشان "تعالج بيانات"، بتشتريها عشان تسوق؛ الـ ES هو اللي بيخلي ده يحصل.

• CPU: executes instructions.بينفّذ الأوامر.
• Memory: stores code and data (RAM, ROM, Flash).بتخزن البرنامج والبيانات.
• Peripherals: I/O interfaces (timers, GPIO, ADC, UART, SCI, USB, Ethernet, WLAN).الطرفيات اللي بتكلم العالم الخارجي.
• Bus systems: communication pathways (data bus, address bus, control bus).الطرق اللي بتوصل المكونات ببعض.
• Block diagram: Processor + mem on a system bus; Control (output) drives motor/light, Observe (input) reads a temperature sensor.الرسمة: البروسيسور بيقرا sensor (input) وبيحرك motor (output).

• Embedded processors (MCUs) vs PC processors: lower clock speeds, integrated memory, integrated I/O (A/D, D/A, PWM, CAN), higher environmental specs.الـ MCU سرعته أقل بس فيه الميموري والـ I/O جواه ومستحمل ظروف أصعب.

• Microcontroller: microprocessor + memory + I/O lines on a single chip (VLSI).ميكروكنترولر = بروسيسور + ميموري + I/O على شريحة واحدة.
• An embedded product does one task only; one application is burned into ROM.المنتج المدمج بيعمل حاجة واحدة وبرنامجه محروق في الـ ROM.
• A computer runs any number of applications: RAM + OS loads programs into RAM.الكمبيوتر بيشغل أي برنامج عن طريق الـ OS.

• Additional factors: Cost, Environment (temperature, robustness), Peripheral support (ADC, DAC, PWM, I2C, SPI, UART), Scalability (future upgrades).عوامل إضافية: السعر، البيئة، الطرفيات، وقابلية التطوير.

• Step 0 — Available power = Total budget − (sensors + communication + display).الأول: الميزانية المتاحة للـ MCU = الكلي − باقي المكونات.
• Step 1 — Weighted power P = P_active × active% + P_sleep × sleep%.احسب متوسط استهلاك كل MCU حسب نسبة الشغل والنوم.
• Check every MCU is ≤ available power.اتأكد إن الكل جوه الميزانية.
• Step 2 — Performance: reject any MCU with CPU clock below the required frequency.ارفض أي MCU سرعته أقل من المطلوب.
• Step 3 — Memory: prefer more Flash/SRAM for data-heavy applications.بعدها قارن الميموري.
• Final decision with a reason line (power + performance + memory).اختم بجملة قرار فيها السبب.

• 8-bit AVR: processes 8 bits (1 byte) at a time.بيشتغل على بايت واحد كل مرة.
• Modified Harvard architecture: separate paths for instructions and data → fetch both at the same time → faster.طريق للبرنامج وطريق للداتا، فبيجيب الاتنين مع بعض.
• RISC: simple instructions, 1–2 clock cycles each.أوامر بسيطة بتاخد cycle أو اتنين.
• 32 general-purpose registers: fast "scratchpads" inside the CPU.32 مسجل جوه الـ CPU للحسابات السريعة.
• Throughput 16 MIPS @ 16 MHz (~1 MIPS per MHz). With 8 MHz → ~8 MIPS.مليون أمر لكل ميجاهرتز؛ لو الكريستال 8 ميجا يبقى 8 MIPS.
• Memory: Flash 32 KB (program, non-volatile) · SRAM 2 KB (variables, stack, volatile) · EEPROM 1 KB (settings, non-volatile).فلاش للبرنامج، SRAM للمتغيرات وبتتمسح، EEPROM للإعدادات وبتفضل.
• Clock: max 16 MHz; internal RC 1 MHz default (not accurate); external crystal 1–16 MHz (8 & 16 common).أقصى 16 ميجا، الداخلي 1 ميجا افتراضي، والكريستال الخارجي أدق.
• 32 I/O lines = 4 ports (A, B, C, D) × 8 pins.32 pin في 4 بورتات.
• Peripherals: Timer0 (8-bit, 0–255), Timer1 (16-bit, 0–65535), Timer2 (8-bit, async with external clock), ADC 8-channel 10-bit (0–1023), PWM, USART, SPI, TWI (I²C, 2 wires SDA/SCL), Watchdog Timer.الطرفيات: 3 تايمرز، ADC، PWM، اتصالات، و Watchdog.
• Watchdog Timer = safety guard: resets the MCU automatically if the program hangs.لو البرنامج علّق، الـ watchdog بيعمل reset.
• Special Function Registers (SFRs): memory addresses that control features (pin direction, timers, interrupts, ADC/UART) — "control switches".مسجلات تحكم: إنت بتكتب فيها عشان تشغّل وتظبط الطرفيات.
• Packages: PDIP (40 pins, through-hole, breadboard, easy, bulkier) vs TQFP/MLF (square, surface-mount, compact, hard to hand-solder, better heat for MLF).PDIP للتجارب والطلبة، TQFP للمنتجات التجارية.
• Applications: consumer electronics, automotive (window motors, dashboards), industrial automation, home automation, education.أماكن استخدامه.

• Idle use cases: digital clock waiting for 1 s timer interrupt, serial waiting for data, smart sensors.Idle لما تستنى event والطرفيات لازم تفضل شغالة.
• ADC Noise Reduction: digital circuits make noise → unstable ADC readings → stop them for precise analog measurement (LM35, gas sensor, medical). Used instead of Idle because it reduces digital noise interference.بيوقف الضوضاء الرقمية عشان القراية تبقى دقيقة.
• Power-down: remote control asleep until a button, temperature logger, IoT node; can run months/years on a coin cell.للأجهزة اللي بتشتغل نادرًا.
• Power-save: digital clock with 32.768 kHz crystal, data loggers, IoT nodes that wake periodically.لما تحتاج تصحى كل فترة لوحدك.
• Standby trade-off: Power-down = lower power, slower wake-up · Standby = slightly higher power, faster wake-up.Standby أغلى شوية بس أسرع في الصحيان.
• Extended Standby vs Standby: the only difference is that async Timer2 keeps running in Extended Standby.الفرق الوحيد إن Timer2 شغال.

• P = I × V.القدرة = التيار × الجهد.
• Worst case → use maximum current; best case → use minimum (if min is empty, use typical).أسوأ حالة = أكبر تيار، أفضل حالة = أقل تيار.
• P_total = V·I_active·active% + V·I_idle·idle%.اضرب كل باور في نسبته واجمع.

• Firmware: special software stored in non-volatile memory (Flash, EEPROM, ROM) that directly controls the hardware (not running on a PC OS).سوفتوير متخزن في ميموري مبتتمسحش وبيكلم الهاردوير مباشرة.
• Four layers (bottom → top): Driver → HAL → Middleware → Application.4 طبقات من تحت لفوق.
• Driver layer: talks directly to hardware registers and pins.بيكلم الريجسترز والـ pins.
• HAL: bridge between hardware and software, hides hardware-specific details.بيخبّي تفاصيل الهاردوير.
• Middleware: reusable services (communication protocols, data processing).خدمات جاهزة متكررة.
• Application: the actual logic, what the product does (e.g. blinking an LED).منطق المنتج نفسه.
• Advantages: Modularity, Portability (move code to other MCUs), Maintainability (fix one layer only).مميزات: تقسيم، نقل لكنترولر تاني، صيانة أسهل.
• Disadvantage: too many layers slow real-time systems (extra function calls and data passing).عيب: طبقات كتير = بطء في الـ real time.

• Selection criteria: Efficiency, Performance, Ease of use, Portability, Maintainability, Readability, Integration (IDE support).معايير اختيار اللغة.

• Code → hex: Writing firmware → Compilation (object files) → Linking (combine & arrange in memory) → Hex file generation → upload.كتابة ← compile ← link ← hex ← تحميل.
• IDEs: Microchip Studio, Eclipse. GCC: open-source, many languages, targets ARM, AVR, MIPS, PowerPC.GCC هو الكومبايلر المستخدم.

• A data type tells the compiler what kind of value and how much memory.النوع بيحدد شكل القيمة وحجمها.
• Why choose carefully: (1) Performance & memory — sensor 0–255 → uint8_t (2) Portability — typedef/headers (3) Type safety (4) Readability & maintenance (5) Data standardization across compilers.5 أسباب لاختيار النوع صح.
• Fixed-width types int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t need #include <stdint.h>.لازم stdint.h.
• uint8_t 0–255 · int8_t −128..127 · uint16_t 0–65535 · int = 2 or 4 bytes (compiler-dependent).حجم int بيختلف، عشان كده بنستخدم الأنواع الثابتة.

• 4 ports A, B, C, D; each has 3 registers:كل بورت ليه 3 مسجلات.
• DDRx (Data Direction): 1 = output, 0 = input.يحدد اتجاه الـ pin.
• PORTx (Data): writes output value; for an input pin, 1 enables the internal pull-up.بيطلّع قيمة، أو بيشغّل الـ pull-up لو الـ pin input.
• PINx (Input): read-only, reads the live pin level.بتقرا منه حالة الـ pin.
• Floating input = unstable readings; pull-up ties it weakly to Vcc → reads stable 1 when nothing drives it.الـ pull-up بيمنع الـ pin يفضل "عايم".
• Pull-up rule: DDR bit = 0 then PORT bit = 1; read from PINx.input + اكتب 1 في PORT.

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

SET(DDRX, i);          // pin i output        (DDRX |= (1<<i))
SET(PORTX, i);         // drive HIGH
CLEAR(PORTX, i);       // drive LOW
TOGGLE(PORTX, i);      // toggle
CLEAR(DDRX, i);        // pin i input
SET(PORTX, i);         // + enable internal pull-up
k = GET(PINX, i);      // read pin i (0 or 1)

• 8 LEDs on Port D toggle every 500 ms while an active-low switch on PA3 is ON; F = 9 MHz.المثال: لمبات بورت D تقلب كل نص ثانية لما السويتش يتداس.
• #define F_CPU 9000000UL before <util/delay.h>; DDRD = 0xFF; PA3 input + pull-up; toggle PORTD ^= 0xFF; debounce _delay_ms(20).عرّف F_CPU قبل delay.h، واعمل debounce بـ 20ms.
• Active-low → pressed reads 0.active-low يعني المضغوط = 0.

#define F_CPU 9000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <stdint.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define L_SW   3                  /* PA3: active-low switch */
#define DELAY  500                /* ms */

int main(void)
{
    /* Step 1: Port D as output (8 LEDs). */
    DDRD = 0xFF;

    /* Step 2: PA3 input + internal pull-up. */
    CLEAR(DDRA, L_SW);
    SET(PORTA, L_SW);

    uint8_t prev = 1, cur;
    while (1)
    {
        cur = GET(PINA, L_SW);
        if (cur != prev)
        {
            _delay_ms(20);                    /* debounce */
            cur = GET(PINA, L_SW);
            if (cur != prev)
            {
                prev = cur;
                if (cur == 0)                 /* 0 = pressed (active-low) */
                {
                    PORTD ^= 0xFF;            /* toggle all 8 LEDs */
                    _delay_ms(DELAY);
                }
            }
        }
    }
    return 0;
}

• Flatten: all code directly in main(), no modularization.كل الكود جوه main على طول.
• Flatten: low abstraction, highest speed (no calls, no macro expansion), low maintainability, hard debugging/scalability.أسرع حاجة بس صعب تصلحه أو تكبّره.
• Macro-based: #define macros replaced inline by the preprocessor → no call overhead → efficient.الماكرو بيتنسخ مكانه، فمفيش تكلفة استدعاء.
• Function-based: functions for set/clear/toggle, pointers to register addresses (volatile uint8_t *var).دوال بتاخد عنوان الريجستر.
• Function-based: best for large projects, slight performance penalty (call overhead), highly maintainable, easy debugging, fits HAL/drivers.أنضف وأسهل صيانة بس أبطأ سنة.

• Function-based is larger because of stack usage, call frames and return instructions.الحجم الزيادة من الـ stack والاستدعاء والرجوع.
• Modern compilers can inline small functions automatically → both speed and structure.الكومبايلر ممكن يعمل inline ويجمع المزايا.

// Macro-based
#define SET_BIT(var,bit) ((var) |=  (1<<(bit)))
#define CLR_BIT(var,bit) ((var) &= ~(1<<(bit)))
#define TOG_BIT(var,bit) ((var) ^=  (1<<(bit)))
// Function-based
void TOG_BIT(volatile uint8_t *var, uint8_t bit){ *var ^= (1<<bit); }
TOG_BIT(&PORTD, 3);   // pass the register address

• PWM = control power by switching the signal ON/OFF very fast. Duty cycle = ON time ratio; average voltage ∝ duty.بنتحكم في القدرة بالتقطيع السريع؛ الـ duty هو نسبة الـ ON.
• 50% → half speed; 100% → full speed. Used for DC motor speed, servo angle, LED brightness; saves energy (switches power instead of reducing voltage).استخداماته وميزته إنه مش بيهدر طاقة.
• Software PWM: code toggles a pin with delays. Cons: accuracy issues (delays not precise) + high CPU usage (CPU stuck in delay loops). Pros: easy.بالكود: سهل بس مش دقيق وبيستهلك الـ CPU.
• Hardware PWM: timers generate it automatically → precise, stable, frees the CPU for sensors/communication. Needs timer knowledge.بالتايمر: دقيق والـ CPU فاضي لحاجات تانية.
• Example (50 Hz, 16 MHz, PA6 out, switch PC4): period 20 ms; DELAY_H = 20·i/100, DELAY_L = 20 − DELAY_H; duty 90→0 step 10; each level repeated 100 times (100 × 20 ms = 2 s).المثال: كل مستوى duty بيتكرر 100 مرة = 2 ثانية.

• A hardware timer is a counter that ticks from a fixed clock: measures time, schedules work, generates signals without busy-waiting.عداد هاردوير بيعدّ لوحده من غير ما يشغل الـ CPU.
• Benefits: precise timing, periodic tasks (interrupt every 10 ms), PWM generation, input capture (timestamp edges → pulse width/frequency), reduce CPU load, synchronizing/scheduling, event counting (encoder ticks).7 فوايد للتايمر.
• Timer = counts internal clock pulses (measures time). Counter = counts external pulses on a pin (measures events).تايمر بيعدّ كلوك داخلي، كاونتر بيعدّ نبضات خارجية.

• Prescaler = frequency divider between F_CPU and the timer → slows the timer clock → longer intervals without changing CPU speed.مقسّم تردد بيبطّأ التايمر بس، مش الـ CPU.
• Values for Timer0/1: 1, 8, 64, 256, 1024.القيم المتاحة.
• f_timer = F_CPU / N · T_tick = N / F_CPU.سرعة التايمر وزمن التكة.
• T_overflow = N × (MAX+1) / F_CPU (8-bit: ×256, 16-bit: ×65536).زمن الـ overflow.
• Why important: without it the 8-bit timer at 1 MHz overflows every 256 µs (too short). With N = 64 → 16.384 ms (~61 overflows/s) → count overflows for seconds.من غيره التايمر بيخلص بسرعة جدًا.

• TCNT0: 8-bit counter holding the current count (0x00–0xFF); read it or write a start value; at 255→0 it overflows (TOV0).العداد نفسه؛ ممكن تكتب فيه قيمة بداية.
• OCR0: compare value; when TCNT0 == OCR0 → compare match → toggle/set/clear OC0 (PB3), compare interrupt (OCIE0), reset timer (CTC), set duty (PWM).القيمة اللي التايمر بيتقارن بيها.
• TCCR0: controls mode (WGM), clock source/prescaler (CS), OC0 behaviour (COM).مسجل التحكم.
• TCCR0 bit order (7→0): FOC0 · WGM00 · COM01 · COM00 · WGM01 · CS02 · CS01 · CS00.احفظ الترتيب ده؛ لاحظ WGM00 في bit 6 و WGM01 في bit 3.

• CS02:0: 000 stopped · 001 clk/1 · 010 /8 · 011 /64 · 100 /256 · 101 /1024 · 110 external T0 falling · 111 external T0 rising.الدكتور هيديك الجدول ده، بس لازم تعرف إنه في TCCR0.

• WGM01:00: 00 Normal (TOP 0xFF) · 01 PWM Phase Correct · 10 CTC (TOP = OCR0) · 11 Fast PWM.أوضاع التشغيل.

• COM01:00 non-PWM: 00 disconnected · 01 toggle · 10 clear · 11 set OC0 on match. Fast PWM: 10 non-inverting (clear on match, set at BOTTOM) · 11 inverting.سلوك pin الـ OC0.

• Counter unit internal signals: count (inc/dec by 1), direction, clear, clkT0, TOP (reached 0xFF or OCR0), BOTTOM (reached 0x00).إشارات العداد الداخلية.
• Output Compare Unit: continuously compares TCNT0 with OCR0 → on match sets OCF0 and (if OCIE0 enabled) raises a compare interrupt.بيقارن وبيرفع OCF0.
• Waveform generator: uses the match signal to drive OC0 according to WGM01:0 and COM01:0.بيطلّع الموجة على الـ pin.

• Timer counts 0x00 (BOTTOM) → 0xFF (TOP) then overflows back to 0.بيعد لفوق لحد 255 ويرجع صفر.
• On overflow TOVn is set automatically → poll it or use the overflow ISR TIMERn_OVF_vect (enable with TIMSK TOIEn).الـ flag بيترفع؛ يا تراقبه يا تستخدم interrupt.
• Best for long delays / low-frequency square waves, especially when the delay exceeds one overflow N_MAX × 2ⁿ / F_CPU.مناسب للتأخيرات الطويلة.
• Settings: WGM01 = 0, WGM00 = 0; prescaler 1024 → CS02 = 1, CS01 = 0, CS00 = 1.البتات.
• T_OV = N × 256 / F_CPU; N_OV = Delay / T_OV.عدد مرات الـ overflow المطلوبة.
• Preload method (one overflow): ticks = Delay × F_CPU / N, TCNT = 256 − ticks (16-bit: 65536 − ticks).لو التأخير أقل من overflow واحد: ابدأ العد من قيمة.
• Polling: wait for TOV0, clear it by writing 1: TIFR |= (1<<TOV0);.الـ flag بيتمسح بكتابة 1 مش 0.

#define F_CPU 8000000UL
#include <avr/io.h>
#include <stdint.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define LED_PIN 0                 /* PB0 */

void Timer0_Init(void)
{
    TCCR0 = 0;                    /* Step 1: stop */
    CLEAR(TCCR0, WGM00);          /* Step 2: Normal mode */
    CLEAR(TCCR0, WGM01);
    TCNT0 = 0;                    /* Step 3: counter */
    SET(TCCR0, CS02);             /* Step 7: N = 1024 → starts */
    CLEAR(TCCR0, CS01);
    SET(TCCR0, CS00);
}

void Delay_2_Seconds(void)
{
    uint8_t overflow_count = 0;
    while (overflow_count < 61)
    {
        while (GET(TIFR, TOV0) == 0);   /* wait for overflow */
        SET(TIFR, TOV0);                /* clear flag by writing 1 */
        overflow_count++;
    }
}

int main(void)
{
    SET(DDRB, LED_PIN);           /* PB0 output */
    Timer0_Init();
    while (1)
    {
        TOGGLE(PORTB, LED_PIN);
        Delay_2_Seconds();
    }
    return 0;
}

• ISR = special function executed when an interrupt occurs (e.g. timer overflow) → react automatically instead of polling.دالة بتشتغل لوحدها لما يحصل الحدث بدل ما تفضل تراقب.
• Syntax: ISR(vector_name){ ... } (macro from avr-gcc, #include <avr/interrupt.h>).الصيغة.
• Vectors: TIMER0_OVF_vect, TIMER0_COMP_vect, TIMER1_OVF_vect, TIMER1_COMPA_vect, TIMER1_COMPB_vect, TIMER1_CAPT_vect, TIMER2_OVF_vect, TIMER2_COMP_vect, INT0_vect.احفظ الأسماء دي حرفيًا.
• Upon reset all interrupts are disabled (masked); SREG I-bit (bit 7) = 0.بعد الـ reset كل الـ interrupts مقفولة.
• Two levels must be enabled: peripheral enable (e.g. TIMSK |= (1<<TOIE0)) and global enable sei() (sets I). cli() clears I.لازم الاتنين: بت الطرفية + sei.
• Keep ISR entries infrequent: each call/return adds overhead → extra CPU delay.متخليش الـ ISR يتنده كتير.
• Two ways to access a timer event: polling the flag in TIFR vs interrupt-driven (TIMSK enable + sei + ISR).طريقتين: polling أو interrupt.

#define F_CPU 8000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define LED_PIN 0                 /* PB0 */

volatile uint8_t overflow_count = 0;

void Timer0_Init(void)
{
    CLEAR(TCCR0, WGM00);          /* Step 2: Normal mode */
    CLEAR(TCCR0, WGM01);
    TCNT0 = 0;                    /* Step 3: counter */
    SET(TIMSK, TOIE0);            /* Step 6: overflow interrupt */
    SET(TCCR0, CS02);             /* Step 7: N = 1024 → starts */
    CLEAR(TCCR0, CS01);
    SET(TCCR0, CS00);
}

ISR(TIMER0_OVF_vect)
{
    overflow_count++;
    if (overflow_count >= 61)     /* ≈ 2 s */
    {
        TOGGLE(PORTB, LED_PIN);
        overflow_count = 0;
    }
}

int main(void)
{
    SET(DDRB, LED_PIN);
    Timer0_Init();
    sei();                        /* Step 8: global interrupts */
    while (1)
    {
        /* main is free for other tasks */
    }
    return 0;
}

• Timer counts up; when TCNTn == OCRn: (1) timer resets to 0 (2) OCFn is set → ISR TIMERn_COMP_vect if OCIEn enabled.لما يساوي OCR بيصفّر ويرفع OCF.
• TOVn is NOT set in CTC (counter never reaches 0xFF unless OCR = 0xFF).مفيش overflow هنا.
• OCn pin can toggle / set / clear automatically on match (COM bits) → square waves without CPU.الـ pin ممكن يتقلب لوحده.
• Uses: precise delays and square wave generation.استخدامين.
• Delay = N × (OCRn + 1) / F_CPU → OCRn = Delay × F_CPU / N − 1.قانون التأخير.
• f_OCn = F_CPU / (2 × N × (1 + OCRn)) (toggle mode).قانون تردد الموجة.
• Bits: Timer0 WGM01 = 1, WGM00 = 0; Timer2 WGM21 = 1, WGM20 = 0; enable TIMSK |= (1<<OCIE2).بتات CTC.

#define F_CPU 2000UL
#include <avr/io.h>
#include <avr/interrupt.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define LED_PIN     6             /* PC6: active-low LED */
#define HEATER_PIN  7             /* PD7 = OC2 */

void Timer2_CTC_Init(void)
{
    TCCR2 = 0;                    /* Step 1: stop */
    SET(TCCR2, WGM21);            /* Step 2: CTC */
    CLEAR(TCCR2, WGM20);
    TCNT2 = 0;                    /* Step 3: counter */
    OCR2 = 38;                    /* Step 4: compare value (≈5 s) */
    SET(DDRD, HEATER_PIN);        /* Step 5: OC2 output */
    CLEAR(PORTD, HEATER_PIN);
    SET(TCCR2, COM21);            /*         set OC2 on match */
    SET(TCCR2, COM20);
    SET(TIMSK, OCIE2);            /* Step 6: compare interrupt */
    SET(TCCR2, CS22);             /* Step 7: N = 256 → starts */
    SET(TCCR2, CS21);
    CLEAR(TCCR2, CS20);
}

ISR(TIMER2_COMP_vect)
{
    CLEAR(PORTC, LED_PIN);        /* LED ON (active-low) */
}

int main(void)
{
    SET(DDRC, LED_PIN);
    SET(PORTC, LED_PIN);          /* LED OFF at start */
    Timer2_CTC_Init();
    sei();                        /* Step 8 */
    while (1)
    {
    }
    return 0;
}

• Timer counts 0 → TOP then instantly resets to 0 → fixed-period saw-tooth. 8-bit TOP = 255; 16-bit up to 65535.بيعد لفوق ويرجع صفر فورًا.
• OCn changes automatically at TCNTn == OCRn; duty set by OCRn.الـ OCR بيحدد الـ duty.
• Non-inverting (COMn1:0 = 10): clear OCn on match, set at BOTTOM → duty = OCR/255. Inverting (11): opposite.non-inverting: عالي في الأول وبيقع عند الـ match.
• Flags: OCFn on match, TOVn at rollover.الاتنين بيترفعوا.
• OCRn = MAX × duty% · f_PWM = F_CPU / (N × (TOP + 1)).القوانين.
• Bits: WGMn0 = 1, WGMn1 = 1; non-inverting COMn1 = 1, COMn0 = 0; OC2 = PD7, OC0 = PB3 as output.بتات Fast PWM.

#define F_CPU 1000000UL
#include <avr/io.h>
#include <stdint.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define OCR_80_PERCENT  204
#define OCR_20_PERCENT  51
#define SWITCH_PIN      2         /* PA2 */
#define PWM_PIN         7         /* PD7 = OC2 */

void Timer2_Fast_PWM_Init(uint8_t duty)
{
    TCCR2 = 0;                    /* Step 1: stop */
    SET(TCCR2, WGM20);            /* Step 2: Fast PWM */
    SET(TCCR2, WGM21);
    TCNT2 = 0;                    /* Step 3 */
    OCR2 = duty;                  /* Step 4: duty cycle */
    SET(DDRD, PWM_PIN);           /* Step 5: OC2 output */
    SET(TCCR2, COM21);            /*         non-inverting */
    CLEAR(TCCR2, COM20);
    SET(TCCR2, CS22);             /* Step 7: Timer2 100 = /64 */
    CLEAR(TCCR2, CS21);
    CLEAR(TCCR2, CS20);
}

int main(void)
{
    CLEAR(DDRA, SWITCH_PIN);      /* switch input */
    Timer2_Fast_PWM_Init(OCR_80_PERCENT);   /* start at high speed */

    uint8_t last_state = 1;
    uint8_t current_state;
    while (1)
    {
        current_state = GET(PINA, SWITCH_PIN);
        if (current_state != last_state)     /* only on a change */
        {
            last_state = current_state;
            if (current_state)
                Timer2_Fast_PWM_Init(OCR_80_PERCENT);
            else
                Timer2_Fast_PWM_Init(OCR_20_PERCENT);
        }
    }
    return 0;
}

• Timer counts external events (edges on a pin) instead of clock time; e.g. heartbeats.بيعد أحداث خارجية بدل الوقت.
• External clock pins: T0 = PB0 (Timer0), T1 = PB1 (Timer1). Each edge → TCNTn + 1.الـ pins الخاصة بالعد.
• The pin is sampled once every system clock (synchronization) because the external signal is not synchronized with the CPU clock; e.g. 8 MHz → every 125 ns.الـ pin بيتقري كل clock عشان يتزامن.
• Edge detector generates one count per edge (even if the signal stays high). CSn2:0 = 110 (6) → falling, 111 (7) → rising.كل edge = عدّة واحدة بس.
• Rule: f_ext,max < f_clk_I/O / 2.5 → 8 MHz → 3.2 MHz.أقصى تردد خارجي آمن.

#define F_CPU 4000UL
#include <avr/io.h>
#include <avr/interrupt.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define SENSOR_PIN 0              /* PB0 = T0 */

void Timer2_CTC_Init(void)        /* 1-minute window */
{
    TCCR2 = 0;                    /* Step 1 */
    SET(TCCR2, WGM21);            /* Step 2: CTC */
    CLEAR(TCCR2, WGM20);
    TCNT2 = 0;                    /* Step 3 */
    OCR2 = 233;                   /* Step 4: ≈60 s */
    SET(TIMSK, OCIE2);            /* Step 6 */
    SET(TCCR2, CS22);             /* Step 7: Timer2 111 = /1024 */
    SET(TCCR2, CS21);
    SET(TCCR2, CS20);
}

void Timer0_Event_Counter_Init(void)
{
    TCCR0 = 0;                    /* Step 1 */
    CLEAR(DDRB, SENSOR_PIN);      /* T0 input */
    TCNT0 = 0;                    /* Step 3 */
    SET(TCCR0, CS02);             /* Step 7: external T0, rising edge */
    SET(TCCR0, CS01);
    SET(TCCR0, CS00);
}

ISR(TIMER2_COMP_vect)             /* one minute passed */
{
    TCCR0 = 0;                    /* stop counting heartbeats */
    TCCR2 = 0;                    /* stop the window */
    PORTA = TCNT0;                /* beats → PORTA */
}

int main(void)
{
    DDRA = 0xFF;
    PORTA = 0x00;
    Timer0_Event_Counter_Init();
    Timer2_CTC_Init();
    sei();
    while (1)
    {
    }
    return 0;
}

• 8-bit counts to 255 (2⁸−1); 16-bit to 65,535 (2¹⁶−1).حدود العد.
• Best practice: use the smallest timer that meets your needs — low-bit timers save power and simplify the program; a 16-bit timer when unnecessary wastes power and adds complexity.استخدم أصغر تايمر يكفّي.
• Analogy: small stopwatch (8-bit) for short timings, big stopwatch (16-bit) for long/precise timings.ساعة صغيرة وساعة كبيرة.

• T1 = PB1 (external clock for Timer1) · OC1A = PD5 · OC1B = PD4 · ICP1 = PD6 · TOSC1/TOSC2 = PC6/PC7 (Timer2 async crystal) · XTAL1/2 = main crystal.الـ pins المهمة.
• Registers: TCCR1A, TCCR1B (control) · TCNT1 (current value) · OCR1A / OCR1B (compare) · ICR1 (capture) · TIMSK (interrupt mask) · TIFR (flags).مسجلات Timer1.

• Measures the exact time of an external edge; source: ICP1 pin (PD6) or Analog Comparator output (ACO).بيسجل وقت حدوث الـ edge بالظبط.
• Step 1 — Edge select with ICES1 in TCCR1B: 1 = rising, 0 = falling.اختار الحافة.
• Step 2 — On the edge, TCNT1 is copied into ICR1 (16-bit) at the exact clock cycle.قيمة العداد بتتنسخ في ICR1.
• Step 3 — ICF1 in TIFR is set; if TICIE1 in TIMSK = 1 → input capture interrupt (TIMER1_CAPT_vect).الـ flag والـ interrupt.
• Step 4 — ICF1 cleared automatically when the ISR executes, or by writing 1 to it.مسحه.
• Step 5 — Read ICR1L first (latches high byte in TEMP), then ICR1H.اقرا الـ low الأول.
• ICNC1 (Noise Canceler, TCCR1B bit 7): small digital filter → increases response time (delay) but improves edge-detection stability.فلتر بيأخر شوية بس بيثبّت الكشف.
• Use: pulse width and frequency measurement without software delay (ultrasonic, tachometer).قياس عرض النبضة والتردد.

• Split into TCNT1H (bits 15..8) and TCNT1L (bits 7..0); increments on the clock selected in TCCR1B.16 بت متقسمين بايتين.
• Overflow 0xFFFF → 0x0000 sets TOV1.الـ overflow.
• Read: low first, then high. Write: high first, then low. (In C, TCNT1 = x; handles it.)ترتيب القراية والكتابة.

• TCCR1A (7→0): COM1A1 · COM1A0 · COM1B1 · COM1B0 · FOC1A · FOC1B · WGM11 · WGM10.احفظ الترتيب.
• COM1A1:0 → OC1A (PD5) action on OCR1A match · COM1B1:0 → OC1B (PD4) · FOC1A/B force compare (non-PWM modes only) · WGM11:10 lower mode bits.معنى كل جزء.

• TCCR1B (7→0): ICNC1 · ICES1 · – · WGM13 · WGM12 · CS12 · CS11 · CS10.احفظ الترتيب.
• ICNC1 noise canceler · ICES1 edge select · WGM13:12 upper mode bits · CS12:10 clock select (prescaler or external T1).معنى كل جزء.

• Mode = WGM13:12:11:10 (4 bits split across both registers): 0000 Normal (TOP 0xFFFF) · 0100 CTC (TOP OCR1A) · 0101 Fast PWM 8-bit · 1100 CTC (TOP ICR1) · 1110/1111 Fast PWM (TOP ICR1/OCR1A).الـ mode موزع على الريجسترين.

• CS12:10: 000 stopped · 001 /1 · 010 /8 · 011 /64 · 100 /256 · 101 /1024 · 110 T1 falling · 111 T1 rising.نفس جدول Timer0.

• TIMSK = interrupt enable bits (1 = enabled).التفعيل.
• TIMSK (7→0): OCIE2 · TOIE2 · TICIE1 · OCIE1A · OCIE1B · TOIE1 · OCIE0 · TOIE0.احفظ الترتيب: Timer2 فوق ثم Timer1 ثم Timer0.
• TIFR = interrupt flags set by hardware; clear by writing 1.الأعلام.
• TIFR (7→0): OCF2 · TOV2 · ICF1 · OCF1A · OCF1B · TOV1 · OCF0 · TOV0.نفس الترتيب بالظبط بس flags.

• Timer1 chosen: long delay without chaining many overflows. N = 1024.16-bit يوصل 2 ثانية في overflow واحد.
• T_tick = 1024 / 8 MHz = 128 µs (7812.5 Hz). ticks = 2 × 8×10⁶ / 1024 = 15,625.حساب التكات.
• Preload TCNT1 = 65536 − 15625 = 49,911. Slides write 49,910 (one tick off, negligible).قيمة البداية.
• Normal: TCCR1A = 0; TIMSK |= (1<<TOIE1); sei(); start TCCR1B |= (1<<CS12)|(1<<CS10).الإعداد.
• ISR reloads TCNT1 (Normal mode does not auto-reload) and toggles the pin.لازم تعيد التحميل كل مرة.

#define F_CPU 8000000UL
#include <avr/io.h>
#include <avr/interrupt.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define DEVICE_PIN  0             /* PB0, active-high */
#define PRELOAD     49911         /* 65536 - 15625 */

void Timer1_Normal_Init(void)
{
    TCCR1A = 0;                   /* Step 1: stop */
    TCCR1B = 0;
    CLEAR(TCCR1A, WGM10);         /* Step 2: Normal (WGM13:10 = 0000) */
    CLEAR(TCCR1A, WGM11);
    CLEAR(TCCR1B, WGM12);
    CLEAR(TCCR1B, WGM13);
    TCNT1 = PRELOAD;              /* Step 3: preload */
    SET(TIMSK, TOIE1);            /* Step 6: overflow interrupt */
    SET(TCCR1B, CS12);            /* Step 7: N = 1024 → starts */
    CLEAR(TCCR1B, CS11);
    SET(TCCR1B, CS10);
}

ISR(TIMER1_OVF_vect)
{
    TCNT1 = PRELOAD;              /* reload: Normal mode does not auto-reload */
    TOGGLE(PORTB, DEVICE_PIN);
}

int main(void)
{
    SET(DDRB, DEVICE_PIN);
    SET(PORTB, DEVICE_PIN);       /* device ON first */
    Timer1_Normal_Init();
    sei();                        /* Step 8 */
    while (1)
    {
    }
    return 0;
}

• Count 10 rising-edge pulses on PB0, measure the elapsed time, show it on PORTC; F = 4 MHz, assume no Timer1 overflow.عدّ 10 نبضات واحسب الوقت.
• Timer0 = counter on T0 (CS02:0 = 111) preloaded so the 10th pulse overflows it: TCNT0 = 256 − 10 = 246 (slides: 245).Timer0 بيعمل overflow عند النبضة العاشرة.
• Timer1 = Normal, N = 1024, free-running from 0 → tick = 256 µs.Timer1 بيقيس الوقت.
• TIMER0_OVF ISR: stop both timers (TCCR1B = 0, TCCR0 = 0), convert ticks to ms, write to PORTC.في الـ ISR وقّف الاتنين واطلع النتيجة.

#define F_CPU 4000000UL
#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>

/* bit-operation macros (not part of the AVR headers) */
#define SET(reg, bit)       ((reg) |=  (1U << (bit)))
#define CLEAR(reg, bit)     ((reg) &= ~(1U << (bit)))
#define TOGGLE(reg, bit)    ((reg) ^=  (1U << (bit)))
#define GET(reg, bit)       (((reg) >> (bit)) & 1U)

#define ALARM_PIN    0            /* PB0 = T0 */
#define PULSE_LIMIT  10

void Timer0_Event_Counter_Init(void)
{
    TCCR0 = 0;                    /* Step 1 */
    CLEAR(TCCR0, WGM01);          /* Step 2: Normal */
    CLEAR(TCCR0, WGM00);
    CLEAR(DDRB, ALARM_PIN);       /* T0 input */
    TCNT0 = 256 - PULSE_LIMIT;    /* Step 3: 246 → overflow on the 10th pulse */
    SET(TIMSK, TOIE0);            /* Step 6 */
    SET(TCCR0, CS02);             /* Step 7: external T0, rising edge */
    SET(TCCR0, CS01);
    SET(TCCR0, CS00);
}

void Timer1_Normal_Init(void)
{
    TCCR1A = 0;                   /* Step 1 + 2: stop, Normal */
    TCCR1B = 0;
    TCNT1 = 0;                    /* Step 3 */
    SET(TCCR1B, CS12);            /* Step 7: N = 1024 → tick = 256 us */
    CLEAR(TCCR1B, CS11);
    SET(TCCR1B, CS10);
}

ISR(TIMER0_OVF_vect)
{
    TCCR1B = 0;                   /* stop Timer1 → time frozen */
    TCCR0 = 0;                    /* stop Timer0 → no more counts */
    uint32_t elapsed_ms = ((uint32_t)TCNT1 * 256UL) / 1000UL;
    PORTC = (uint8_t)elapsed_ms;
}

int main(void)
{
    DDRC = 0xFF;
    PORTC = 0x00;
    Timer0_Event_Counter_Init();
    Timer1_Normal_Init();
    sei();
    while (1)
    {
    }
    return 0;
}

اختار ريجستر واكتب أسماء البتات من 7 لـ 0 (البت المحجوز اكتبه -)، وبعدين Check.

اقرا الطلب، اكتب السطور على ورقة، وبعدين افتح الإجابة.

CLEAR(TCCR0, WGM00);  CLEAR(TCCR0, WGM01);    // Normal
SET(TCCR0, CS02);  CLEAR(TCCR0, CS01);  SET(TCCR0, CS00);   // 1024

SET(TCCR0, WGM01);  CLEAR(TCCR0, WGM00);     // CTC
SET(TIMSK, OCIE0);
CLEAR(TCCR0, CS02);  SET(TCCR0, CS01);  SET(TCCR0, CS00);   // 64
sei();

SET(TCCR0, WGM00);  SET(TCCR0, WGM01);       // Fast PWM
SET(TCCR0, COM01);  CLEAR(TCCR0, COM00);     // non-inverting
SET(DDRB, 3);                                // OC0 = PB3
CLEAR(TCCR0, CS02);  SET(TCCR0, CS01);  CLEAR(TCCR0, CS00);  // 8

CLEAR(DDRB, 0);                              // T0 = PB0 input
SET(TCCR0, CS02);  SET(TCCR0, CS01);  SET(TCCR0, CS00);     // 111

SET(TCCR0, WGM01);  CLEAR(TCCR0, WGM00);     // CTC
CLEAR(TCCR0, COM01);  SET(TCCR0, COM00);     // toggle OC0
SET(DDRB, 3);
CLEAR(TCCR0, CS02);  SET(TCCR0, CS01);  SET(TCCR0, CS00);   // 64

SET(TCCR2, WGM21);  CLEAR(TCCR2, WGM20);     // CTC
SET(TIMSK, OCIE2);
SET(TCCR2, CS22);  SET(TCCR2, CS21);  CLEAR(TCCR2, CS20);   // Timer2 110 = 256
sei();

SET(TCCR2, WGM20);  SET(TCCR2, WGM21);       // Fast PWM
SET(TCCR2, COM21);  CLEAR(TCCR2, COM20);     // non-inverting
SET(DDRD, 7);                                // OC2 = PD7
SET(TCCR2, CS22);  CLEAR(TCCR2, CS21);  CLEAR(TCCR2, CS20);  // Timer2 100 = 64

TCCR1A = 0;  TCCR1B = 0;                     // Normal 0000
SET(TIMSK, TOIE1);
SET(TCCR1B, CS12);  CLEAR(TCCR1B, CS11);  SET(TCCR1B, CS10);  // 1024
sei();

TCCR1A = 0;  TCCR1B = 0;
SET(TCCR1B, WGM12);                          // CTC 0100
SET(TIMSK, OCIE1A);
SET(TCCR1B, CS12);  CLEAR(TCCR1B, CS11);  CLEAR(TCCR1B, CS10);  // 256
sei();

SET(TCCR1B, ICES1);                          // rising edge
SET(TCCR1B, ICNC1);                          // noise canceler
SET(TIMSK, TICIE1);
sei();
// ISR(TIMER1_CAPT_vect){ x = ICR1; }

while (GET(TIFR, TOV0) == 0);   // wait
SET(TIFR, TOV0);                 // write 1 to clear

TCCR0 = 0;     // CS = 000 → no clock
TCCR1B = 0;