Cộng đồng Arduino Việt Nam - shiftout

Điều khiển ma trận LED 24x8 - Tìm hiểu kĩ thuật quét LED (Phần 1)

soituyet3s — Thu, 11 Feb 2016 09:23:47 +0000

I. Giới thiệu

Hôm nay mình sẽ hướng dẫn các bạn làm ma trận LED kích thước 24x8 để các bạn có thể treo chơi Tết (năm sau ).

Ờ quên, sắp tới valentine rồi nên các nếu cố gắng các bạn có thể làm kịp để tỏ tình đấy

II. Chuẩn bị tâm lí

WARNING: điều khiển ma trận LED là chuyện không hề dễ, đòi hỏi thuật toán khá phức tạp.

PHẦN 1 này mình chỉ viết mã để nó có thể chạy chữ được thôi, nhưng cũng khá phức tạp rồi

PHẦN 2 mình sẽ phát triển thêm một số hiệu ứng, dựa trên những thuật toán về đồ thị, có lẽ sẽ HƠI HƠI khó hiểu đối với những bạn không chuyên về lập trình :D

Các bài nên đọc trước

Để có thể nắm bắt tốt hơn, mình đề nghị các bạn đọc trước những bài hướng dẫn sau đây trước khi bắt đầu:

Điều khiển 8 đèn LED sáng theo ý muốn của bạn, dễ hay khó? (Để biết cách sử dụng IC HC595 và tìm hiểu shiftout)
Hiển thị hình ảnh với LED MATRIX 8x8 (Để làm quen với kĩ thuật quét LED, mình sẽ nói kĩ hơn, với lại các hiển thị chữ trên ma trận LED trong bài này không được bắt mắt lắm, xin lỗi tác giả nhé, mình sẽ hiển thị chữ mượt hơn)

III. Chuẩn bị vật liệu

24 x 8 = 192 đủ để gắn 192 đèn LED

Một bảng

8 điện trở

4 IC Uno cho nó dễ nhé).

Lưu ý:

Sản phẩm của mình vẫn còn nằm trên BreadBoard, do trước Tết để dành tiền oánh bài nên không có đặt hàng về, vì vậy phần này tùy vào sự sáng tạo của bạn, sao cho đẹp là được

IV. Tìm hiểu kĩ thuật quét

Như mình đã nói, các bạn tham khảo bài này - LED matrix 8x8 điều khiển để biết sơ sơ về kĩ thuật quét LED. Bây giờ mình sẽ nói kĩ hơn

Ma trận gồm 8 dòng và 24 cột như đánh thứ tự trong hình

Để sáng được đèn LED cần nối 2 đầu LED với nguồn điện

Ví dụ: Nếu muốn đèn (B2, Z6) sáng, bạn cần nối chân B2 với cực dương và chân Z6 cũng được nối với cực dương luôn (ủa kì vậy? phải nối tới cực âm chứ). Thực ra IC HC595 không được sản xuất để làm cấp nguồn cho LED, vì vậy nó chịu dòng rất kém, nếu nối trực tiếp vào nó thì trong trường hợp cả 24 LEDs trong một hàng cùng sáng thì dòng điện qua nó sẽ quá tải, do vậy ta cần một transistor để hứng dòng đó, ta kéo Z6 lên cực dương để kích cho transistor thông dòng để dòng điện qua các LEDs về cực âm mới sáng được)

Oops, lạc đề rồi. Đó là giải thích tại sao cần có transistor đứng trước mỗi dòng của ma trận, nhưng thôi để cho dễ hiễu cũng như dễ giải thích, thì muốn đèn (B2, Z6) sáng, cần nối chân B2 với cực dương, chân Z6 với cực âm.

Vấn đề hiển thị nhiều LED

Giả sử nếu bạn muốn đèn (B2, Z6) và đèn (C3, Z8) sáng thì làm sao, chúng ta cần nối chân B2 với C3 với cực dương, chân Z6 và Z8 với cực âm. Nếu vậy thì ngoài 2 đèn cần sáng đó ra, sẽ có thêm vị khách không mời là thằng (C3, Z6) nó cũng sáng theo. Vậy làm thế lào mà sáng theo ý muốn được chớ, nó sẽ hiển thị búa lua xua hết?

Đó là lí do tại sao kĩ thuật quét ra đời.

Kỹ thuật quét led

Kỹ thuật quét thay vì cấp nguồn như trên, nó sẽ cấp nguồn theo một thứ tự khác. Nó sẽ lần lượt nối các hàng Z1, Z2, Z3, Z4, Z5, Z6, Z7, Z8 với cực âm theo thứ tự từng cái một, như vậy chỉ những đèn trên hàng được nối nguồn âm mới có thể sáng được (nếu như cột của nó cũng được nối với nguồn dương)

Để hiểu rõ hơn, hãy nhìn vào bảng sau

Khi hàng số 1 được nối cực âm, thì bộ 24 giá trị trên hàng 1 trong bảng trên sẽ được cập nhật là trạng thái cho 24 cột của ma trận (đen là được nối cực dương, trắng thì không), tiếp theo là tới hàng 2 và bộ 24 cột của hàng 2, cứ tiếp tục tới hàng 8 rồi trở lại hàng 1. Quá trình chân 1 được nối cực âm, rồi tới chân 2, chân 3, tới chân 8 rồi trở về chân 1 được thực hiện rất nhanh, cập nhật trạng thái cho 24 cột cũng rất nhanh nên do hiện tượng lưu ảnh của mắt nên ta không thể thấy kịp từng hàng sáng lên mà chỉ thấy cả ma trận sáng theo thứ tự đúng y như trong bảng thôi.

Bạn tưởng mình nói xạo ư, nói có sách mách có chứng, mình đã thêm một hàm delay giữa các lần chuyển đổi hai chân để nối cực âm. Các bạn xem video sau rồi so sánh với video phía trên sẽ rõ.

Thế là xong kĩ thuật quét, dễ như ăn bánh nhể

V. Mắc mạch

Nối chân IC HC595

(Cái này do mình vẽ nên hơn xấu, nếu muốn xem cái đẹp hơn các bạn hãy vào trang instructables đã nói ở trên ^^).

Nối LED

Đây là hình ảnh thực tế của em nó

VI. Lập trình nào

Thiệt tình mà nói thì code của mình viết vừa đơn giản vừa phức tạp. Đơn giản với dân chuyên lập trình, đọc sẽ tự hiểu và phức tạp với dân điện tử ít tiếp xúc lập trình nhiều, mình cũng không biết phải chú thích gì nên bỏ không vậy, bạn nào có thắc mắc trong code cứ việc comment, mình rất sẵn lòng giúp.

//tốc độ chạy chữ, càng lớn chạy càng lâu
const byte SPEED = 4;

//kéo lên HIGH để cháy đèn LED, xài chung cho ROW và COL
const byte LATCH = 2;

const byte CLOCK_ROW = 3;
const byte DATA_ROW = 4;

const byte CLOCK_COL = 5;
const byte DATA_COL = 6;

//Dùng cho ROW, ứng với {00000001, 00000010, 00000100, 00001000, 00010000, 00100000, 01000000, 10000000};
const byte ROWS[8] = {1, 2, 4, 8, 16, 32, 64, 128};

//Ma trận gồm 8 dòng và 24 cột
//Mỗi byte trong 8 byte của một phần tử trong mảng sau ứng với 1 cột của ma trận. Vậy tại sao có 8 byte trong khi chỉ cần 5 cột là đủ biểu diễn một kí tự?
//Đó là vì dư ra cho tiện cho làm thêm các hình khác, trái tim chẳng hạn

//Mình chỉ làm kí tự hoa, số và vài kí tự đặt biệt
//Chữ thường làm hơi xấu nên sẽ tính sau

//Mình cũng sẽ đăng một phần mềm nhỏ nhỏ do mình viết dùng để tạo các kí tự
byte up[26][8] = {
  {B00111111, B01010000, B10010000, B01010000, B00111111, B00000000, B00000000, B00000000},//A
  {B11111111, B10010001, B10010001, B10010001, B01101110, B00000000, B00000000, B00000000},//B
  {B01111110, B10000001, B10000001, B10000001, B10000001, B00000000, B00000000, B00000000},//C
  {B11111111, B10000001, B10000001, B10000001, B01111110, B00000000, B00000000, B00000000},//D
  {B11111111, B10010001, B10010001, B10010001, B10010001, B00000000, B00000000, B00000000},//E
  {B11111111, B10010000, B10010000, B10010000, B10010000, B00000000, B00000000, B00000000},//F
  {B01111110, B10000001, B10000001, B10001001, B01001110, B00001000, B00000000, B00000000},//G
  {B11111111, B00010000, B00010000, B00010000, B11111111, B00000000, B00000000, B00000000},//H
  {B10000001, B10000001, B11111111, B10000001, B10000001, B00000000, B00000000, B00000000},//I
  {B10000011, B10000001, B11111111, B10000000, B10000000, B00000000, B00000000, B00000000},//J
  {B11111111, B00011000, B00100100, B01000010, B10000001, B00000000, B00000000, B00000000},//K
  {B11111111, B00000001, B00000001, B00000001, B00000001, B00000000, B00000000, B00000000},//L
  {B11111111, B01000000, B00100000, B01000000, B11111111, B00000000, B00000000, B00000000},//M
  {B11111111, B01000000, B00100000, B00010000, B11111111, B00000000, B00000000, B00000000},//N
  {B01111110, B10000001, B10000001, B10000001, B01111110, B00000000, B00000000, B00000000},//O
  {B11111111, B10010000, B10010000, B10010000, B01100000, B00000000, B00000000, B00000000},//P
  {B01111110, B10000001, B10000001, B10000101, B01111110, B00000001, B00000000, B00000000},//Q
  {B11111111, B10011000, B10010100, B10010010, B01100001, B00000000, B00000000, B00000000},//R
  {B01100001, B10010001, B10010001, B10010001, B01001110, B00000000, B00000000, B00000000},//S
  {B10000000, B10000000, B11111111, B10000000, B10000000, B00000000, B00000000, B00000000},//T
  {B11111110, B00000001, B00000001, B00000001, B11111110, B00000000, B00000000, B00000000},//U
  {B11111100, B00000010, B00000001, B00000010, B11111100, B00000000, B00000000, B00000000},//V
  {B11111111, B00000010, B00000100, B00000010, B11111111, B00000000, B00000000, B00000000},//W
  {B11000011, B00100100, B00011000, B00100100, B11000011, B00000000, B00000000, B00000000},//X
  {B11100000, B00010000, B00001111, B00010000, B11100000, B00000000, B00000000, B00000000},//Y
  {B10000111, B10001001, B10010001, B10100001, B11000001, B00000000, B00000000, B00000000}//Z
};

byte num[10][8] = {
  {B01111110, B10000001, B10000001, B10000001, B01111110, B00000000, B00000000, B00000000},//0
  {B00100001, B01000001, B11111111, B00000001, B00000001, B00000000, B00000000, B00000000},//1
  {B01000011, B10000101, B10001001, B10010001, B01100001, B00000000, B00000000, B00000000},//2
  {B01000001, B10010001, B10010001, B10010001, B01101110, B00000000, B00000000, B00000000},//3
  {B11110000, B00010000, B00010000, B11111111, B00000000, B00000000, B00000000, B00000000},//4
  {B11110001, B10010001, B10010001, B10010001, B10001110, B00000000, B00000000, B00000000},//5
  {B01111110, B10010001, B10010001, B10010001, B10001110, B00000000, B00000000, B00000000},//6
  {B10000000, B10000000, B10011111, B10100000, B11000000, B00000000, B00000000, B00000000},//7
  {B01101110, B10010001, B10010001, B10010001, B01101110, B00000000, B00000000, B00000000},//8
  {B01100000, B10010001, B10010001, B10010001, B01111110, B00000000, B00000000, B00000000}//9
};

byte specials[5][8] = {
  {B00011000, B00100100, B01000010, B00100001, B01000010, B00100100, B00011000, B00000000},//HEART
  {B00000001, B00000110, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000},//,
  {B00000001, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000},//.
  {B11111101, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000}//!
};

//Lưu trữ giá trị để biểu diễn ma trận, 24 byte là 24 cột
//1 byte = 8 bit ứng mỗi điểm trên cột
byte leds[24];

void copyArr(byte target[8], byte source[8]) {
  for (byte i = 0; i < 8; i++) {
    target[i] = source[i];
  }
}

//Tìm xem một kí tự ứng với đâu trong các mảng UP, NUM, SPECIALS)
void getArrFromChar(char ch, byte arr[8]) {
  byte ind = (byte) ch; //Lấy mã ASCII của kí tự

  if ((ind >= 48) && (ind <= 57)) {
    copyArr(arr, num[ind - 48]);
    return;
  }

  if ((ind >= 65) && (ind <= 90)) {
    copyArr(arr, up[ind - 65]);
    return;
  }

  switch (ch) {
    case '$': {
        copyArr(arr, specials[0]);
        break;
      }
    case ',': {
        copyArr(arr, specials[1]);
        break;
      }
    case '.': {
        copyArr(arr, specials[2]);
        break;
      }
    case '!': {
        copyArr(arr, specials[3]);
        break;
      }
  };
}

//Thêm một kí tự, sau đó gọi hàm addCol để hiển thị từng phần của kí tự
void addChar(char chr) {
  byte arr[8];
  getArrFromChar(chr, arr);
  for (byte i = 0; i < 8; i++) {
    if (arr[i] != 0) {
      addCol(arr[i]);
    }
  }
  addCol(0);
}

//Thêm vào một cột vào mảng leds để hiển thị
void addCol(byte col) {
  moveLeft();
  leds[23] = col;
  show(leds, SPEED);
}

void moveLeft() {
  for (byte i = 0; i < 23; i++) {
    leds[i] = leds[i + 1];
  }
}


void parseString(String s) {
  s += "      ";
  for (byte i = 0; i < s.length(); i++) {
    if (s.charAt(i) == ' ') {
      addCol(0);
      addCol(0);
    } else {
      addChar(s.charAt(i));
    }
  }
}

//Hiển thị mảng leds ra ma trận
void show(byte leds[24], byte hold) {
  for (byte k = 0; k < hold; k++) {
    for (byte i = 0; i < 8; i++) {
      byte d[3] = {0, 0, 0};

      for (byte j = 0; j < 24; j++) {
        d[  j / 8] = d[j / 8] | ((leds[j] >> i & 1) * ROWS[7 - j % 8]);
      }

      digitalWrite(LATCH, LOW);
      shiftOut(DATA_ROW, CLOCK_ROW, LSBFIRST, ROWS[i]);
      shiftOut(DATA_COL, CLOCK_COL, MSBFIRST, d[0]);
      shiftOut(DATA_COL, CLOCK_COL, MSBFIRST, d[1]);
      shiftOut(DATA_COL, CLOCK_COL, MSBFIRST, d[2]);
      digitalWrite(LATCH, HIGH);
//      delay(10); bỏ comment nếu bạn muốn tìm hiểu kĩ thuật quét LED
    }
  }
}

void initPin() {
  pinMode(LATCH, OUTPUT);
  pinMode(CLOCK_COL, OUTPUT);
  pinMode(DATA_COL, OUTPUT);
  pinMode(CLOCK_ROW, OUTPUT);
  pinMode(DATA_ROW, OUTPUT);
}

void setup() {
  Serial.begin(9600);
  initPin();
}

void loop() {
  parseString("HAPPY NEW YEAR 2016");
}

VII. Kết luận

Ok baby, vậy là mình đã cùng các bạn tìm hiểu về kĩ thuật quét LED, cách mắc mạch và chưa nói gì nhiều về thuật toán. Cái đó để dàng phần 2 nhé. Phần 2 mình sẽ nói kĩ hơn lại về phần lập trình này và sẽ bổ sung một số hiệu ứng đẹp vi diệu khác nữa, mong các bạn ủng hộ.

Hi vọng là các bạn tìm thấy điều lí thú trong bài viết này. Chúc các bạn làm kịp Valentine và tỏ tình thành công. :D

Chúc các bạn năm mới vui nhé và cộng đồng Arduino ngày càng phát triển.

Chuyên mục:

Intermediate - Có kiến thức cơ bản

Nào cùng làm!

Tự làm mạch led trái tim

hungpaladin — Mon, 10 Nov 2014 14:28:07 +0000

Bài viết này tôi sẽ giới thiệu cách làm một mạch đèn led trái tim kết hợp Arduino với IC HC595, bạn có thể dùng nó để tỏ tình, làm quà tặng bạn gái rất ý nghĩa và lãng mạn. Trước khi bắt đầu bạn cần tìm hiểu các bài viết sau đây:

Nếu bạn đã nắm rõ cách sử dụng IC HC595 và phương pháp làm mạch in thủ công thì chúng ta hãy bắt đầu ngay thôi:

Bạn cần chuẩn bị những thứ sau:

Arduino Uno
3 con (Màu vỏ trắng đục, không nên dùng led siêu sáng vỏ trong suốt vì ánh sáng rất chói)

24 điện trở 560 Ohm
Các vật liệu làm mạch in (, bột ăn mòn ... )

Sơ đồ nguyên lý

Phần tiếp theo không thể thiếu được, đó là lập trình điều khiển led:

// Khai báo các chân sẽ sử dụng để giao tiếp IC HC595
int latchPin = 10;
int clockPin = 12;
int dataPin = 11;

// Khai báo mảng dùng điều khiển IC
byte ledStatus[3]= {};
byte SangHet=0b11111111;
byte TatHet=0b00000000;

// Khai báo các kiểu chạy
byte Chay1[9]= {0b00000000,0b10000000,0b11000000,0b11100000,0b11110000,0b11111000,0b11111100,0b11111110,0b11111111};
byte Chay2[9]= {0b11111111,0b01111111,0b00111111,0b00011111,0b00001111,0b00000111,0b00000011,0b00000001,0b00000000};

void setup() {
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

// Hàm shiftOut ra IC 595
// Ở đây bạn hoàn toàn có thể sử dụng vòng lặp cho code ngắn gọn và chuyên nghiệp hơn
// Nhưng tôi thích làm thế này nhìn cho dễ hiểu
void shiftOutHC595(int dataPin, int clockPin, byte ledStatus[]) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin,clockPin,MSBFIRST,ledStatus[0]);
  shiftOut(dataPin,clockPin,MSBFIRST,ledStatus[1]);
  shiftOut(dataPin,clockPin,MSBFIRST,ledStatus[2]);
  digitalWrite(latchPin, HIGH);
}

// Hàm chạy led kiểu 1
void Kieu1(int _delay)
{

   for (int i = 0;i<=8;i++)
   {
      ledStatus[0]=Chay1[i];
      ledStatus[1]=TatHet;
      ledStatus[2]=TatHet;
      shiftOutHC595(dataPin,clockPin,ledStatus);
      delay(_delay);
   }

   for (int i = 0;i<=8;i++)
   {
      ledStatus[0]=SangHet;
      ledStatus[1]=Chay1[i];
      ledStatus[2]=TatHet;
      shiftOutHC595(dataPin,clockPin,ledStatus);
      delay(_delay);
   }

   for (int i = 0;i<=8;i++)
   {
      ledStatus[0]=SangHet;
      ledStatus[1]=SangHet;
      ledStatus[2]=Chay1[i];
      shiftOutHC595(dataPin,clockPin,ledStatus);
      delay(_delay);
   }
}

// Hàm chạy led kiểu 1
void Kieu2(int _delay)
{
   for (int i = 0;i<=8;i++)
   {
      ledStatus[0]=Chay2[i];
      ledStatus[1]=SangHet;
      ledStatus[2]=SangHet;
      shiftOutHC595(dataPin,clockPin,ledStatus);
      delay(_delay);
   }

   for (int i = 0;i<=8;i++)
   {
      ledStatus[0]=TatHet;
      ledStatus[1]=Chay2[i];
      ledStatus[2]=SangHet;
      shiftOutHC595(dataPin,clockPin,ledStatus);
      delay(_delay);
   }

   for (int i = 0;i<=8;i++)
   {
      ledStatus[0]=TatHet;
      ledStatus[1]=TatHet;
      ledStatus[2]=Chay2[i];
      shiftOutHC595(dataPin,clockPin,ledStatus);
      delay(_delay);
   }

}

// Hàm chạy led kiểu 3
void Kieu3(int _delay, int SoLan)
{
for (int i = 0;i<=SoLan;i++) {
   ledStatus[0]=SangHet;
   ledStatus[1]=SangHet;
   ledStatus[2]=SangHet;
   shiftOutHC595(dataPin,clockPin,ledStatus);
   delay(_delay);
   ledStatus[0]=TatHet;
   ledStatus[1]=TatHet;
   ledStatus[2]=TatHet;
   shiftOutHC595(dataPin,clockPin,ledStatus);
   delay(_delay);
}
  
}

void loop() { 
// Gọi hàm chạy kiểu 1 thời gian delay 50
Kieu1(50);
// Gọi hàm chạy kiểu 2 thời gian delay 50
Kieu2(50);
// Gọi hàm chạy kiểu 3 thời gian delay 500 và vòng lặp chạy 5 lần
Kieu3(500,5);
}

Xong rồi, sau khi hoàn thành mạch in, hàn linh kiện hãy upload code, kết nối mạch với Arduino và chạy thôi, bạn hãy tự sáng tạo các kiểu chạy led khác nhau và cùng chia sẻ với mọi người nhé. Nếu bạn có ý định dùng mạch trái tim này để tỏ tình, tặng bạn gái thì hãy dùng Arduino Mini Pro hoặc Arduino Nano cho rẻ :D hay muốn tiết kiệm hơn bạn có thể dùng Attiny85 và 1 số con vi điều khiển AVR khác tương thích với Arduino. Cách sử dụng Attiny85 tương tự Attiny13, bạn có thể tìm hiểu các bài viết liên quan đến Attiny13 tại đây:

Cuối cùng là video test sản phẩm:

Từ khóa:

led trái tim

shiftout

595

arduino

Chuyên mục:

Nào cùng làm!

Làm máy đo nhiệt độ cầm tay như thế nào, có khó không?

ksp — Sat, 04 Oct 2014 23:09:58 +0000

Giới thiệu

Đúng như tiêu đề mình đã trình bày, hôm nay chúng ta sẽ đi tìm lời giải cho bài toán trên. Qua bài viết này ngoài việc tự trả lời câu hỏi vừa được nêu ra, mình còn mong muốn hướng các bạn đến khái niệm "Học để ứng dụng và đọc để sáng tạo"! Từ đó, bạn sẽ học thêm một kĩ năng mềm đó là "bóc tách" vấn đề của một "bài toán thực tế".

Vấn đề hôm nay là gì?

Như tiêu đề đã nêu, chúng ta cần giải quyết vấn đề "làm một máy đó nhiệt độ cầm tay"! Vậy vấn đề này bao gồm những vấn đề nhỏ gì? Hãy cùng mình liệt kê nhé.

Thứ nhất, chúng ta đang làm một máy và vì vậy chúng ta cần một nguồn năng lượng! Để biết năng lượng cho một dự án Arduino là như thế nào thì bạn có thể tham khảo bài viết Pin - Năng lượng cho mọi dự án Arduino. Nói nôm na là chúng ta cần một bộ pin vừa tầm cho một máy cầm tay.

Thứ hai, làm thế nào để đọc được nhiệt độ? Rất đơn giản, chúng ta sẽ xử dụng cảm biến LM35, nếu bạn chưa biết cảm biến LM35 là gì, và làm thế nào để đọc nhiệt độ từ đó, hãy tham khảo bài viết Cảm biến nhiệt độ LM35 và cách sử dụng nó trong môi trường Arduino. Khi đã nghiên cứu xong bài viết này, chúng ta sẽ biết cảm biến LM35 rất dễ sử dụng, chỉ cần sử dụng hàm analogRead() và một công thức cực kì đơn giản và ngắn gọn!

Thứ ba, đã là máy cầm tay thì ta phải hiển thị được nhiệt độ một cách nhanh chóng nhất hay còn gọi là "thời gian thực nhiệt độ"! Vậy ta sẽ làm như thế nào? Không khó, khi đã có đươc nhiệt độ, chúng ta sẽ dùng 2 LED 7 đoạn đơn và dùng IC HC595 để shiftout ra 2 LED này, nếu chưa biết về khái niệm shiftout bạn hãy tham khảo tại đây.

Thứ tư, lựa chọn vi điều khiển cho máy cầm tay này như thé nào để hợp lý hóa giá thành và đơn giản hóa việc lắp đặt? Chúng ta sẽ thống kê số chân sẽ dùng trong dự án này, đó là 1 chân analog để đọc tín hiệu từ cảm biến LM35, 3 chân digital để shiftout ra IC HC595. Tóm lại là có 4 chân, như vậy, ta có thể dùng rất nhiều loại vi điều khiển với giá thành khác nhau để hoàn thiện dự án này. Tuy nhiên, theo mình nghỉ thì chúng ta chỉ nên dùng vi điều khiển ATtiny13 để lập trình vì nó đáp ứng được các yêu cầu mà chúng ta vừa liệt kê nãy giờ. Nếu chưa biết về vi điều khiển ATtiny13, bạn hãy tham khảo bài viết Bài 2: Attiny13 - Trợ thủ đắc lực của Arduino - Lập trình nó?

Tổng kết

Chúng ta tạm thời đã liệt kê được là 4 vấn đề có thể dễ dàng nhìn thấy ngay được nếu muốn giải quyết bài toán "làm máy đo nhiệt độ cầm tay". Vì vậy hãy giải quyết từng vấn đề và nếu có phát sinh thêm vấn đề này thì hãy cùng nhau giải quyết nó nhé!

Tuy nhiên, đầu tiên, để dễ dàng hoàn thành bài viết này, các bạn hãy chuẩn bị cho mình một số phần cứng sau:

Phần cứng

Arduino Uno
Breadboard
Dây cắm breadboard
2 điện trở 560 Ohm (hoặc 220 Ohm hoặc 1kOhm)
1 ATTiny13
2IC 74HC595
1 IC LM35
4 cục pin tiểu (con ó hoặc con thỏ nhé, loại xịn hơn thì có thể sẽ gây ra một số vấn đề đấy) và khung pin 4 viên hình lăng trụ
1 bé tụ 1uF hoặc hơn

Vấn đề 1 - Pin

Nói về pin, đây là một vấn đề nhỏ trong dự án này, vì sao?

Thứ nhất, trong máy của chúng ta sẽ làm, nó không có nhiều phần cứng đòi công suất cao và chúng đều hoạt động tốt ở mức điện áp 5V đến 6V.
Thứ hai, chúng ta hướng đến việc xây dựng một máy cầm tay nên kích thước pin và khung pin phải ở một mức nào đó mà con người cầm được. Trên thị trường đã có sẵn loại khung này (khung pin 4 viên hình lăng trụ) và việc tìm kiếm rất đơn giản.

Nói tóm lại, bạn chỉ cần tím cách đáp ứng được nhu cầu về hiệu điện thế (5V hoặc 6V) cho sản phẩm của mình là ok! Ở dự án này, chúng ta chưa quan tâm về công suất và hiệu suất của pin.

Bạn thấy đấy, phân tích một vấn đề không có gì phức tạp cả, nhiều khi nó còn rất đơn giản là đằng khác. Vậy bạn hãy bắt đầu suy ngẫm về câu hỏi sau: "làm máy đo nhiệt độ cầm tay có khó không nhé?"

Vấn đề 2 + 4 - Làm thế nào để đọc được nhiệt độ của LM35 trên ATTiny13

Bạn có ngạc nhiên vì sao tớ lại ghi là "2+4" mà không phải là "2+3"? Bởi vì khi chúng ta làm một dự án, sau bước liệt kê những vấn đề có thể cần được giải quyết thì không có nghĩa chúng ta phải giải quyết những vấn đề đó theo thứ tự vừa được liệt kê. Bạn phải vận dụng sự liên kết giữa các phần cứng (nếu có thể) để góp nhiều vấn đề con thành một vấn đề trung gian từ đó giải quyết luôn một lần. Như vậy chúng ta sẽ tăng được tốc độ làm việc và giảm thời gian làm việc cho dự án này, từ đó có thời gian làm những dự án khác hoặc có thời gian để tối ưu hóa những dòng code của mình.

Bây giờ, chúng ta đi vào nội dung chính của chủ đề này nhé.

Thứ nhất, bạn cần biết cách đọc nhiệt độ của IC LM35 trên Arduino, vì vậy, bạn cần đọc bài viết Cảm biến nhiệt độ LM35 và cách sử dụng nó trong môi trường Arduino ngay.

Thứ hai, bạn chưa biết ATTiny13 là gì? Như vậy bạn cần phải đọc và ngẫm nghĩ các bài viết về ATTiny13 trên Cộng đồng Arduino Việt Nam tại đây.

Như vậy, sau khi đã có được kiến thức về việc lập trình ATTiny13, bạn sẽ thấy vấn đề này của chúng ta sẽ hơi hơi khó nhằn, phải không? Vì dung lượng chương trình của ATTiny13 chỉ có 1KB trong khi đó code của chúng ta sẽ rất là dài (vừa đọc nhiệt độ, sau đó lại shiftout ra nữa mà). Nhưng đừng lo lắng, đó chỉ là những gì mà suy nghĩ của bạn đang cố gắng thuyết phục bạn. Hãy dập tắt nó và tiến hành, đừng lo lắng những thứ của tương lai vì chính chúng ta quyết định tương lai nó như thế nào! Vì vậy, đừng lo lắng sẽ không đủ dung lượng bộ nhớ flash, chính chúng ta sẽ quyết định code của chúng ta sẽ như thế nào mà lị !

Bây giờ, chúng ta sẽ tìm hiểu xem ATTiny13 có bao nhiêu chân Analog nhé.

Gợi ý: Những chân nào có chữ ADCx (x là một số nguyên) không âm) thì đó là chân analog đấy!

Như vậy, chúng ta có 4 chân Analog nhưng trong đó có một chân là chân ADC0 trùng với chân RESET nên rất khó dùng, nên ta hãy bỏ nó ra. Như vậy ta có 3 chân Analog có thể dễ dàng dùng được, đó là ADC1 (pin 7), ADC2 (pin 3), ADC3 (pin 2).

Vậy còn chần chừ gì nữa, hãy cùng tớ mắc mạch thôi!

Đầu tiên, bạn hãy mắc mạch như thế này nhé.

Mạch vừa rồi là mạch để chúng ta lập trình ATTiny13 qua giao thức SPI. Nếu bạn chưa biết giao thức này và cách lập trình cho ATTiny13 thì bắt buộc bạn phải xem bài viết Bài 2: Attiny13 - Trợ thủ đắc lực của Arduino - Lập trình nó?

Nếu có điều kiện và thời gian, bạn nên tự làm cho mình một mạch nạp ATTiny13 sẵn (như hình dưới), và mỗi lần cần dùng ta chỉ cần gắn nó vào.

Bây giờ, việc tiếp theo của bạn không có gì khó khăn cả. Bạn chỉ việc gắn bé LM35 như trong bài viết Cảm biến nhiệt độ LM35 và cách sử dụng nó trong môi trường Arduino. Nhưng vấn đề mới đặt ra cho bạn là: Làm thế nào để đọc tín hiểu Analog từ ATTiny13? Vâng, câu hỏi này không khó trả lời đâu bạn nhé. Bạn hãy kéo lên xem ảnh các chân của ATTiny13 và nhìn vào thông tin về các chân của nó. Nếu đã có thêm những kiến thức sâu hơn về VĐK (vi điều khiển) các loại, thì bạn sẽ nhận ra ngay ở ATTiny13 chân nào là chân Analog. Nếu chưa, thì bạn hãy để ý đến những chân có thông tin là ADCx (trong đó x là một số nguyên dương). Ở đây mình dùng chân ADC2 (chân số 3).

Câu hỏi tiếp theo mà mình nghĩ bạn sẽ thắc mắc, đó là "làm thế nào để đọc được tín hiệu điện Analog của cảm biến LM35?". Vâng, câu hỏi này khá hay và mới, bạn chỉ việc sử dụng cái số x ở trên với hàm analogRead là được ngay thôi mà .

//đọc cảm biến LM35
int lm35Pin = 2;//ADC2

void setup() {
    //Cài đặt Analog reference. Trang 91 của datasheet.
    /*
        cảm biến LM35 chỉ đo được lên đến 150 độ C (max = 1.5V).
        Nhưng mình nghĩ ta không có gì để đảm bảo độ bền của sản phẩm này
        nếu đưa nó vào nơi nào có nhiệt độ khá cao như vậy. Vì vậy, mình
        đã đặt lại analog reference của ATTiny13 ở mức 1.1 V để việc đo chính 
        xác hơn và đảm bảo được dung lượng của sketch khi upload lên ATTiny13
        khi hoàn thiện dự án.
    */
    ADMUX |= _BV(REFS0);
}

void loop() { 
    int temperature =  analogRead(lm35Pin) * 111UL / 1024;
}

Tại sao lại là 111UL / 1024UL? Nó không hề giống với công thức đã nêu ở bài Cảm biến nhiệt độ LM35 và cách sử dụng nó trong môi trường Arduino. Vâng, chúng ta sẽ cùng phân tích vấn đề này nhé. Nếu bạn dùng đồng hồ đo điện sẽ thấy chân tín hiệu của cảm biến LM35 chỉ ở mức 0.xx vol mà thôi. Như vậy nếu ta dùng analog reference là 5V thì khoảng đo của chúng ta sẽ rất nhỏ và như vậy máy của chúng ta sẽ hoạt động không chính xác! Vì thế, chúng ta sẽ chỉnh lại mức analog reference đó thành 1.1 V (thường thì bạn sẽ không đo được những thứ quá nóng nên mức 1.1 V là ổn - tuy nhiên LM35 có thể đo đến 150 độ C).

Lúc này, ta sẽ phát triển công thức từ bài trước và được công thức sau

float temperature = (1.1*analogRead(2)*100.0/1024.0);

Vì ATTiny13 khá nhỏ nên thực hiện các phép tính trên số thực sẽ làm ta tốn khá nhiều bộ nhớ. Vì thế, ta phải tối ưu hóa công thức thành các phép nhân và chia các số nguyên. Ở đây, 1.1*100 ta sẽ cho thành 110, rồi sau đó đem chia cho 1024 (các số vừa rồi là các số nguyên). Như vậy công thức sẽ trở thành.

int temperature = analogRead(2)*110/1024;

Nhưng, nếu nhìn sâu hơn một tí, bạn sẽ thấy đoạn code này lỗi ngay! Vì sao lỗi? Thứ nhất, ta đã chỉnh lại analog reference là 1.1 Vol nên hàm analogRead bình thường cũng cho một số khá lớn và tập xác định của nó là đoạn từ 0-1023. Như vậy, nếu đem giá trị đó nhân với 110 thì ta sẽ được một giá trị nằm trong khoảng từ 0-1023*110 (0-112530). Như vậy, ta sẽ có một số vượt quá khoảng xác định của int. Như vậy, ta cần dùng một kiểu dữ liệu lớn hơn để lưu trữ giá trị của phép tính này, vì vậy, mình đã viết công thức như trên. Đoạn này hơi khó giải thích, vì nó cần giải thích khá dài và trước đó mình đã có giải thích trong loạt bài về các kiểu dữ liệu số nguyên và toán tử số học trong mục Tài liệu tham khảo. Vì vậy, nếu muốn biết được chi tiết tại làm sao nó phải như thế, mình khuyên bạn nên đọc thêm những bài vừa rồi.

À, ngoài ra, ATTiny13 không có Serial Monitor nên bạn không thể debug (Tìm lỗi) một cách dễ dàng trên ATTiny13 đâu nhé. Vì vậy, để debug, bạn phải viết code lại cho Arduino Uno và test trên Arduino Uno.

Vấn đề 3 - làm thế nào để xuất giá trị của LM35 qua shiftOut bé 595

Vấn đề này vừa khó lại vừa dễ. Khó vì nó nhiều dây nhợ, dễ vì nó đơn giản chỉ là việc gắn dây !

Bạn cần lắp mạch như ở bài Cách lập trình nhiều con LED 7 đoạn (loại đơn) và bài Dùng ATTiny13 để shiftOut ra IC 595 điều khiển nhiều LED để tập lắp mạch trước và từ đó ta sẽ dùng cơ sở 2 mạch ấy để lắp thành mạch dưới đây.

Hơi khó nhìn, nhưng nếu làm 2 bài trước thì sẽ không hề khó đâu bạn. Vấn đề tiếp theo là phần lập trình. Nếu như làm 2 bài mình đã nêu ở trước thì chắc hẳn bây giờ bạn sẽ có những kinh nghiệm riêng. Nên việc đọc các dòng code dưới đây sẽ dễ hiểu hơn. Vì vậy, nếu chưa đọc 2 bài trước thì bạn nên đọc! Không vòng vo nữa, tiếp tục đến phần code nào.

//đọc cảm biến LM35
int lm35Pin = 2;//ADC2

/*
shiftOut ra 1 Module LED 7 đoạn đơn
*/
//chân ST_CP của 74HC595
int latchPin = 1;//PB1
//chân SH_CP của 74HC595
int clockPin = 0;//PB0
//Chân DS của 74HC595
int dataPin = 2;//PB2

//Timer để chỉnh lại đồng hồ của ATTiny13
int timer = 150;



// Ta sẽ xây dựng mảng hằng số với các giá trị cho trước
// Các bit được đánh số thứ tự (0-7) từ phải qua trái (tương ứng với A-F,DP)
// Vì ta dùng LED 7 đoạn chung cực dương nên với các bit 0
// thì các đoạn của LED 7 đoạn sẽ sáng
// với các bit 1 thì đoạn ấy sẽ tắt

//mảng có 10 số (từ 0-9) và 
const byte Seg[10] = {
  0b11000000,//0 - các thanh từ a-f sáng
  0b11111001,//1 - chỉ có 2 thanh b,c sáng
  0b10100100,//2
  0b10110000,//3
  0b10011001,//4
  0b10010010,//5
  0b10000010,//6
  0b11111000,//7
  0b10000000,//8
  0b10010000,//9
};


void setup() {
  
  //Cài đặt timer 
  TCCR0B |=  _BV(CS02);
  
  //Cài đặt Analog reference. Trang 91 của datasheet.
  /*
    cảm biến LM35 chỉ đo được lên đến 150 độ C (max = 1.5V).
    Nhưng mình nghĩ ta không có gì để đảm bảo độ bền của sản phẩm này
    nếu đưa nó vào nơi nào có nhiệt độ khá cao như vậy. Vì vậy, mình
    đã đặt lại analog reference của ATTiny13 ở mức 1.1 V để việc đo chính 
    xác hơn và đảm bảo được dung lượng của sketch khi upload lên ATTiny13
    khi hoàn thiện dự án.
  */
  ADMUX |= _BV(REFS0);
  
  //Bạn BUỘC PHẢI pinMode các chân này là OUTPUT
  
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}
void _delay(word time = 1) { // Xây dựng lại hàm delay
  for (word i = 1; i<=time;i++) {
    delayMicroseconds(timer);
  }
}
void HienThiLED7doan(int Giatri) {
   digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, Seg[Giatri / 10]); 
  shiftOut(dataPin, clockPin, MSBFIRST, Seg[Giatri % 10]); 
   digitalWrite(latchPin, HIGH);
}


void loop() { 
  int temperature =  analogRead(lm35Pin) * 111UL / 1024;
  HienThiLED7doan(temperature);
  _delay(500);
  
}

Như các bạn đã thấy, mình đã xây dựng lại hàm HienThiLED7doan cho nânó đơn giản hơn phù vớp với vấn đề bài toán là ta chỉ shiftout ra 2 bé 595 để điều khiển 2 bé led 7 đoạn. Vì nhiệt độ của nó máy cần đo là một số nguyên dương có 2 chữ số nên nếu mình đem số chia cho 10 sẽ được chữ số hàng chục và phần dư là hàng đơn vị.

Không hề khó phải không nào các bạn!

Video nguyên lý mình đã làm xong, bạn hãy hoàn thiện nó thành một sản phẩm nhé

Kết luận

Qua quá trình làm vừa rồi, mình nghĩ bạn có thể dễ dàng làm được dự án này và nhiều dự án hơn nữa. Thực chất các bước mình vừa làm cũng không có gì khó cả. Chỉ là việc ta phân tích vấn đề ban đầu rồi liệt kê những gì cần tìm hiểu, sau đó tiến hành giải quyết các vấn đề cần liệt kê theo thứ tự từ dễ đến khó, rồi giải quyết các vấn đề nhỏ nảy sinh ở từng phần. Cuối cùng là bước hoàn thiện sản phẩm thành những mô hình nhỏ nhỏ xinh xinh!

Làm một dự án Arduino không hề khó, nó chỉ khó khi bạn không dám đam mê và không dám tìm kiếm. Đừng nên đặt quá nhiều câu hỏi cho mình, chỉ cần nghĩ đơn giản và tìm kiếm theo những gì mình nghĩ, dần dà nó sẽ ra. Khi bí quá thì mới đặt câu hỏi. Vì hầu hết các vấn đề đều có trên mạng Internet này hết đấy, bạn ơi!

Về vấn đề "Học để ứng dụng và đọc để sáng tạo", mình xin giải thích như sau (rất mong nhận được những phản hồi tích cực của các bạn):

Học để ứng dụng
- Khi làm một việc nào đó, nếu bạn không có mục đích thì sẽ không thể nào làm một cách hoàn hảo được. Ở Việt Nam, học sinh cấp 3 học rất nhiều thứ, như đạo hàm, tích phân, vi phân,... nhưng hầu hết khi được hỏi, các bạn nói rằng: chúng tớ học để thi đại học, chúng tớ học để thi học sinh giỏi chơi cho vui,... Như thế thì giúp ích gì cho các bạn sau này? Nói thẳng ra là không giúp ích được gì cả. Vì sau này, khi lên đại học và những cấp cao hơn, các giảng viên sẽ cung cấp lại một cách khoa học và hệ thống hóa các kiến thức giúp bạn giải quyết được các vấn đề trong môn học của mình. Khi đó, bạn sẽ tự yêu thích môn học mà mình đang học và học nó thật tốt.
- Vì sao lại như vậy? Bởi vì, lúc đấy, bạn đã có một mục đích cao cả cho việc học. Đó là, học để ứng dụng. Có thể bạn sẽ phản bác ý kiến của tôi cho rằng, bạn học tốt nhưng không phải học để ứng dụng mà là học để ... (kiếm tiền, vì gia đình quá khó khăn,...). Nhưng theo quan điểm của mình, để làm được những việc đó, bạn phải ứng dụng được những kiến thức được học trong trường và tự học trong quá trình tiếp xúc cọ xát với xã hội, từ đó hoàn thiện những ước mơ cao đẹp!
- Vậy, nếu học có mục đích và nếu mục đích của nó là để ứng dụng cộng với nghị lực vượt quá thì bạn sẽ dễ dàng vượt qua mọi khó khăn!
Đọc để sáng tạo
- Bạn đã bao giờ đọc những bài giải dài dòng trong sách tham khảo và tự thấy mình có thể rút gọn nó cho dễ hiểu hơn chưa? Chắc hẳn là đa số các bạn đều đã nghĩ như vậy đúng không! Rất tốt, hãy tiếp tục suy nghĩ như vậy nhé, đó là mầm móng của sự sáng tạo.
- Bây giờ, bạn nghĩ mình sẽ giải tốt bài tập đó hơn sách, và biết đâu được sau này mình sẽ làm được một chiếc vệ tinh nhẹ hơn, to hơn và do chính con người Việt Nam chế tạo,... Trong môi trường tự nhiên, mọi cây đều xuất phát từ những hạt giống (trong tự nhiên không có ghép, chiết,... nhé), và những sản phẩm sáng tạo, những ý tưởng thông minh đều bắt nguồn từ bạn. Bạn chính là hạt giống của sự sáng tạo, và trong điều kiện thuận lợi, bạn sẽ nảy chồi và phát triển mạnh mẽ.
- Vậy, tại sao phải đọc? Đọc để biết, đọc để hiểu, đọc để sáng tạo. Ta cần phải biết "họ" làm được gì! Phải hiểu họ làm những gì! Và từ đó sáng tạo để làm cho nó tốt hơn, nó bá đạo hơn! Như vậy, nếu chịu khó đọc và suy nghĩ, những ý tưởng sáng tạo sẽ dạt dào đến với bạn. Và lúc này, như một người nông dân trồng (đọc) cây ăn quả đã đến mùa trái (sáng tạo), bạn chỉ việc hái và lựa ra những trái (ý tưởng) tốt nhất để tiến hành đem bán (hoàn thiện sản phẩm và đem bán)
Tóm tại, nếu bạn có mục đích học và dám đọc để sáng tạo thì ắc hẳn không có gì có thể cản bước bạn ngoại trừ bản thân lười biếng!
Và Cộng đồng Arduino Việt Nam sẽ luôn đồng hành cùng bạn, chia sẻ những tri thức và giúp bạn đi đến thành công!

Chúc bạn thành công!

Từ khóa:

Chuyên mục:

Level: Advanced - Nâng cao

Nào cùng làm!

Cách lập trình nhiều con LED 7 đoạn (loại đơn)

ksp — Fri, 27 Jun 2014 06:05:11 +0000

Nội dung chính, cần nắm

Điều khiển một con LED 7 đoạn loại đơn, loại kép hay loại tứ với Arduino là điều cực kỳ đơn giản. Bạn có thể tham khảo các bài viết sau nếu chỉ muốn lập trình điều khiển 1 con LED 7 đoạn:

Tuy nhiên, để điều khiển nhiều hơn 1 chú LED 7 đoạn thì ta không thể sử dụng hướng dẫn ở 2 bài hướng dẫn trên. Vì sao? Là bởi vì chúng ta không đủ "chân" cho các chú LED thứ 2, 3,... Trong phạm vi bài viết này, tớ có tham khảo một số hình ảnh, thông tin từ 2 bài viết kia để các bạn dễ dàng nắm bắt. Đồng thời, trước khi bắt đầu, bạn bắt buộc phải biết về shiftOut. Vì vậy, nếu chưa biết về shiftOut, đề nghị bạn tham khảm bài viết Điều khiển 8 đèn LED sáng theo ý muốn của bạn, dễ hay khó ?.

Được rồi, đi thẳng vào vấn đề chính ngày hôm nay nào, chúng ta sẽ tìm hiểu cách điều khiển 1 đèn LED 7 đoạn qua 1 chú HC595 được điều khiển bởi Arduino. Sau đó sẽ là 2 chú HC 595, và cứ như thế bạn sẽ làm được nhiều LED 7 đoạn hơn.

Phần cứng

Arduino Uno
2 điện trở 560 Ohm (hoặc 220 Ohm hoặc 1kOhm)
2 (dành cho việc ShiftOut)

1 tụ điện 1uF (từ 6v3 trở lên)
Breadboard
Dây cắm breadboard
1 vài chai nước (uống nước ngọt nhiều quá có nguy cơ tiểu đường)

Video demo

Giới thiệu led 7 đoạn

Bạn có thể hiểu một cách vô cùng đơn giản về LED 7 đoạn như sau:

LED 7 đoạn có 2 loại:

Chung cực dương: Mỗi đèn LED có 2 chân (1 dương 1 âm). Ở loại LED 7 đoạn này tất cả cực dương sẽ được nối chung cực dương. Để làm các đèn LED trong LED 7 đoạn sáng thì bạn chỉ cần cấp cực âm vào các chân của đèn. Với loại LED 7 đoạn này bạn chỉ cần 1 điện trở là đủ.

Chung cực âm: Tương tự nhưng ngược lại và bạn cần đến 8 điện trở cho các chân dương của LED.

Nguyên lý căn bản của LED 7 đoạn đó là cấp nguồn là nó sáng. Để nó sáng theo ý mình thì bạn cần phải nói ngôn ngữ Arduino cho mạch Arduino Uno hiểu, từ đó Arduino Uno sẽ điều khiển IC HC 595 (chỉ tốn 3 chân điều khiển), từ đó IC HC595 sẽ cấp nguồn cho các chân LED 7 đoạn theo yêu cầu của mình!

Lắp mạch

Vì tớ đã yêu cầu bạn xem về bài viết shiftOut trước khi đọc phần bài này nên trong phạm vi bài viết tớ sẽ không nhắc lại về shiftOut. Nếu bạn đã quên về shiftOut, bạn có thể tham khảo tại bài viết Điều khiển 8 đèn LED sáng theo ý muốn của bạn, dễ hay khó ?

Đầu tiên, bạn cần lắp mạch như thế này để bật IC HC595 lên.

Sau đó lắp thêm như thế này để ta có thể shiftOut từ Arduino vào IC HC595

Sau đó bạn lắp tiếp như thế này hoặc tham khảo bảng chỉ dẫn lắp mạch ở dưới

LED 7 đoạn	HC 595
1 (e)	Q4 (4)
2 (d)	Q3 (3)
4 (c)	Q2 (2)
5 (dp)	Q7 (7)
6 (b)	Q1 (1)
7 (a)	Q0 (15)
9 (f)	Q5 (5)
10 (g)	Q6 (6)

Bạn có thể tham khảo file ảnh từ Proteus sau.

Lập trình

/*
shiftOut ra 1 Module LED 7 đoạn đơn
*/
//chân ST_CP của 74HC595
int latchPin = 8;
//chân SH_CP của 74HC595
int clockPin = 12;
//Chân DS của 74HC595
int dataPin = 11;

// Ta sẽ xây dựng mảng hằng số với các giá trị cho trước
// Các bit được đánh số thứ tự (0-7) từ phải qua trái (tương ứng với A-F,DP)
// Vì ta dùng LED 7 đoạn chung cực dương nên với các bit 0
// thì các đoạn của LED 7 đoạn sẽ sáng
// với các bit 1 thì đoạn ấy sẽ tắt

//mảng có 10 số (từ 0-9) và 
const int Seg[10] = {
  0b11000000,//0 - các thanh từ a-f sáng
  0b11111001,//1 - chỉ có 2 thanh b,c sáng
  0b10100100,//2
  0b10110000,//3
  0b10011001,//4
  0b10010010,//5
  0b10000011,//6
  0b11111000,//7
  0b10000000,//8
  0b10010000,//9
};


void setup() {
  //Bạn BUỘC PHẢI pinMode các chân này là OUTPUT
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() { 
  static int point = 0;
  
  //shiftout - start
  digitalWrite(latchPin, LOW);
  //Xuất bảng ký tự ra cho Module LED
  shiftOut(dataPin, clockPin, MSBFIRST, Seg[point]);  
  digitalWrite(latchPin, HIGH);
  //shiftout - end
  
  point = (point + 1) % 10; // Vòng tuần hoàn từ 0--9
  delay(500);//Đợi 0.5 s cho mỗi lần tăng số
}

Bạn có thể tải về file Proteus và file hex của ví dụ trên Tiếp theo sẽ là 2 Module LED 7 đoạn đơn và hơn thế nữa trong tương lai

Kể từ con IC HC595 thứ 2 trở đi, bạn sẽ lắp như thế này. Con thứ 2 thì mắc vào con thứ 1, con thứ 3 thì mắc vào con thứ 2,... Sau đó xem phần lập trình của tớ để xây dựng bảng số. Tớ có viết một hàm đơn giản để sau này bạn lắp bao nhiêu thì tùy ý hehe. Con sau sẽ lắp trước con liền kề nó nhé!

LED 7 đoạn	HC 595 thứ 2
1 (e)	Q4 (4)
2 (d)	Q3 (3)
4 (c)	Q2 (2)
5 (dp)	Q7 (7)
6 (b)	Q1 (1)
7 (a)	Q0 (15)
9 (f)	Q5 (5)
10 (g)	Q6 (6)

HC 595 thứ 1	HC 595 thứ 2
11	11
12	12
9	14

Bạn có thể tham khảo cách lắp từ proteus

/*
shiftOut ra 1 Module LED 7 đoạn đơn
*/
//chân ST_CP của 74HC595
int latchPin = 8;
//chân SH_CP của 74HC595
int clockPin = 12;
//Chân DS của 74HC595
int dataPin = 11;

// Ta sẽ xây dựng mảng hằng số với các giá trị cho trước
// Các bit được đánh số thứ tự (0-7) từ phải qua trái (tương ứng với A-F,DP)
// Vì ta dùng LED 7 đoạn chung cực dương nên với các bit 0
// thì các đoạn của LED 7 đoạn sẽ sáng
// với các bit 1 thì đoạn ấy sẽ tắt

//mảng có 10 số (từ 0-9) và 
const byte Seg[10] = {
  0b11000000,//0 - các thanh từ a-f sáng
  0b11111001,//1 - chỉ có 2 thanh b,c sáng
  0b10100100,//2
  0b10110000,//3
  0b10011001,//4
  0b10010010,//5
  0b10000010,//6
  0b11111000,//7
  0b10000000,//8
  0b10010000,//9
};


void setup() {
  //Bạn BUỘC PHẢI pinMode các chân này là OUTPUT
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void HienThiLED7doan(unsigned long Giatri, byte SoLed = 2) {
  
  byte *array= new byte[SoLed];
  for (byte i = 0; i < SoLed; i++) {
    //Lấy các chữ số từ phải quá trái
    array[i] = (byte)(Giatri % 10UL);
    Giatri = (unsigned long)(Giatri /10UL);
  }
  digitalWrite(latchPin, LOW);
  for (int i = SoLed - 1; i >= 0; i--)
    shiftOut(dataPin, clockPin, MSBFIRST, Seg[array[i]]); 
  
  digitalWrite(latchPin, HIGH);
  free(array);
}


void loop() { 
  static unsigned long point = 0;
  
  HienThiLED7doan(point, 2);
  
  point = (point + 1) % 100UL; // Vòng tuần hoàn từ 0--99
  delay(500);//Đợi 0.5 s cho mỗi lần tăng số
}

Bạn hãy tải về file proteus và file hex của ví dụ này Lời kết

Càng nghiên cứu Arduino nhiều bạn sẽ cảm thấy nó cực kỳ hay (giống như tôi bây giờ). Càng nghiên cứu rành rọt những thứ cơ bản bạn sẽ dễ dàng được nhiều thứ phức tạp. Ở bài viết này, những điều đơn giản là nguyên lý led 7 đoạn rồi shiftout. Tớ tập hợp lại shiftout + nhiều led 7 đoạn. Hehe, sau này sẽ còn nhiều thứ kết hợp lại lắm. Chỉ cần bạn chịu khó nghiên cứu và sáng tạo thôi!

Uống nước nhiều vô nhé, do thời gian này là mùa hè mà!

Chuyên mục:

Intermediate - Có kiến thức cơ bản

Nào cùng làm!

Dùng ATTiny13 để shiftOut ra IC 595 điều khiển nhiều LED

ksp — Sun, 15 Jun 2014 16:03:55 +0000

Nội dung chính, cần nắm

Qua bài viết Bài 2: Attiny13 - Trợ thủ đắc lực của Arduino - Lập trình nó?, chúng ta đã biết được cách lập trình một bé ATTiny13 để làm nhấp nháy một chú đèn LED. Hôm nay, chúng ta sẽ nâng cao một tí nữa, chúng ta sẽ lập trình chú ATTiny13 này để shiftOut ra 8 LED và hơn thế nữa!

Nếu bạn chưa biết về shiftOut, bạn có thể xem bài viết này và thực hiện nó trước!

Phần cứng

Arduino Uno
Breadboard
Dây cắm breadboard
8 điện trở 560 Ohm (hoặc 220 Ohm hoặc 1kOhm)
8 đèn LED siêu sáng
1 ATTiny13
1 IC 74HC595

Lắp mạch

Đầu tiên, bạn cần lắp mạch như bài Bài 2: Attiny13 - Trợ thủ đắc lực của Arduino - Lập trình nó? !

Tiếp theo, bạn lắp thêm IC 595 như mạch sau, kích vào hình để xem kích thước thật.

Lập trình

Bạn nhớ chỉnh lại loại mạch là Attiny13 và chỉnh lại Programmer là Program as ISP.

Trước tiên, bạn cần phải nắm một khái niệm về vi điều khiển, đó là xung nhiệp (hoặc tần số của vi điều khiển). Bạn có bao giờ để ý đến "Tần số hoạt động" của mạch Arduino Uno R3 hay là chưa? (Nếu chưa, bạn có thể tham khảo tại đây). Tần số hoạt động có thể hiểu một cách "thoát nghĩa" là một cái đồng hồ của vi điều khiển. Bạn cần nó với một nhiệm vụ cực kỳ đơn giản là tính giờ! Tính giờ đểm làm gì? Để delay đợi đèn sáng đấy :P.

Trong ATTiny13, chúng ta không sử dụng được hàm delay() vì nó chiếm dụng khá nhiều bộ nhớ flash, vì vậy ta sẽ dùng hàm delayMicroseconds(). Mạch Arduino Uno có tần số là 16Mhz, và ATTiny13 chỉ có 9.6 Mhz thôi. Khi xem hướng dẫn delayMicroseconds(), ta thấy mỗi giá trị của hàm này tương đương 1 micro gây (us) bên ngoài đời thực. Vì vậy cứ mỗi giá trị của hàm này trên ATTiny13 sẽ tương ứng với 9.6 / 16 = 0.6 us (nghĩa là cứ 150us thì bằng 1 ms (ngoài đời thực) 150 = 9.6/16 * 1000 / 4 - số này mình thực nghiệm rút kinh nghiệm thôi, các bạn hỗ trợ mình phần này nhé).

Có một điều mà bạn cần biết là: ATTiny13 mặc định lại không bật cái timer (tần số hoạt động) của nó (tuy nó có sẵn một bộ timer bên trong). () bằng cách sử dụng hàm này TCCR0B |= _BV(CS02) ; trong hàm setup(). Để xem kĩ hơn về cách sử dụng của biến TCCR0B, bạn nên vào xem datasheet của ATTiny13 tại trang 73.

Sau đây, bạn hãy upload đoạn code sau để hiểu rõ hơn.

byte latchPin = 1; 
byte clockPin = 0;
byte dataPin = 2;
void setup() {     
  
  pinMode(latchPin,OUTPUT);
  pinMode(clockPin,OUTPUT);
  pinMode(dataPin,OUTPUT);
  
  // cài đặt timer
  TCCR0B |=  _BV(CS02)  ; 
}

int timer = 150;

void _delay(word time = 1) { // Xây dựng lại hàm delay
  for (word i = 1; i<=time;i++) {
    delayMicroseconds(timer);
  }
}

void _shiftOut(byte dataPin, byte clockPin, byte ledStatus) {
  digitalWrite(latchPin, LOW);
  shiftOut(dataPin, clockPin, MSBFIRST, ledStatus);  
  digitalWrite(latchPin, HIGH); 
}
void loop() {
  byte ledStatus = 0; //trạng thái Led
  _shiftOut(dataPin, clockPin, 0);
  _delay(100);
  for (byte i = 0; i < 8; i++) {
    ledStatus = ledStatus << 1 | 1;
    _shiftOut(dataPin, clockPin, ledStatus);
    _delay(100);
  }
}

Lời kết

Nước ngọt là thứ không thể thiếu trong quá trình "hack" não! Bạn hãy thoải mái đọc và hiểu một cách từ từ, tớ lúc đầu cũng hơi khó hiểu. Nhưng ngẫm đi ngẫm lại thì có mỗi cái timer là mới thôi. Còn mấy cái kia thì cũng khá ok rồi hehe!

Từ khóa:

Chuyên mục:

Intermediate - Có kiến thức cơ bản