AVR-Xuất xung với tần số và độ rộng theo ý muốn

1: Làm sao để tạo xung?

Yêu cầu: Tạo xung vuông với tần số khoảng 1khz, độ rộng xung là 10%.

void setup()
{
    pinMode(13, OUTPUT);
}
void loop()
{
    digitalWrite(13, HIGH);
    delayMicroseconds(100);
    digitalWrite(13, LOW);
    delayMicroseconds(900);
}

void setup()
{
    analogWrite(5, 25);
    // 25/256=10%
}
void loop()
{
}

Về bản chất hàm analogWrite

• Không cần khai báo pin.
• Tần số mặc định trên pin 5,6 là 976 Hz (uno r3), trên pin 3, 11 là 976 Hz (Leonardo).
• Tần số mặc định trên các pin còn lại là 490 hz.
• Nó truy cập trực tiếp lên các thanh ghi nên không ảnh hưởng đến tốc độ sử lý . (bạn sẽ biết điều đó ngay bây giờ).

Chạy mô phỏng trên proteus

void setup()
{
    pinMode(13, OUTPUT);
    analogWrite(5, 25);
}

void loop()
{
    digitalWrite(13, HIGH);
    delayMicroseconds(100);
    digitalWrite(13, LOW);
    delayMicroseconds(900);
}

2: Truy cập thanh ghi điều khiển để thay đổi tần số

2.1: Cách tạo ra xung PWM.

Cấp một xung nhịp P_clock vào bộ đếm Counter, Xung P_clock được lấy ra từ bộ chia tần số hệ thống F_clock. Mỗi một xung P_clock sẽ làm bộ đếm Counter tăng thêm một giá trị, khi giá trị đạt max (tràn số) thì counter lại được đặt về 0 (Fast PWM) hoặc lại đếm lùi về 0 (Phase correct), quá trình này sẽ được lặp đi lặp lại .

Tiếp đến, bộ so sánh sẽ kiểm tra giá trị của bộ đếm Counter với một giá trị đặt trước Value, giá trị lấy ra từ bộ so sánh cũng chính là dạng xung PWM có tần số P_clock, độ rộng xung là tỷ số của Value với Counter.

2.2: Truy cập cài đặt các thanh ghi

Trên AVR 168/328, Việc tạo xung được hỗ trợ bởi 3 timer là TIMER 0 (8 bit), TIMER 1 (16 bit), TIMER 2 (8 bit). Mỗi Timer bao gồm 2 thanh ghi dữ liệu A-B, Bằng cách truy cập và thay đổi thông số của các thanh ghi, chúng ta sẽ cài đặt pin ra, bộ chia tần, đặt ngắt Value, lựa chọn kiểu Counter (xung răng cưa/ tam giác), kiểu so sánh, đặt ngắt tràn cho Counter…

AVR là mình gọi tắt của con Atmega - cái con vi điều khiển của con arduino đó các bạn

Trên AVR 328, Chúng ta có 6 pin hỗ trợ xuất xung.

Một vài thuật ngữ

Lấy ví dụ trên TIMER 1:

• TCCR_1_A(Timer/Counter_1 _Control Register_ A)
• TCCR_1_B(Timer/Counter_1 _Control Register _B)
• TCNT_1(Timer/Counter Register )
• ICR_1(Input Capture Register) 
• OCR_1_A/B(Output Compare Register)

2.3 Đầu ra phụ thuộc vào kiểu so sánh “inverted” hay "none-inverted":

Ví dụ chọn kiểu đếm răng cưa (FAST PWM), kiểu so sánh thường ”none-inverted”. Tín hiệu ra là HIGH khi Value lớn hơn Counter, là LOW khi Value nhỏ hơn Counter. Khi chọn là “inverted”, tín hiệu đầu ra sẽ bị đảo lại so với trường hợp trên.

Kiểu đếm Counter tam giác cũng như vậy.

Tần số xung phụ thuộc vào xung nhịp P_clock (sau bộ chia tần) và dạng đếm counter.

Như đã biết, mỗi  P_clock thì counter tăng lên 1, nếu bộ đếm có cỡ là 8 bit thì cần 256 xung để đếm từ BOTTOM lên TOP (đếm răng cưa). Nếu chọn kiểu tam giác, khi Counter đạt TOP nó sẽ tiếp tục đếm lùi, khi đó nó cần 256*2 xung P_clock để đi hết một chu kỳ đếm.

Khi đó công thức tổng quát để tính tần số PWM là :

F_pwm =P_clock  /  (Top_value+1).    Fast Pwm.

Hoặc

F_pwm=P_clock  / (2*( Top_value+1)) .   Phase Cerrect Pwm.

Với P_clock =F_clock  / Prescaller.

Ví dụ

Chọn kiểu Fast Pwm, tần số thạch anh F_clock=16mhz, sử dụng bộ đếm timer 0 (8 bit = 1 byte) tương đương TOP_value=255+1. Giảm tầm số Counter xuống còn P_clock = 16mhz/64=250kHz. (Prescller=64).

Khi đó tần số của xung ra:

F_pwm=250khz/256=976.562 Hz.

Cũng như trên, nhưng chọn kiểu Phase Cerrect Pwm, tần số xung ra F_pwm=488.28 Hz.

Timer/Counter1 có 2 đầu ra là OC1A và OC1B tương ứng với pin ~9 và pin ~10 trên arduino.

Timer/Counter Control Register 1 A

Timer/Counter Control Register 1 B

Kiểu so sánh

Applies only to PWM modes

Bộ chia tần

CS bits

Kiểu counter

Waveform Generator Mode bits (Abbreviated)

Ưu điểm của timer 1 so với timer 0 là nó độ phân giải cao hơn, bộ đếm Counter 0 sẽ bị tràn sau 256 xung P_clock, còn Counter 1 sẽ tràn sau 512 xung Clock (9 bit) hoặc 1024 xung (10 bit), hoặc 65536 xung (16 bit).  Điều này giúp ta xuất xung PWM có rộng xung cực kỳ chính xác.

Ưu điểm nữa của Timer 1 là nó cho phép thay đổi giá trị TOP, ví dụ bạn có thể cài đặt ngưỡng tràn là 500 xung P_clock ( thay vì mặc định là 512 xung). Khi đó độ phân giải mặc định là 16 bit.

Còn lại cách dùng thì vẫn như cũ.

Như vậy việc sử dụng TIMER 1 -16 BIT cũng rất dễ dàng.

1. Xuất xung 8mhz ra ngoài

Đơn giản là ta sẽ chia cho mẫu số nhỏ nhất là 1.

Kĩ thuật này chỉ áp dụng cho TIMER1 vì nó có thể thay đổi tràn TOP_value.

Có nghĩa chỉ có 2 pin ~9 và ~10 mới có khả năng này

void setup()
{
    TCCR1A = 0;
    TCCR1B = 0;
    // RESET lại 2 thanh ghi
    DDRB |= (1 << PB1);
    // Đầu ra PB1 là OUTPUT ( pin 9)

    TCCR1A |= (1 << WGM11);
    TCCR1B |= (1 << WGM12) | (1 << WGM13);
    // chọn Fast PWM, chế độ chọn TOP_value tự do  ICR1
    TCCR1A |= (1 << COM1A1);
    // So sánh thường( none-inverting)
    ICR1 = 1;
    // xung răng cưa tràn sau 1 P_clock
    OCR1A = 0;
    // xuất mọi lúc
    TCCR1B |= (1 << CS10);
    // F_clock=16mhz, P_clock=16/1=16mhz.
    //F_pwm=16mhz/(ICR1+1)=8mhz
}

void loop()
{
}

2. Xuất xung 16mhz ra ngoài

Theo công thức ngay ở đầu bài viết:

F_pwm = P_clock  /  (Top_value+1).   

Để F_pwm=16mhz, thì TOP_value=0, và P_clock=16mhz.

Điều này là không thể, bởi vì OCR1A (value) nhỏ nhất =0, khi đó nếu  ICR1 (TOP_value) cho bằng 0 thì nó sẽ không đếm được sự kiện.

3. Điều khiển SERVO với góc siêu chính xác

Thư viện SERVO.h mà chúng ta đang dùng có số góc điều khiển SERVO là số nguyên.(0->180) độ.

Vậy bạn có muốn điều khiển nó nhích 0.5 độ không ?  Hãy đón đọc bài tiếp theo nhé. 

4. Hàm AnalogWrite!

Tới đây việc tự xây dựng một hàm AnalogWrite sẽ không còn khó nữa. Hiểu lầm lớn nhất của beginner khi sử dụng AnalogWrite  là đã “đánh đồng” cả 3 bộ TIMER là như nhau, khiến ta không khai thác được nhiều ưu điểm của từng TIMER.

Dưới đây là mã nguồn cho hàm analogWrite:

http://http://garretlab.web.fc2.com/en/arduino/inside/arduino/wiring_analog.c/analogWrite.html

Các ví dụ trên là sử dụng độc lập các đầu ra của timer, tinh ý sẽ thấy, ta luôn phải reset lại 2 thanh ghi trước khi muốn đặt lại bằng phép hợp (toán tử “ |”). Lý do reset vì nó đã được với các thông số  mặc định trước đó.  Tiếp nữa là tần số trên  hai đầu ra là luôn bằng nhau ( chung một Counter, chung tần số P_clock).

TIMER 0:

void setup(){
  ////////////////////////////////////////////////////
  TCCR0A=0;TCCR0B=0;
  // reset lại 2 thanh ghi
  //B2: 
    DDRD |= (1 << PD6);
    DDRD |= (1 << PD5);
    // pin 6, 5 là output
  //B3:

    TCCR0A |= (1 << WGM01) | (1 << WGM00);
    // chọn Fast Mode
    TCCR0B |= (1 << CS01);
    //prescaler = 8, P_clock=16mhz/8=2mhz
    // Tần số xung F_pwm=2 mhz/256=7812,5 hz

    ///////////////////////////////////////////////////////
    TCCR0A |= (1 << COM0A1);
    // đầu ra kiểu thường cho PD6 (none-inverting)
    TCCR0A |= (1 << COM0B1);
    // đầu ra kiểu thường cho PD5 (none-inverting)

    OCR0A = 128; //(chân PD6 ) Độ rộng xung= 128/256=50%
    OCR0B = 64;// (chân PD5) Độ rộng xung 64/256=25%
   
   
}


void loop(){

}

TIMER 1:

void setup(){
  /////////////////////////////////////////////////
   TCCR1A=0; TCCR1B=0;
   // RESET lại 2 thanh ghi
  DDRB |= (1 << PB1)|(1 << PB2);
  // Đầu ra PB1 và PB2 là OUTPUT ( pin ~9, ~10)

    TCCR1A |= (1 << WGM11);
    TCCR1B |= (1 << WGM12)|(1 << WGM13);
    // chọn Fast PWM, chế độ chọn TOP_value tự do  ICR1 

    ICR1 = 10000;
    // xung răng cưa tràn sau 10001 P_clock
    TCCR1B |= (1 << CS10)|(1 << CS11);
    // F_clock/64=16mhz/64=250 khz
    //F_pwm=250khz/10001=25hz
///////////////////////////////////////////////////
    
    TCCR1A |= (1 << COM1A1);
    // So sánh thường cho PB1 ( none-inverting)
    TCCR1A |= (1 << COM1B1);
    // So sánh thường cho PB2 ( none-inverting) 
    OCR1A =1000;//(PB1) Value=1000 -> độ rộng 10%
    OCR1B = 5000; //(PB2) Value=5000 -> độ rộng 50 %

}

void loop(){

  
}

TIMER 2:

void setup(){

  ////////////////////////////////////////////////////////
  TCCR2A =0; TCCR2B=0;
  //reset
    DDRD |= (1 << PD3);// PD3 output, (pin ~3)
    DDRB |= (1 << PB3);// PB3 output, (pin ~11)

    TCCR2A |= (1 << WGM21) | (1 << WGM20);
    //  PWM Mode (răng cưa)
    TCCR2B |= (1 << CS22)|(1 << CS20);
    //  prescaler= 128, P_clock=16mhz/128=125 khz
    // F_pwm=125 khz/256=488.28 hz
//////////////////////////////////////////////////
    TCCR2A |= (1 << COM2B1);// so sánh thường (PD3) (pin 3) ( none-inverting)
    TCCR2A |= (1 << COM2A1);// so sánh thường (PB3) (pin 11) ( none-inverting)

    OCR2B = 25; // (PD3) (pin 3)độ rộng xung =25/256=10%
    OCR2A = 128;//(PB3) (pin 11) độ rộng 50%

}

void loop(){
}

\