Arduino Uno R3 I2C | Các Lỗi Thường Gặp Khi Sử Dụng I2C Lcd

Giới thiệu LCD 16×2

Thông số kỹ thuật LCD 16×2

LCD 16×2 được sử dụng để hiển thị trạng thái hoặc các thông số.

• LCD 16×2 có 16 chân trong đó 8 chân dữ liệu (D0 – D7) và 3 chân điều khiển (RS, RW, EN).
• 5 chân còn lại dùng để cấp nguồn và đèn nền cho LCD 16×2.
• Các chân điều khiển giúp ta dễ dàng cấu hình LCD ở chế độ lệnh hoặc chế độ dữ liệu.
• Chúng còn giúp ta cấu hình ở chế độ đọc hoặc ghi.

LCD 16×2 có thể sử dụng ở chế độ 4 bit hoặc 8 bit tùy theo ứng dụng ta đang làm.

Arduino – Giao tiếp I2C

Ngoài chuẩn truyền thông thông nối tiếp Serial, chúng ta còn có một chuẩn giao tiếp khác giữa các vi điều khiển, IC đó là chuẩn I2C.

Ở chương này, chúng ta sẽ tìm hiểu các nội dung sau:

• Các khái niệm liên quan tới giao tiếp I2C như: mô hình master/slave, hoạt động cơ bản – truyền, nhận bit của giao thức I2C.

• Cách xác định địa chỉ của thiết bị trong giao tiếp I2C bằng chương trình, xác định địa chỉ với nhiều thiết bị khác nhau, những vấn đề xảy ra với nhiều thiết bị giống nhau trong truyền, nhận dữ liệu I2C.

• Sử dụng giao tiếp I2C đơn giản với LCD và OLED.

• Giao tiếp giữa 2 board Arduino Uno với nhau thông qua chuẩn I2C.

Mô hình Master/slave

Master/slave là một mô hình giao tiếp mà một thiết bị có thể điều khiển ít nhất một thiết bị khác. Mô hình master/slave được dùng để chỉ các mô hình giao tiếp giữa các thiết bị điện tử, cơ khí và máy tính.

Trong mô hình master/slave, một thiết bị được chọn làm master (thiết bị chủ điều khiển các thiết bị khác), các thiết bị còn lại làm vai trò slave (là các thiết bị chịu sự điều khiển của master).

Ví dụ, trong một mô hình ta có một vi điều khiển muốn điều khiển, hoặc đọc dữ liệu từ các cảm biến, relay,… thì vi điều khiển đóng vai trò là một master và các cảm biến, relay sẽ đóng vai trò là slave.

Giao tiếp I2C

Giới thiệu

I2C là một chuẩn giao tiếp theo mô hình master/slave được phát triển vào năm 1982 bởi hãng Philips cho việc giao tiếp ngoại vi giữa các vi điều khiển, IC trong khoảng cách ngắn. Chuẩn giao tiếp I2C được sử dụng rất phổ biến trong các thiết bị điện tử bởi đặc tính dễ thực hiện với giao tiếp giữa một hoặc nhiều thiết bị làm master với một hoặc hoặc nhiều thiết bị làm slave. Các hãng sản xuất IC ngày nay đều hỗ trợ giao tiếp I2C trên các IC có ứng dụng cần giao tiếp với các IC hay các vi điều khiển khác.

Giao tiếp I2C chỉ sử dụng 2 dây cho việc giao tiếp giữa 128 thiết bị với việc định địa chỉ 7 bit và 1024 thiết bị với việc định địa chỉ 10 bit. Khi đó, mỗi thiết bị trong mô hình master/slave sẽ có một địa chỉ cố định và duy nhất và master sẽ lựa chọn thiết bị nào cần giao tiếp.

Hoạt động

I2C sử dụng 2 dây giao tiếp là SCL và SDA. Dây SCL (viết tắt của Serial Clock Data) là dây truyền xung clock phát từ thiết bị master đồng bộ với việc truyền dữ liệu. Dây SDA (Serial Data) là dây truyền dữ liệu.

Mạch vật lý I2C là mạch cực thu hở, do đó để mạng I2C có thể hoạt động được, cần tối thiểu 2 cặp điện trở pull-up như trên hình, thông thường các giá trị điện trở 4k7 hoặc 1k2 được sử dụng, tùy thuộc vào tốc độ truyền và khoảng cách truyền.

Truyền nhận bit trong I2C

Các dữ liệu được truyền trong I2C dạng các chuỗi 8 bit. Sau khi bit Start đầu tiên được truyền, 8 bit tiếp theo chứa thông tin về địa chỉ của thiết bị sẽ được truyền tiếp. Sau đó, một bit ACK sẽ được truyền để xác nhận việc truyền bit thành công. Sau khi truyền bit ACK, 8 bit tiếp theo chứa thông tin địa chỉ thanh ghi nội của thiết bị slave sẽ được truyền. Sau khi hoàn tất việc định địa chỉ với 8 bit này, một bit ACK nữa sẽ được truyền để xác nhận. Sau đó, 8 bit Data sẽ được truyền tiếp theo. Cuối cùng, quá trình truyền kết thúc với 1 bit ACK và 1 bit Stop xác nhận việc truyền dữ liệu kết thúc.

Để hiểu rõ hơn về quá trình truyền nhận dữ liệu và bit trong I2C, tham khảo: Understanding the I2C Bus, How I2C Communication Works and How To Use It with Arduino.

Sử dụng giao thức I2C

Với các vi điều khiển, IC, cảm biến,… có hỗ trợ chuẩn giao tiếp I2C thì sẽ có 2 chân có tên SCL và SDA, tương ứng với 2 dây SCL, SDA cho giao tiếp I2C. Với board Arduino Uno, chân A4 là chân SDA và chân A5 là chân SCL, 2 chân A4, A5 này cũng được nối tới 2 chân SDA, SCL tương ứng ở header sử dụng với OLED của board Arduino Uno. Với các IC và vi điều khiển được sản xuất ngày nay đều có hỗ trợ điện trở nội kéo lên do đó trong việc kết nối dây không cần thêm điện trở nội kéo lên. Với các module hỗ trợ I2C chỉ có 1 tính năng như OLED SSD1306, LCD 1602 để hiển thị, Cảm biến AM2315 để đọc nhiệt độ, độ ẩm của môi trường,… thường hoạt động ở chế độ slave và có 4 chân: SDA, SCL, GND và VCC.

Viết chương trình cho I2C

Chương trình cho giao tiếp I2C giữa cảm biến và vi điều khiển thường cần thư viện thích hợp cho từng loại vi điều khiển. Các cảm biến, thiết bị,… sẽ đọc dữ liệu từ môi trường và gởi về cho vi điều khiển cũng như vi điều khiển sẽ điều khiển các thiết bị thông qua giao tiếp I2C. Nhiều loại cảm biến, module cần dùng thêm thư viện riêng cho việc đọc, hiển thị dữ liệu,…

Một số chương trình có yêu cầu phải khai báo địa chỉ của thiết bị slave trong giao tiếp I2C thì việc đọc, hiển thị dữ liệu mới thực hiện được. Khi đó, nảy sinh vấn đề phải xác định được địa chỉ của thiết bị trong giao tiếp I2C. Địa chỉ này thường được cung cấp trong datasheet của thiết bị, hoặc có thể xác định thông qua các chương trình đọc địa chỉ.

Để sử dụng thư viện I2C trong Arduino, người dùng cần gọi thư viện

tích hợp sẵn trên trình biên dịch Arduino IDE.

Xác định địa chỉ của thiết bị trong giao tiếp I2C

Như đã trình bày ở phần giới thiệu, mỗi thiết bị trong giao tiếp I2C sẽ có một địa chỉ riêng. Các địa chỉ này sẽ được nhà sản xuất cung cấp trong datasheet của thiết bị. Ở phần này, chúng ta sẽ tìm hiểu về chương trình xác định địa chỉ của một thiết bị trong giao tiếp I2C. Một số linh kiện có hỗ trợ I2C nhưng người dùng khó tìm được datasheet chính thức từ nhà sản xuất thì việc dùng một chương trình ngắn để định địa chỉ I2C là một việc làm đơn giản và cần thiết.

Yêu cầu

Xác định địa chỉ các thiết bị trong giao tiếp I2C và phát hiện số thiết bị có giao tiếp I2C trong kết nối hiện tại.

Linh kiện cần dùng

• Board Arduino Uno

• Module LCD 20×4

Source code


#include

void setup() { Wire.begin(); // Khởi tạo thư viện Wire Serial.begin(9600); while (!Serial); // Đợi Serial Monitor hiển thị Serial.println("I2C Scanner"); } void loop() { byte error, address; int nDevices; Serial.println("Scanning..."); nDevices = 0; // Định địa chỉ I2C có 7 bit ứng với 128 thiết bị, việc quét sẽ tiến hành // từ 1 tới 127 (1 thiết bị làm master nên chỉ còn 127) for (address = 1; address < 127; address++ ) { Wire.beginTransmission(address); error = Wire.endTransmission(); if (error == 0) { Serial.print("I2C device found at address 0x"); if (address < 16) Serial.print("0"); Serial.print(address, HEX); Serial.println(" !"); nDevices++; Serial.println("Device no. " + String(nDevices)); } else if (error == 4) { Serial.print("Unknown error at address 0x"); if (address < 16) Serial.print("0"); Serial.println(address, HEX); } } if (nDevices == 0) Serial.println("No I2C devices found\n"); else Serial.println("number of devices " + String(nDevices)); delay(5000); // Delay 5s cho quá trình scan tiếp theo }



Với chương trình này, đầu tiên ta kiểm tra khi chỉ có 1 master – 1 slave với master là board Arduino Uno và slave là Module LCD 20×4 (các kiến thức cơ bản về hoạt động của LCD bạn đọc tham khảo ở nội dung phần tiếp theo).

Module LCD20x4	Arduino Uno
VCC	5V
GND	GND
SDA	A4
SCL	A5

Sau khi kết nối thành công, ta nạp chương trình trên vào board Arduino Uno và kiểm tra kết quả.

Kết quả:

• Số thiết bị kết nối vào là 1 thiết bị.

• Slave có địa chỉ I2C là 0x3F, ta sẽ dùng địa chỉ này để khai báo trong những chương trình giao tiếp I2C với module này.

Tiếp theo, ta xét việc định địa chỉ với chương trình trên khi trong giao tiếp I2C có ít nhất 2 thiết bị làm slave. Kết nối board Arduino Uno với LCD 20×04 và OLED SSD1306.

OLED SSD1306	Arduino Uno
VCC	5V
GND	GND
SDA	A4
SCL	A5

Kết nối song song các chân SCL, SDA, VCC, GND của các thiết bị slave và thiết bị master với nhau. Sau khi kết nối thành công, nạp chương trình trên vào cho board Arduino Uno.

Kết quả

Bạn đọc có thể sẽ đặt câu hỏi rằng: “Vậy việc định địa chỉ sẽ như thế nào khi trong giao tiếp I2C có 2 thiết bị giống nhau?”

Để kiểm chứng việc này, ta sẽ kết nối 2 thiết bị giống hệt nhau trong giao tiếp I2C và nạp chương trình trên. Kết quả nhận được sẽ là chương trình chỉ phát hiện được có 1 thiết bị kết nối vào, và trả về địa chỉ I2C duy nhất của thiết bị đó.

Một số module có các option để lựa chọn địa chỉ I2C thông qua việc setup phần cứng, một số module cho phép người dùng có thể định lại địa chỉ I2C bằng phần mềm, nếu không chúng ta có thể sử dụng các mạch I2C Multiplexer khi muốn kết nối nhiều module có cùng địa chỉ I2C.

Giới thiệu về LCD và OLED

Giới thiệu về LCD

LCD là chữ viết tăt của Liquid Crystal Display, tiếng Việt có nghĩa là màn hình tinh thể lỏng, đây là loại thiết bị để hiển thị nội dung, cấu tạo bởi các tế bào (cũng là các điểm ảnh) chứa các tinh thể lỏng (liquid crystal) có khả năng thay đổi tính phân cực của ánh sáng và do đó thay đổi cường độ ánh sáng truyền qua khi kết hợp với các kính lọc phân cực. LCD có ưu điểm là phẳng, cho hình ảnh sáng, chân thật và tiết kiệm năng lượng.

Các hãng sản xuất linh kiện ngày nay sản xuất nhiều module LCD hỗ trợ cho việc tương tác với các vi điều khiển mà phổ biến nhất là 2 module LCD text 16×02 và LCD text 20×04. Các thông số 16×02 và 20×04 là số hàng và số cột tương ứng của các module, ví dụ với 16×02 cho biết module có 16 hàng và 2 cột, 20×04 là 20 hàng và 4 cột.

Như ở hình vẽ, các module có 16 chân để kết nối với chức năng mỗi chân:

• 
VSS

  : Tương đương với GND – cực âm.
• 
VDD

  : Tương đương với VCC – cực dương (5V).
• 
Constrast Voltage (Vo)

  : Điều khiển độ sáng màn hình.
• 
Register Select (RS)

  : Lựa chọn thanh ghi (RS=0 chọn thanh ghi lệnh, RS=1 chọn thanh ghi dữ liệu).
• 
Read/Write (R/W)

  : R/W=0 ghi dữ liệu , R/W=1 đọc dữ liệu.
• 
Enable pin

  : Cho phép ghi vào LCD.
• 
D0 - D7

  : 8 chân nhận dữ liệu.
• 
Backlight (Backlight Anode (+) và Backlight Cathode (-))

  : Tắt bật đèn màn hình LCD.

Để khắc phục nhược điểm đấu nối nhiều dây với module LCD thông thường, các nhà sản xuất đã tích hợp thêm IC LCM1602 hỗ trợ giao tiếp I2C vào module LCD, việc đấu nối cũng như nạp chương trình từ đây sẽ trở nên đơn giản hơn.

LCM1602	Arduino Uno
VCC	5V
GND	GND
SDA	A4
SCL	A5

Chúng ta sẽ viết chương trình hiển thị ký tự lên màn hình LCD. Với module LCD có module I2C kèm theo, chúng ta cần thêm thư viện LiquidCrystal_I2C và Wire.h.

Link download thư viện : Liquid Crystal I2C. Add thư viện sau khi download vào chương trình.

Yêu cầu

Chương trình hiển thị dòng chữ “UniCloud Vietnam” và “Hello World” lên LCD trên 2 hàng

Source code


#include

#include LiquidCrystal_I2C lcd(0x3F, 20, 4); // Khởi tạo lcd 20x04 với 0x3F là địa chỉ của LCD void setup() { lcd.begin(); // Khởi tạo LCD lcd.backlight(); // Mở đèn nền của LCD lcd.setCursor(1,0); // Lệnh setCursor() tương tự như với thư viện LiquidCrystal lcd.print("UniCloud Vietnam"); lcd.setCursor(3,1); lcd.print("Hello, world!"); } void loop() { // Không làm gì cả }


Giới thiệu về OLED

OLED là chữ viết tắt của Organic Light Emitting Diode), là loại màn hình hiển thị bao gồm một lớp vật liệu hữu cơ với thành phần chính là carbon nằm giữa hai điện cực anode và cathode, nó sẽ tự động phát sáng mỗi khi có dòng điện chạy qua. OLED sử dụng diode phát quang hữu cơ, chính vì thế OLED không cần tới đèn nền chiếu sáng nên có kích thước nhỏ gọn cũng như tiết kiệm điện hơn so với các loại LCD, độ sáng của OLED cũng tương đối tốt ở môi trường sáng tự nhiên.

OLED SSD1306

OLED SSD1306 là loại OLED có màn hình loại nhỏ, kích thước tầm 0.96 inch cho tới 1.25 inch. OLED SSD1306 hỗ trợ chuẩn giao tiếp I2C được sử dụng khá rộng rãi trong các sản phẩm điện tử. Tấm nền của OLED được điều khiển bằng chip driver SSD1306. Về cơ bản, để OLED có thể hiển thị được các thông tin mong muốn thì cần có thư viện hỗ trợ, cũng giống như khi làm việc với LCD. Tùy vào mỗi loại vi điều khiển với kiến trúc phần cứng khác nhau mà sẽ có những thư viện OLED SSD1306 khác nhau hỗ trợ, ví dụ như với các board dùng chip ESP8266 có thể sử dụng thư viện: ESP8266 OLED SSD1306, với board Arduino Uno (dùng chip ATmega328), thư viện OLED hỗ trợ được nhiều người sử dụng là Adafruit SSD1306.

Để sử dụng được hoàn chỉnh tất cả các tính năng thư viện này bao gồm cả những tính năng đồ họa, người dùng cần cài đặt thêm thư viện: Adafruit GFX Library (thư viện hỗ trợ thêm các tính năng đồ họa).

Viết chương trình hiển thị thời gian lên màn hình OLED

Yêu cầu

Chương trình hiển thị thời gian từ lúc nạp chương trình vào board Arduino Uno.

Đấu nối

OLED	Arduino Uno
VCC	5V
GND	GND
SDA	A4
SCL	A5

Source code


#include

#include

#include

#include

#define OLED_RESET 4 #define LOGO16_GLCD_HEIGHT 16 #define LOGO16_GLCD_WIDTH 16 #if (SSD1306_LCDHEIGHT != 32) #error("Height incorrect, please fix Adafruit_SSD1306.h!"); #endif Adafruit_SSD1306 display(OLED_RESET); int time_run = 0; void setup() { Serial.begin(9600); display.begin(SSD1306_SWITCHCAPVCC, 0x3C); display.display(); delay(2000); display.clearDisplay(); display.setTextSize(1); display.setTextColor(WHITE); display.setCursor(0, 0); display.println("Hello, world!"); display.display(); delay(2000); display.clearDisplay(); } void loop() { int hour_run, min_run, sec_run; delay(1000); time_run ++; hour_run = time_run / 3600; min_run = (time_run % 3600) / 60; sec_run = time_run % 60; display.clearDisplay(); display.setCursor(0, 0); display.println(String(hour_run) + ":" + String(min_run) + ":" + String(sec_run)); display.display(); }






Ngoài ra, chúng ta cũng có thể tự tìm hiểu thêm các tính năng đồ họa của OLED với thư viện Adafruit SSD1306 với các chương trình có sẵn trong phần Example của thư viện.

Giao tiếp giữa 2 board Arduino Uno

Có nhiều cách để giao tiếp giữa các vi điều khiển với nhau như truyển nhận qua Serial như đã đề cập ở bài hướng dẫn trước. Phần này, chúng ta sẽ tìm hiểu cách giao tiếp giữa 2 board Arduino Uno thông qua chuẩn giao tiếp I2C.

Yêu cầu*

Board master điều khiển bật tắt LED trên thiết bị slave.

Kết nối

Đầu tiên ta thực hiện việc kết nối giữa 2 board Arduino Uno.

Master	Slave
5V	5V
GND	GND
A4	A4
A5	A5

Ở đây, để thuận tiện ta có thể lấy ngõ ra 5V trên master để cấp nguồn cho slave, người dùng cũng có thể cấp nguồn riêng cho thiết bị slave trong các ứng dụng thực tế tùy theo yêu cầu sử dụng.

Nạp các chương trình cho master và slave.

Source code cho master


// Master #include

void setup() { Serial.begin(9600); // Khởi tạo giao tiếp I2C Wire.begin(); // Khởi tạo truyền nhận dữ liệu I2C } void loop() { // Bắt đầu quá trình truyền dữ liệu trên Serial Monitor while (Serial.available()) { char c = Serial.read(); // Đọc dữ liệu từ serial nếu có và lưu vào biến c if (c == 'H') { Wire.beginTransmission(3); // Bắt đầu truyền đến slave với address la 3 Wire.write('H'); // Truyền chữ H đến slave Wire.endTransmission(); // Kết thúc quá trình truyền } else if (c == 'L') { Wire.beginTransmission(3); Wire.write('L'); Wire.endTransmission(); } } }



Source code cho slave


// Slave #include

#define pinLed 13 // Định nghĩa chân LED void setup() { Wire.begin(3); // Khởi tạo giao tiếp I2C với địa chỉ của slave là 3 Wire.onReceive(receiveEvent); // Đăng kí hàm receiveEvent sẽ được gọi khi nhận được dữ liệu pinMode(pinLed,OUTPUT); digitalWrite(pinLed,LOW); } void loop() { // Không làm gì cả } void receiveEvent() { while(Wire.available()) { char c = Wire.read(); // Lưu dữ liệu nhận được từ master vào biến c nếu có if(c == 'H') // So sánh dữ liệu nhận được và điều khiển LED digitalWrite(pinLed,HIGH); else if(c == 'L') digitalWrite(pinLed,LOW); } }



Giải thích source code

I2C sử dụng việc định địa chỉ 7 bit tương ứng với 128 thiết bị kết nối. Trong Arduino, ta có thể định địa chỉ cho slave bởi hàm

Wire.begin(địa chỉ slave)

, khi đó, slave được khởi tạo một địa chỉ với địa chỉ nằm trong khoảng từ 1 tới 127.Master sẽ truyền dữ liệu tới slave qua câu lệnh

Wire.beginTransmission(địa chỉ slave)

. Master thì không cần truyền địa chỉ.

Kết quả

Sau khi nạp chương trình cho master và slave thành công, ta mở cửa số Serial Monitor ở board Arduino Uno master lên và gõ vào dòng Send kí tự hoặc tương ứng với các lệnh để bật và tắt LED trên board Arduino Uno slave.

Tổng kết

Qua phần này, chúng ta đã tìm hiểu được những khái niệm cơ bản về giao tiếp I2C, các kết nối giữa vi điều và các IC sử dụng giao thức này, hiểu được cách xác định địa chỉ và tìm hiểu một số chương trình cơ bản dùng giao thức này.Bạn đọc có thể tham khảo các ứng dụng mở rộng của giao thức này với các module cảm biến gia tốc, thời gian thực, các module phối hợp chuẩn I2C và SPI,… Tùy vào những ứng dụng cụ thể mà người dùng sẽ phải lựa chọn những IC thích hợp dùng giao tiếp I2C.

Inter-Integrated Circuit (I2C) Protocol

Allows the communication between devices or sensors connected via Two Wire Interface Bus.

What Is I2C?

The I2C protocol involves using two lines to send and receive data: a serial clock pin (SCL) that the Arduino Controller board pulses at a regular interval, and a serial data pin (SDA) over which data is sent between the two devices.

In I2C, there is one controller device, with one or more peripheral devices connected to the controllers SCL and SDA lines.

As the clock line changes from low to high (known as the rising edge of the clock pulse), a single bit of information is transferred from the board to the I2C device over the SDA line. As the clock line keeps pulsing, more and more bits are sent until a sequence of a 7 or 8 bit address, and a command or data is formed. When this information is sent – bit after bit -, the called upon device executes the request and transmits it’s data back – if required – to the board over the same line using the clock signal still generated by the Controller on SCL as timing.

Each device in the I2C bus is functionally independent from the controller, but will respond with information when prompted by the controller.

Because the I2C protocol allows for each enabled device to have it’s own unique address, and as both controller and peripheral devices to take turns communicating over a single line, it is possible for your Arduino board to communicate (in turn) with many devices, or other boards, while using just two pins of your microcontroller.

An I2C message on a lower bit-level looks something like this:

• The controller sends out instructions through the I2C bus on the data pin (SDA), and the instructions are prefaced with the address, so that only the correct device listens.
• Then there is a bit signifying whether the controller wants to read or write.
• Every message needs to be acknowledged, to combat unexpected results, once the receiver has acknowledged the previous information it lets the controller know, so it can move on to the next set of bits.
• 8 bits of data
• Another acknowledgement bit
• 8 bits of data
• Another acknowledgement bit

But how does the controller and peripherals know where the address, messages, and so on starts and ends? That’s what the SCL wire is for. It synchronises the clock of the controller with the devices, ensuring that they all move to the next instruction at the same time.

However, you are nearly never going to actually need to consider any of this, in the Arduino ecosystem we have the Wire library that handles everything for you.

Examples

The remainder of this article is a collection of examples that can get you off the ground with I2C.

Controller Reader

In some situations, it can be helpful to set up two (or more!) Arduino boards to share information with each other. In this example, two boards are programmed to communicate with one another in a Controller Reader/Peripheral Sender configuration via the I2C synchronous serial protocol. Several functions of Arduino’s Wire Library are used to accomplish this. Arduino 1, the Controller, is programmed to request, and then read, 6 bytes of data sent from the uniquely addressed Peripheral Arduino. Once that message is received, it can then be viewed in the Arduino Software (IDE) serial monitor window.

Controller Reader Sketch

1// Wire Controller Reader2// by Nicholas Zambetti [http://www.zambetti.com](http://www.zambetti.com)34// Demonstrates use of the Wire library5// Reads data from an I2C/TWI peripheral device6// Refer to the “Wire Peripheral Sender” example for use with this78// Created 29 March 2006910// This example code is in the public domain.111213#include

1415void setup() {16 Wire.begin(); // join i2c bus (address optional for master)17 Serial.begin(9600); // start serial for output18}1920void loop() {21 Wire.requestFrom(8, 6); // request 6 bytes from peripheral device #82223 while (Wire.available()) { // peripheral may send less than requested24 char c = Wire.read(); // receive a byte as character25 Serial.print(c); // print the character26 }2728 delay(500);29}

Peripheral Sender Sketch

1// Wire Peripheral Sender2// by Nicholas Zambetti [http://www.zambetti.com](http://www.zambetti.com)34// Demonstrates use of the Wire library5// Sends data as an I2C/TWI peripheral device6// Refer to the “Wire Master Reader” example for use with this78// Created 29 March 2006910// This example code is in the public domain.111213#include

1415void setup() {16 Wire.begin(8); // join i2c bus with address #817 Wire.onRequest(requestEvent); // register event18}1920void loop() {21 delay(100);22}2324// function that executes whenever data is requested by master25// this function is registered as an event, see setup()26void requestEvent() {27 Wire.write(“hello “); // respond with message of 6 bytes28 // as expected by master29}

Controller Writer

In some situations, it can be helpful to set up two (or more!) Arduino boards to share information with each other. In this example, two boards are programmed to communicate with one another in a Controller Writer/Peripheral Receiver configuration via the I2C synchronous serial protocol. Several functions of Arduino’s Wire Library are used to accomplish this. Arduino 1, the Controller, is programmed to send 6 bytes of data every half second to a uniquely addressed Peripheral. Once that message is received, it can then be viewed in the Peripheral board’s serial monitor window opened on the USB connected computer running the Arduino Software (IDE).

Controller Writer Sketch

1// Wire Master Writer2// by Nicholas Zambetti [http://www.zambetti.com](http://www.zambetti.com)34// Demonstrates use of the Wire library5// Writes data to an I2C/TWI Peripheral device6// Refer to the “Wire Peripheral Receiver” example for use with this78// Created 29 March 2006910// This example code is in the public domain.111213#include

1415void setup()16{17 Wire.begin(); // join i2c bus (address optional for master)18}1920byte x = 0;2122void loop()23{24 Wire.beginTransmission(4); // transmit to device #425 Wire.write(“x is “); // sends five bytes26 Wire.write(x); // sends one byte27 Wire.endTransmission(); // stop transmitting2829 x++;30 delay(500);31}

Peripheral Receiver Sketch

1// Wire Peripheral Receiver2// by Nicholas Zambetti [http://www.zambetti.com](http://www.zambetti.com)34// Demonstrates use of the Wire library5// Receives data as an I2C/TWI Peripheral device6// Refer to the “Wire Master Writer” example for use with this78// Created 29 March 2006910// This example code is in the public domain.111213#include

1415void setup()16{17 Wire.begin(4); // join i2c bus with address #418 Wire.onReceive(receiveEvent); // register event19 Serial.begin(9600); // start serial for output20}2122void loop()23{24 delay(100);25}2627// function that executes whenever data is received from master28// this function is registered as an event, see setup()29void receiveEvent(int howMany)30{31 while(1 < Wire.available()) // loop through all but the last32 {33 char c = Wire.read(); // receive byte as a character34 Serial.print(c); // print the character35 }36 int x = Wire.read(); // receive byte as an integer37 Serial.println(x); // print the integer38}

Accelerometer

This code lets you read accelerometer data from a Grove 6-Axis Accelerometer module using the seeed arduino LSM6DS3 library.

1#include “LSM6DS3.h”2#include “Wire.h”34//Create instance of Accelerometer class5LSM6DS3 accelerometer(I2C_MODE, 0x6A);67void setup() {8 // put your setup code here, to run once:9 Serial.begin(9600);10 while (!Serial);1112 if (accelerometer.begin() != 0) {13 Serial.println(“LSM6DS3 not found, check your wiring.”);14 } else {15 Serial.println(“LSM6DS3 found!”);16 }17}1819void loop() {20 //Gyroscope21 Serial.print(“\nGyroscope:\n”);22 Serial.print(” X1 = “);23 Serial.println(accelerometer.readFloatGyroX(), 4);24 Serial.print(” Y1 = “);25 Serial.println(accelerometer.readFloatGyroY(), 4);26 Serial.print(” Z1 = “);27 Serial.println(accelerometer.readFloatGyroZ(), 4);2829 //Accelerometer30 Serial.print(“\nAccelerometer:\n”);31 Serial.print(” X1 = “);32 Serial.println(accelerometer.readFloatAccelX(), 4);33 Serial.print(” Y1 = “);34 Serial.println(accelerometer.readFloatAccelY(), 4);35 Serial.print(” Z1 = “);36 Serial.println(accelerometer.readFloatAccelZ(), 4);3738 delay(1000);39}

I2C BMP280

This code example lets you read the temperature over I2C from a BMP280 breakout module from Adafruit:

1#include

2#include

34//Create an instance of the BMP280 sensor5Adafruit_BMP280 bmp;67void setup() {8 Serial.begin(9600);910 // Start the sensor, and verify that it was found11 if (!bmp.begin()) {12 Serial.println(“Sensor not found”);13 while (1){}14 }1516}1718void loop() {19 // Read the values20 float temperature = bmp.readTemperature();2122 // Print to the Serial Monitor23 Serial.print(“Temperature: “);24 Serial.print(temperature);25 Serial.println(” C”);2627 Serial.println();28 delay(2000);29}

I2C OLED

1#include

2#include

3#include

45Adafruit_SSD1306 display(128, 64, &Wire, -1);67// The Arduino Logo in a bitmap format8const uint8_t arduinoLogo[] = {9 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,10 0x00, 0x00, 0x00, 0x00, 0x07, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x30, 0x00, 0x00,11 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xfc, 0x00, 0x70, 0x00, 0x00,12 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x07, 0xff, 0xff, 0x80, 0x50, 0x00, 0x00,13 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xe0, 0x40, 0x00, 0x00,14 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xf0, 0x20, 0x00, 0x00,15 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00,16 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x01, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00,17 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xc0, 0x03, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,18 0x00, 0x00, 0x01, 0xff, 0xfc, 0x0f, 0xff, 0xe0, 0x07, 0xff, 0xf0, 0x3f, 0xff, 0x80, 0x00, 0x00,19 0x00, 0x00, 0x01, 0xff, 0xc0, 0x00, 0xff, 0xf0, 0x0f, 0xff, 0x00, 0x07, 0xff, 0x80, 0x00, 0x00,20 0x00, 0x00, 0x03, 0xff, 0x80, 0x00, 0x7f, 0xf8, 0x1f, 0xfc, 0x00, 0x01, 0xff, 0xc0, 0x00, 0x00,21 0x00, 0x00, 0x07, 0xfe, 0x00, 0x00, 0x1f, 0xfc, 0x3f, 0xf8, 0x00, 0x00, 0x7f, 0xe0, 0x00, 0x00,22 0x00, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x0f, 0xfe, 0x7f, 0xf0, 0x00, 0x00, 0x3f, 0xe0, 0x00, 0x00,23 0x00, 0x00, 0x0f, 0xf8, 0x00, 0x00, 0x07, 0xff, 0x7f, 0xe0, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x00,24 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x03, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00,25 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x01, 0xff, 0xff, 0x80, 0x0f, 0x00, 0x0f, 0xf8, 0x00, 0x00,26 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x0f, 0x80, 0x07, 0xf8, 0x00, 0x00,27 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0x7f, 0xfe, 0x00, 0x0f, 0x80, 0x07, 0xf8, 0x00, 0x00,28 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0x3f, 0xfc, 0x00, 0x0f, 0x80, 0x07, 0xf8, 0x00, 0x00,29 0x00, 0x00, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x3f, 0xfc, 0x00, 0x0f, 0x80, 0x03, 0xf8, 0x00, 0x00,30 0x00, 0x00, 0x1f, 0xc0, 0x1f, 0xff, 0x00, 0x1f, 0xf8, 0x00, 0xff, 0xf8, 0x03, 0xfc, 0x00, 0x00,31 0x00, 0x00, 0x1f, 0xc0, 0x3f, 0xff, 0x00, 0x1f, 0xf8, 0x00, 0xff, 0xf8, 0x03, 0xfc, 0x00, 0x00,32 0x00, 0x00, 0x1f, 0xc0, 0x3f, 0xff, 0x00, 0x1f, 0xf0, 0x00, 0xff, 0xf8, 0x03, 0xfc, 0x00, 0x00,33 0x00, 0x00, 0x1f, 0xc0, 0x1f, 0xff, 0x00, 0x1f, 0xf8, 0x00, 0xff, 0xf8, 0x03, 0xfc, 0x00, 0x00,34 0x00, 0x00, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x3f, 0xfc, 0x00, 0x0f, 0x80, 0x03, 0xf8, 0x00, 0x00,35 0x00, 0x00, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x3f, 0xfc, 0x00, 0x0f, 0x80, 0x07, 0xf8, 0x00, 0x00,36 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0x7f, 0xfe, 0x00, 0x0f, 0x80, 0x07, 0xf8, 0x00, 0x00,37 0x00, 0x00, 0x1f, 0xe0, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x0f, 0x80, 0x07, 0xf8, 0x00, 0x00,38 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x00, 0x01, 0xff, 0xff, 0x80, 0x0f, 0x00, 0x0f, 0xf8, 0x00, 0x00,39 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00, 0x03, 0xff, 0xff, 0x80, 0x00, 0x00, 0x0f, 0xf0, 0x00, 0x00,40 0x00, 0x00, 0x0f, 0xf8, 0x00, 0x00, 0x07, 0xff, 0xff, 0xc0, 0x00, 0x00, 0x1f, 0xf0, 0x00, 0x00,41 0x00, 0x00, 0x07, 0xfc, 0x00, 0x00, 0x0f, 0xfe, 0x7f, 0xf0, 0x00, 0x00, 0x3f, 0xe0, 0x00, 0x00,42 0x00, 0x00, 0x07, 0xfe, 0x00, 0x00, 0x1f, 0xfc, 0x3f, 0xf8, 0x00, 0x00, 0x7f, 0xe0, 0x00, 0x00,43 0x00, 0x00, 0x03, 0xff, 0x00, 0x00, 0x7f, 0xf8, 0x1f, 0xfc, 0x00, 0x00, 0xff, 0xc0, 0x00, 0x00,44 0x00, 0x00, 0x01, 0xff, 0xc0, 0x01, 0xff, 0xf0, 0x0f, 0xff, 0x00, 0x03, 0xff, 0x80, 0x00, 0x00,45 0x00, 0x00, 0x01, 0xff, 0xf8, 0x07, 0xff, 0xf0, 0x07, 0xff, 0xe0, 0x1f, 0xff, 0x80, 0x00, 0x00,46 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x03, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00,47 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xff, 0x80, 0x01, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00,48 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0xff, 0xfc, 0x00, 0x00, 0x00,49 0x00, 0x00, 0x00, 0x0f, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xf0, 0x00, 0x00, 0x00,50 0x00, 0x00, 0x00, 0x07, 0xff, 0xff, 0xf8, 0x00, 0x00, 0x1f, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x00,51 0x00, 0x00, 0x00, 0x01, 0xff, 0xff, 0xe0, 0x00, 0x00, 0x07, 0xff, 0xff, 0x80, 0x00, 0x00, 0x00,52 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0x80, 0x00, 0x00, 0x01, 0xff, 0xfc, 0x00, 0x00, 0x00, 0x00,53 0x00, 0x00, 0x00, 0x00, 0x07, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xc0, 0x00, 0x00, 0x00, 0x00,54 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,55 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,56 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,57 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,58 0x00, 0x00, 0x00, 0x0c, 0x07, 0x80, 0xf0, 0x04, 0x18, 0xff, 0x88, 0x18, 0x1c, 0x00, 0x00, 0x00,59 0x00, 0x00, 0x00, 0x1e, 0x0f, 0xf8, 0xff, 0x1e, 0x1c, 0xff, 0x9e, 0x1c, 0x7f, 0x00, 0x00, 0x00,60 0x00, 0x00, 0x00, 0x1f, 0x0f, 0xfc, 0xff, 0x9e, 0x1c, 0xff, 0x9f, 0x1c, 0xff, 0x80, 0x00, 0x00,61 0x00, 0x00, 0x00, 0x3f, 0x0e, 0x3c, 0xe3, 0xce, 0x1c, 0x1c, 0x1f, 0x1d, 0xe3, 0x80, 0x00, 0x00,62 0x00, 0x00, 0x00, 0x3f, 0x0e, 0x1c, 0xe1, 0xce, 0x1c, 0x1c, 0x1f, 0x99, 0xc3, 0x80, 0x00, 0x00,63 0x00, 0x00, 0x00, 0x33, 0x8e, 0x1c, 0xe1, 0xce, 0x1c, 0x1c, 0x1f, 0x99, 0xc3, 0xc0, 0x00, 0x00,64 0x00, 0x00, 0x00, 0x73, 0x8f, 0x3c, 0xe1, 0xce, 0x1c, 0x1c, 0x1d, 0xd9, 0xc3, 0xc0, 0x00, 0x00,65 0x00, 0x00, 0x00, 0x73, 0x8f, 0xf8, 0xe1, 0xce, 0x1c, 0x1c, 0x1d, 0xf9, 0xc3, 0xc0, 0x00, 0x00,66 0x00, 0x00, 0x00, 0x7f, 0x8f, 0xf0, 0xe1, 0xce, 0x1c, 0x1c, 0x1c, 0xf9, 0xc3, 0x80, 0x00, 0x00,67 0x00, 0x00, 0x00, 0xff, 0xce, 0x70, 0xe3, 0xce, 0x1c, 0x1c, 0x1c, 0xf9, 0xc3, 0x80, 0x00, 0x00,68 0x00, 0x00, 0x00, 0xff, 0xce, 0x78, 0xe7, 0x8e, 0x3c, 0x3c, 0x1c, 0x7d, 0xe7, 0x80, 0x00, 0x00,69 0x00, 0x00, 0x00, 0xe1, 0xce, 0x3c, 0xff, 0x8f, 0xf8, 0xff, 0x9c, 0x7c, 0xff, 0x00, 0x00, 0x00,70 0x00, 0x00, 0x01, 0xe1, 0xee, 0x3c, 0xff, 0x07, 0xf0, 0xff, 0x9c, 0x3c, 0x7e, 0x00, 0x00, 0x00,71 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xc0, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00,72 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,73};7475void setup() {76 Serial.begin(9600);7778 if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {79 Serial.println(F(“SSD1306 not found”));80 while(1){}81 }8283 display.clearDisplay();8485 display.drawBitmap(0, 0, arduinoLogo, 128, 64, SSD1306_WHITE);86 display.display();8788}8990void loop() {91}

Suggested changes

The content on docs.arduino.cc is facilitated through a public GitHub repository. You can read more on how to contribute in the contribution policy.

License

The Arduino documentation is licensed under the Creative Commons Attribution-Share Alike 4.0 license.

• • Tổng tiền thanh toán:

Code test cơ bản

#include void loop()

Code Đếm số 0 đến 9 LCD 16×2 I2C

#include void loop()

Code test cơ bản

#include void loop()

Code Đếm số 0 đến 9 LCD 16×2 I2C

#include void loop()

Tổng quan LCD 16×2 và giao tiếp I2C LCD sử dụng Arduino

Code mẫu

#include

#include LiquidCrystal_I2C lcd(0x3F,16,2); void setup() { lcd.init(); lcd.backlight(); lcd.setCursor(2,0); lcd.print(“Arduinokit.vn”); lcd.setCursor(0,1); lcd.print(“Xin chao cac ban”); } void loop() { }

Giải thích code

LiquidCrystal_I2C lcd(0x3F,16,2);

• Đặt địa chỉ LCD là 0x3F cho màn hình LCD 16×2.
• 16 là số cột của màn hình (nếu dùng loại màn hình 20×4) thì thay bằng 20.
• 2 là số dòng của màn hình (nếu dùng loại màn hình 20×4) thì thay bằng 4.

lcd.init();

Khởi động màn hình LCD, bắt đầu cho phép Arduino sử dụng màn hình.

lcd.backlight();

Bật đèn nền LCD 16×2.

lcd.setCursor(2,0);

Đưa con trỏ tới hàng 1, cột 3.

Lưu ý: giá trị hàng và cột bắt đầu từ số 0 có nghĩa 0 là hàng(cột) 1.

lcd.print(“Arduinokit.vn”);

Xuất ra dòng chữ Arduinokit.vn tại vị trí con trỏ ở hàng 1, cột 3.

lcd.setCursor(0,1); lcd.print(“Xin chao cac ban”);

Đoạn code này thì tương tự như trên, xuất ra dòng chữ “Xin chao cac ban” tại vị trí con trỏ ở hàng 2, cột 1.

Bây giờ thì các bạn upload chương trình và xem kết quả nhé.

Keywords searched by users: arduino uno r3 i2c

Categories: Phổ biến 43 Arduino Uno R3 I2C

See more here: kientrucannam.vn

See more: https://kientrucannam.vn/vn/