Phone

083.7240946-0905468597

Viết bài mới

Học vi điều khiển PIC trong 1 ngày (Phần 2)

Viết bởi: le_hieu_29 - 19/03/2012

Qua bài học thứ nhất, chúng ta đã học về cách bật tắt một đèn LED. Bây giờ nếu muốn làm
cho đèn LED nhấp nháy, có nghĩa là chúng ta bật đèn LED, sau đó chờ một khoảng thời gian, và
tắt đèn led đó đi, sau đó lại chờ một khoảng thời gian nữa và lại bật đèn led lên. Muốn thực hiện
việc này, chúng ta phải tìm cách làm một hàm delay (delay - tiếng Anh có nghĩa là trễ, chậm lại).

Hàm DELAY là một hàm rất thông dụng khi lập trình thời gian thực. Nguyên lý của hàm delay là
dùng thời gian thực hiện các lệnh của vi điều khiển để làm thời gian trễ. Như các bạn đã biết (nếu
chưa biết thì bây giờ biết.. hihi), mỗi lệnh của vi điều khiển, khi thực hiện, cần phải tốn một
khoảng thời gian nào đó. Nếu một việc làm mà không tốn thời gian thì đúng là vô lý. Vậy thời gian
thực hiện một lệnh của PIC là bao lâu?
Như trong bài học đầu tiên chúng ta đã đề cập, chúng ta sử dụng thạch anh từ 4MHz đến
10MHz và đến 20MHz. Thạch anh này tạo ra các dao động xung nhịp chính xác để duy trì những
khoảng thời gian xác định cho vi điều khiển hoạt động.
Chúng ta xem hình sau để hiểu được nguyên lý tạo dao động bên trong vi điều khiển:

Thạch anh tạo dao động trên các chân OSC, đưa vào bên trong PIC. PIC sẽ đếm 4 nhịp trên dao
động thạch anh, và để thực hiện một lệnh. Như vậy, thời gian thực hiện một lệnh chính là 4 nhịp
dao động của thạch anh.
Chúng ta thường gọi thời gian thực hiện một lệnh của PIC là một chu kỳ máy (đoạn số 2 trên
hình). Vậy một chu kỳ máy bằng bao nhiêu, nếu chúng ta sử dụng thạch anh 10MHz cho PIC?
Code:

Tần số dao động của thạch anh:
F_osc = 10MHz
Chu kỳ của dao động thạch anh:
T_osc = 1/10.000.000 s
Chu kỳ máy
T_instruction = 4 * T_osc = 4/10.000.000 s = 0.0000004 s = 0.0004 ms = 0.4 us = 400ns

Như vậy, một lệnh máy được thực hiện trong vòng 0.4 micro giây, hay 400 nano giây.
Tương tự, khi các bạn dùng thạch anh 4MHz, chu kỳ máy sẽ là 1us, và dùng thạch anh 20MHz,
chu kỳ máy sẽ là 200 nano giây.
Quay trở lại với việc nếu chúng ta cần thực hiện một việc gì đó giống như nhấp nháy đèn
LED, thì chúng ta cần PIC phải dừng lại, không làm gì cả để chờ chúng ta. Nếu như lệnh NOP (lệnh
không làm gì) sẽ giúp chúng ta chờ 0.4 us, mà chúng ta cần chờ 1 giây, thì chúng ta viết bao
nhiêu lệnh NOP cho đủ? Thay vì như vậy, chúng ta viết một vòng lặp để cho vi điều khiển làm một
việc vô thưởng vô phạt nào đó N lần, và mỗi lần như vậy nó tốn T chu kỳ máy. Như vậy, sau khi
kết thúc việc làm vô thưởng vô phạt đó, vi điều khiển đã chờ chúng ta N * T chu kỳ máy.
Để viết một vòng lặp như vậy, trước tiên chúng ta học cách đặt biến.
Một biến được đặt trong PIC, thực chất là một tên gọi chung cho một hoặc nhiều thanh ghi các giá
trị. Trong phần này, chúng ta chỉ đơn giản làm đặt biến có nghĩa là đặt tên cho một thanh ghi.
Thực ra, chúng ta hoàn toàn không cần đặt tên, mà có thể gọi trực tiếp địa chỉ của thanh ghi,
nhưng nếu làm như vậy, sau này, khi chương trình phức tạp dần lên, chúng ta sẽ dễ bị lẫn lộn các
biến.
Khi đặt biến, thanh ghi này nằm ở đâu? Nó sẽ nằm trong bộ nhớ chương trình và cụ thể,

nó sẽ nằm trong vùng nhớ dùng chung mà chúng ta đã đề cập trong bài học trước.
Vậy làm thế nào để đặt biến? Có rất nhiều cách đặt biến, và trong phần này, tôi sẽ hướng dẫn các
bạn cách đặt biến mà tôi cho rằng rõ ràng nhất.
Code:

;================================================= =================
ORG 0x020
COUNT_L RES 1
COUNT_H RES 1
COUNT_N RES 3
;================================================= =================

Các bạn vừa làm gì?
Directive ORG dùng để xác định địa chỉ vùng nhớ. Các bạn lưu ý rằng, khi xác định địa chỉ
vùng nhớ ở đây, chính là các bạn xác định địa chỉ vùng nhớ dữ liệu, chứ không phải địa chỉ vùng
nhớ lập trình. Những gì các bạn viết phía bên dưới, sẽ giúp cho trình dịch hiểu được rằng các bạn
đang làm việc trong vùng nhớ lập trình, hay vùng nhớ dữ liệu
Directive RES quy định việc đặt biến. Số 1 phía sau xác định rằng biến có tên COUNT_L chiếm 1
thanh ghi 8 bit, tức là 1 byte. Tiếp theo, các bạn lại đặt biến tên là COUNT_H. Như vậy, biến
COUNT_H cũng chiếm 1 byte.

Câu hỏi đặt ra là các thanh ghi này nằm ở đâu?
Các bạn lưu ý, khi các bạn dùng directive ORG, là các bạn đã xác định nơi bắt đầu đặt biến.
Như vậy, biến COUNT_L sẽ có độ dài 1 byte, và được đặt ở địa chỉ 0x020 tức là địa chỉ đầu tiên
của vùng nhớ dữ liệu dùng chung trong băng 0 (20h)
Vì COUNT_L đã chiếm 1 byte. Do đó, biến COUNT_H sẽ chiếm byte tiếp theo, và địa chỉ đầu tiên
của COUNT_H sẽ là 21h, nhưng COUNT_H cũng chỉ có 1 byte, cho nên nó chính là thanh ghi ở địa
chỉ 21h. Đến biến COUNT_N, tương tự, địa chỉ đầu tiên của nó sẽ là 22h. Biến COUNT_N chiếm 3
thanh ghi, như vậy, biến COUNT_N sẽ nằm từ 22h, 23h đến 24h. Nếu tiếp tục đặt thêm các biến
khác, các biến đó sẽ bắt đầu từ địa chỉ 25h, cứ như thế.
Nếu hiểu nôm na theo cách này, bạn có thể sẽ dễ hiểu nó hơn, một hằng là một giá trị. Giá
trị đó có thể nằm trong thanh ghi dữ liệu (bộ nhớ dữ liệu), nhưng cũng có thể nằm trong lệnh điều
khiển (bộ nhớ chương trình). Điều này khẳng định rằng, hằng là một giá trị.
Một khi bạn đặt một tên nào đó, để đại diện cho một hằng số, có nghĩa là thay vì bạn viết cái giá
trị đó, thì bạn viết cái tên đại diện đó, để dễ nhớ. Chẳng hạn, bạn viết chữ pi, đại diện cho hằng
số có giá trị 3.1415926....
Trong khi đó, nếu bạn đặt một biến pi, thì có nghĩa là bạn xác định địa chỉ của thanh ghi dữ
liệu nào đó, mà mỗi khi bạn truy xuất đến biến pi, có nghĩa là bạn đang thao tác với thanh ghi ở
địa chỉ mà biến pi đại diện. Ví dụ: bạn đặt biến pi ở thanh ghi 0x20 chẳng hạn. Điều đó có nghĩa là
khi ban làm gì với biến pi, chính là bạn đang làm việc với thanh ghi ở địa chỉ 0x20.
Nhưng bạn sẽ thấy rằng, vậy biến pi và hằng số pi có gì khác nhau? Bây giờ biến pi và hằng pi
cũng đều mang giá trị cả. Nhưng các bạn nên nhớ, trong câu lệnh lúc nào vị trí của biến (thanh
ghi) F, và vị trí của hằng số k (trong cấu trúc một câu lệnh MPASM, tôi sẽ post lại bài này từ
dddt). có sự phân biệt rõ ràng.
Vậy tùy theo vị trí bạn đặt nó ở đâu, nó sẽ là biến, hoặc là hằng. Nếu là biến, nó chỉ mang
giá trị của dịa chỉ của thanh ghi nằm trong bộ nhớ dữ liệu, nếu là hằng, nó nằm đâu cũng được kể
cả ở bộ nhớ dữ liệu và bộ nhớ chương trình.
Vậy muốn đặt biến ở các băng khác thì làm thế nào? Các bạn cứ lấy địa chỉ đầu của vùng nhớ dữ
liệu dùng chung của băng đó và viết như sau:
Code:

;=================================================
ORG 0x0A0h
COUNT_X RES 10
;=================================================

Tóm lại, để chuẩn hoá một chương trình, các bạn chép đoạn code này vào, và sau đó không bao
giờ còn phải viết lại nữa:
Code:

;================================================= ======================
;-----------------------------------
; Bien nam o Bank0
;-----------------------------------
ORG 0x020
COUNT_L RES 1
COUNT_H RES 1
;----------------------------------
; Bien nam o Bank1
;----------------------------------
ORG 0x0A0
COUNT1_L RES 1
;---------------------------------
; Bien nam o Bank2
;---------------------------------
ORG 0x120
;================================================= =======================

Như vậy, một chương trình tổng quát bây giờ sẽ trở thành như thế nào?
Code:

; Phần chú thích ban đầu
;
;================================================= =======================
; Phần khởi tạo vi điều khiển
TITLE
PROCESSOR
INCLUDE
__CONFIG
;================================================= =======================
; Phần đặt biến
;-------------------------------------
; Biến ở băng 0
;-------------------------------------
ORG 0x020
;------------------------------------
; Biến ở băng 1
;------------------------------------
ORG 0x0A0
;------------------------------------
; Biến ở băng 2
;------------------------------------
ORG 0x120
;================================================= ========================
; Phần chương trình chính
ORG 0x0000
GOTO MAIN
ORG 0x0005
MAIN
; những dòng lệnh được viết ở đây
END
;================================================= =========================

Như vậy, chúng ta đã biết cách viết một chương trình đầy đủ dành cho vi điều khiển PIC
bằng ngôn ngữ MPASM. Các bạn cần chú ý thêm, nếu phía trên chỗ biến ở băng 2, các bạn không
đặt biến gì cả, thì các bạn cứ để nguyên như vậy, vì ngay bên dưới, các bạn đã đặt lại địa chỉ
0x0000, nó chẳng ảnh hưởng gì đến chương trình. Cũng giống như, nếu bạn không viết gì ở đoạn
ORG 0x0000 và GOTO MAIN, mà bạn để ngay dòng ORG 0x0005 thì chương trình vẫn chạy bình
thường. Đơn giản là từ đoạn 0x0000 đến 0x0004, PIC sẽ không làm gì cả. Chúng tôi đang cố gắng
từng bước hình thành cho bạn kết cấu chương trình viết bằng MPASM, mỗi ngày một hoàn thiện
hơn, để các bạn nắm rõ lý do vì sao các chương trình được viết như vậy, và chúng ta cùng thống
nhất với nhau ở điểm này khi viết chương trình. Nếu các bạn tin tưởng vào việc tạo ra một chuẩn
viết chương trình MPASM cho Việt Nam, thì các bạn là người đang đặt nền móng cho nó. Tôi cũng
có tham vọng này, cho nên các quy cách ký hiệu tôi cố gắng dùng một chuẩn thống nhất, và
mong rằng các bạn cùng tôi làm việc này, để sau này tất cả mọi người khi làm việc cùng với nhau
có thể hiểu và truyền tải ý tưởng một cách nhanh nhất.
Kể từ nay, các bạn đã biết cách đặt biến, biết cách viết phần khởi tạo, chúng ta sẽ chỉ còn
bàn tới việc viết ở phần chương trình chính như thế nào nữa mà thôi.
Code:

;================================================= ===========================
ORG 0x0000
GOTO MAIN
ORG 0x0005
MAIN
BANKSEL TRISB
CLRF TRISB ; đặt portb là output
MOVLW D'255'
MOVWF COUNT_L ; COUNT_L là 1 byte
BANKSEL PORTB
LOOP BSF PORTB, 0
CALL DELAY
BCF PORTB, 0
CALL DELAY
GOTO LOOP
;================================================= ============================
; Các chương trình con
;================================================= ============================
DELAY DECFSZ COUNT_L, F
GOTO DELAY
RETURN
;================================================= ============================
GOTO $
END
;================================================= ============================

Các bạn vừa làm gì với đoạn chương trình trên?
Điểm thứ nhất các bạn nên chú ý, đó là việc tôi thêm phần các chương trình con vào trong
phần chương trình chính. Phần cuối chương trình tôi vẫn luôn để là GOTO $ và kết thúc với lệnh
END. Tạm thời các bạn cứ viết như vậy để khoá chương trình ở dòng GOTO $, khi chương trình
nhảy đến đó, nó sẽ thực hiện vòng lặp vô cùng tại chỗ, còn lệnh END là lệnh bắt buộc.
Việc này giúp chúng ta phần tách rạch ròi phần chương trình con và chương trình chính để
tránh nhầm lẫn. Bởi vì ở đây chúng ta mới bắt đầu các bài học cơ bản, cho nên tôi cho rằng các
chương trình của các bạn viết là ngắn, nên chúng ta chưa đi xa hơn về việc phân bổ vị trí này. Các
bạn chỉ đơn giản hiểu là chúng ta cần phải bỏ đoạn chương trình con ở đâu đó, và chúng ta nên
tách thêm một phần nữa để dành riêng cho việc viết chương trình con. Việc làm này về sau sẽ rất
có lợi, nhưng tạm thời chúng ta khoan bàn tới, và chúng ta cứ viết như vậy đã.
Phân tích về đoạn chương trình con này, chúng ta thấy chương trình con luôn bao gồm như sau:
Code:

[NHÃN]
các câu lệnh
RETURN

Lưu ý rằng ở trên, chúng ta gọi chương trình con CALL DELAY. Như vậy, việc gọi hàm được
thực hiện bằng lệnh CALL [NHÃN].
Con trỏ chương trình sẽ nhảy về [NHÃN] được gọi. Nó thực hiện các lệnh nằm từ nhãn đó trở đi.
Thực hiện cho đến khi gặp lệnh RETURN, nó sẽ quay trở về và thực hiện lệnh tiếp theo ngay bên
dưới lệnh CALL. Ở đây, chúng ta gặp phải một vấn đề, đó là khái niệm Top of Stack. Tuy nhiên,
chúng ta tạm gác nó lại cho bài học sau, còn bây giờ các bạn chỉ cần nắm được việc thực hiện lệnh
CALL bao giờ cũng đi kèm với một nhãn. Con trỏ nhảy tới nhãn và thực hiện các lệnh bên trong
đó, đến khi gặp lệnh RETURN thì nó nhảy trở về vị trí nằm sau lệnh CALL đó và thực hiện tiếp
công việc đang làm.
Vì bỏ qua khái niệm Top of Stack, cho nên đề nghị các bạn không đặt ra câu hỏi nếu trong
các lệnh thực hiện, nó lại có một lệnh CALL gọi đi chỗ khác thì làm thế nào? Chúng ta sẽ giải
quyết vấn đề này ở phần sau.


Thế bên trong hàm DELAY chúng ta làm những gì?
Lưu ý rằng, ở trên chương trình chính, sau khi đã khởi tạo PORTB là ngõ output, các bạn
thấy chúng ta đã ghi giá trị d'255' vào biến COUNT_L. Cách viết giá trị như sau:
b'11001010' để xác định số nhị phân
d'234' để xác định số thập phân
0xF3 để xác định số thập lục phân
Lưu ý:
Số nhị phân chỉ có các giá trị 0 và 1, và tối đa dài 8 bit. Số thập phân chỉ có thể có giá trị từ 0 đến
255, và số thập lục phân chỉ có giá trị từ 00 đến FF
Quay trở lại, biến COUNT_L đang mang giá trị 255.
Khi thực hiện hàm DELAY, các bạn thực hiện lệnh DECFSZ (DECrement File, Skip if Zero), có nghĩa
là nó sẽ giảm giá trị của một thanh ghi nào đó một đơn vị. Nếu sau khi giảm xong, mà kết quả là
0, thì nó sẽ nhảy cách ra một ô nhớ trong bộ nhớ chương trình, và thực hiện lệnh tiếp theo đó.
Nếu giá trị sau khi giảm một đơn vị chưa bằng 0, thì nó sẽ thực hiện lệnh liền kề với nó.
Như vậy, vòng lặp được thực hiện như sau:
Code:

COUNT_L = 255 (ở trên đã đặt)
DELAY COUNT_L = COUNT_L - 1
if COUNT_L <> 0
GOTO DELAY
if COUNT_L = 0
RETURN

Code

Lệnh DECFSZ [File], F/W

Nếu phía sau dấu phẩy, chúng ta để W, thì kết quả sẽ lưu vào thanh ghi W, và [File] không
thay đổi giá trị gì hết. Nhưng ở đây, chúng ta muốn thực hiện như đoạn mã giả ở trên, nên chúng
ta phải để là F. COUNT_L sẽ giảm dần từ 255 đến 1, trong quá trình đó nó cứ chạy lên DELAY, rồi
giảm COUNT_L một đơn vị, xong lại nhảy về DELAY, lại thực hiện việc giảm 1 đơn vị của COUNT_L
Khi COUNT_L = 1 nó lại giảm 1 đơn vị, lúc này COUNT_L = 0. Và nó không thực hiện lệnh GOTO
nữa, mà thay bằng lệnh NOP, sau đó nó thực hiện lệnh RETURN, có nghĩa là quay về lại lệnh CALL
ở trên. Như vậy, các bạn đã hiểu rõ hàm DELAY rồi. Nhưng quan trọng nhất là làm sao tính toán
được thời gian hao tốn của đoạn vòng lặp này kể từ khi bắt đầu thực hiện lệnh CALL, vì thực ra
chúng ta muốn là muốn biết chính xác thời gian thực hiện lệnh của nó.


Thời gian thực hiện của lệnh CALL DELAY là bao lâu?
Lệnh CALL khi thực hiện tốn 2 chu kỳ máy, như vậy chúng ta ghi chú là (2) ở đây.
Lệnh DECFSZ tốn 1 chu kỳ máy khi giá trị trả về khác 0. Như vậy, trong quá trình thực hiện giảm
từ 255 xuống 1, nó thực hiện 255 - 1 = 254 lần. Mỗi lần thế này nó tốn 1 chu kỳ máy, chúng ta
ký hiệu (254) ở đây. Khi thực hiện lệnh GOTO, lệnh GOTO tốn 2 chu kỳ máy, vậy nó cũng thực
hiện 254 lần, chúng ta ký hiệu (254 x 2 = 506) ở đây.
Khi COUNT_L = 1, nó vẫn thực hiện lệnh DECFSZ, vậy nó tốn thêm 1 chu kỳ máy nữa (1). Sau khi
thực hiện lệnh này, kết quả trả về là 0, vậy nó sẽ thực hiện một lệnh NOP (1), và sau đó thực hiện
lệnh RETURN, lệnh RETURN tốn 2 chu kỳ máy (2)
Kết quả:
(2) + (254) + (508) + (1) + (1) + (2) = 768 chu kỳ máy
Nếu chúng ta dùng thạch anh 10MHz, 1 chu kỳ máy tốn 0.4 us, có nghĩa là lệnh CALL DELAY tốn
768 * 0.4 us tức là khoảng 1/3000 giây.
Chúng ta khoan bàn đến việc xa hơn, vậy thì chúng ta đã biết cách tính thời gian hao tốn của hàm
DELAY rồi. Nhưng nếu tính như thế này thì quá mất công, chúng ta có thể chuyển nó thành công
thức cụ thể như sau:
CALL = 2
DELAY (COUNT_L) = [COUNT_L - 1] * (DECFSZ + GOTO) + 1 + 1
RETURN = 2
Các bạn nên nhớ công thức này để sau này phát triển lên tính các công thức khác.
Có lẽ hôm nay chúng ta tạm dừng bài học ở đây.


Tổng kết
Các bạn đã học được gì ngày hôm nay?
- Các bạn đã hiểu được khái niệm chu kỳ máy, dao động thạch anh tạo ra, PIC sẽ thực hiện 1 lệnh
trong vòng 4 dao động của thạch anh. Như vậy, chu kỳ máy của PIC sẽ là chu kỳ dao động của
thạch anh nhân với 4, hay tần số PIC sẽ bằng tần số thạch anh chia 4.
- Các bạn đã học được cách đặt biến trong một chương trình viết bằng MPASM, các bạn đã có thể
đặt biến ở bất kỳ băng nào các bạn muốn
- Sau đó, các bạn bổ sung phần đặt biến này vào trong sườn chương trình lần trước đã học, các
bạn hoàn thiện hơn sườn một chương trình viết bằng MPASM
- Các bạn lại thêm vào sườn chương trình đó phần các chương trình con, vậy tôi thông báo với các
bạn rằng các bạn chỉ còn thiếu 2 phần nữa là ngắt (Interrupt) và bảng (Table) nữa, là các bạn đã
có thể có một sườn chương trình viết bằng MPASM hoàn chỉnh. Các bạn sẽ không phải đợi lâu để
hoàn tất sườn chương trình này.
- Các bạn học được cách dùng hàm CALL và RETURN, nó luôn luôn đi kèm từng cặp với nhau.
- Các bạn học thêm các lệnh: BCF, CALL, RETURN, DECFSZ
Tài liệu tham khảo:

Các bạn tham khảo datasheet PIC16F84A, PIC16F628A và PIC16F88 để biết thêm chi tiết
về cấu trúc bộ nhớ dữ liệu, vì có cái thì có băng 2, có cái không có, có cái lại có băng 3, băng 4....
Nhớ chú ý phần tập lệnh để đọc hiểu thêm về các lệnh vừa học (Instruction Set). Các bạn có thể
dùng keyword: DELAY để tìm trong trang http://www.piclist.com/ những đoạn chương trình con
viết về hàm DELAY, làm thế nào để viết hàm DELAY dài hơn?...
Lưu ý cuối cùng, đó là các bạn đang chuẩn bị trở thành một người viết PIC chuyên nghiệp,
do đó, các bạn cần phải nhớ các chân nào của PIC để thiết kế mạch và điều khiển, các bạn nên in
hình sơ đồ chân của PIC ra để dán lên trước bàn làm việc. Các bạn có thể download bản in tại đây
(có trong datasheet, nhưng tôi muốn gửi trực tiếp cho các bạn để các bạn đỡ mất công).


Bài tập làm thêm:
1) Các bạn thấy rằng, nếu thời gian DELAY quá ngắn, trên thực tế các bạn sẽ khó thấy đèn LED
nhấp nháy. Vì vậy, thay vì viết một hàm CALL DELAY, các bạn viết một dọc 20 dòng CALL DELAY
liên tiếp nhau, các bạn sẽ thấy sự khác biệt
2) Nhưng nếu viết 20 dòng CALL DELAY thì cũng như viết 20 dòng lệnh NOP, vậy có nghĩa là các
bạn vẫn có thể thực hiện một vòng lặp, trong đó lặp lại 20 lần, và trong vòng lặp các bạn thực
hiện hàm DELAY. Như vậy, các bạn phải viết một hàm DELAY_NGOAI để bên trong thực hiện hàm
DELAY_TRONG. Chính vì vậy, tôi gợi ý cho các bạn tìm trong trang web http://www.piclist.com/
để tìm các source code hàm DELAY, và các bạn sẽ biết phải làm sao để viết hàm DELAY chờ lâu
hơn. Quan trọng nhất là các bạn phải chỉ ra được công thức tính toán thời gian của hàm DELAY mà
các bạn viết. (bài tập tính điểm)
3) Bây giờ các bạn có thể điều khiển một đèn LED, vậy nếu muốn 8 đèn LED nháy theo thứ tự nào
đó chẳng hạn, các bạn sẽ làm thế nào? (bài tập tính điểm)

Nguồn : Picvietnam

Ý kiến bạn đọc
2 phản hồi về "Học vi điều khiển PIC trong 1 ngày (Phần 2)".
 
le_hieu_29 - le_hieu_29@yahoo.com
14h:31' - 19/03/2012
Bổ sung:

Bài 2. Hàm Delay

 
tantan - dkttank34@gmail.com
19h:15' - 14/04/2014
moi nguoi giup minh hieu them về ghép nối song song của PIC

Ý kiến của bạn : moi nguoi giup minh hieu them về ghép nối song song của PIC

Hãy Đăng Nhập hoặc đăng ký thành viên để chia sẻ,bình luận và tích lũy điểm.
Thegioiic-live-support