🎓 Danh sách khóa học Thầy Lê Chí Tuyền

// Bài 1 – Blink: "Hello world" của vi điều khiển. Nháy LED có sẵn trên board mỗi 500 ms.
// Arduino Uno: LED_BUILTIN là chân 13.  ESP32 DevKit: LED xanh ở GPIO 2 (nếu board có LED).

void setup() {                       // chạy MỘT lần khi cấp điện hoặc nhấn reset
  pinMode(LED_BUILTIN, OUTPUT);      // khai báo chân là ngõ RA
  Serial.begin(115200);              // mở cổng Serial để in thông tin lên máy tính
  Serial.println("Board đã khởi động!");
}

void loop() {                        // lặp lại MÃI MÃI
  digitalWrite(LED_BUILTIN, HIGH);   // xuất mức cao (5 V / 3.3 V) -> LED sáng
  delay(500);                        // chờ 500 ms
  digitalWrite(LED_BUILTIN, LOW);    // xuất mức thấp (0 V) -> LED tắt
  delay(500);
}

// Bài 2 – Đèn giao thông: 3 LED đỏ / vàng / xanh, mỗi LED nối nối tiếp một điện trở 220 Ω xuống GND.
const int DEN_DO = 4;
const int DEN_VANG = 5;
const int DEN_XANH = 6;

// Hàm phụ: bật đúng một đèn, tắt hai đèn còn lại
void batDen(int den) {
  digitalWrite(DEN_DO,   den == DEN_DO   ? HIGH : LOW);
  digitalWrite(DEN_VANG, den == DEN_VANG ? HIGH : LOW);
  digitalWrite(DEN_XANH, den == DEN_XANH ? HIGH : LOW);
}

void setup() {
  pinMode(DEN_DO, OUTPUT);
  pinMode(DEN_VANG, OUTPUT);
  pinMode(DEN_XANH, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  Serial.println("XANH: được đi");
  batDen(DEN_XANH);
  delay(3000);

  Serial.println("VÀNG: chuẩn bị dừng");
  batDen(DEN_VANG);
  delay(1000);

  Serial.println("ĐỎ: dừng lại");
  batDen(DEN_DO);
  delay(3000);
}

// Bài 3 – Nút nhấn: đọc ngõ vào số, điện trở kéo lên trong (INPUT_PULLUP), chống dội phím, bật/tắt LED.
// Nối: một chân nút vào chân 2, chân kia xuống GND.  Không nhấn = HIGH, nhấn = LOW.
const int NUT = 2;
const int LED = 13;
const unsigned long CHONG_DOI_MS = 30;

bool trangThaiLed = false;
int trangThaiOnDinh = HIGH;        // trạng thái nút đã được xác nhận
int lanDocTruoc = HIGH;
unsigned long lanDoiCuoi = 0;
int soLanNhan = 0;

void setup() {
  pinMode(NUT, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  int doc = digitalRead(NUT);
  if (doc != lanDocTruoc) {         // tín hiệu vừa thay đổi (có thể do nảy tiếp điểm)
    lanDoiCuoi = millis();
    lanDocTruoc = doc;
  }
  // Chỉ tin trạng thái mới nếu nó giữ nguyên đủ 30 ms
  if (millis() - lanDoiCuoi > CHONG_DOI_MS && doc != trangThaiOnDinh) {
    trangThaiOnDinh = doc;
    if (trangThaiOnDinh == LOW) {   // cạnh xuống = vừa nhấn
      soLanNhan++;
      trangThaiLed = !trangThaiLed;
      digitalWrite(LED, trangThaiLed);
      Serial.print("Nhấn lần ");
      Serial.println(soLanNhan);
    }
  }
}

// Bài 4 – Ngõ vào analog: quang trở (LDR) làm đèn ngủ tự động, biến trở chỉnh ngưỡng.
// ESP32: ADC 12 bit (0..4095) ở 3.3 V.  Arduino Uno: ADC 10 bit (0..1023) ở 5 V.
const int CHAN_LDR = 34;          // cầu phân áp: 3V3 – LDR – chân 34 – điện trở 10k – GND (tối -> giá trị nhỏ)
const int CHAN_BIEN_TRO = 35;     // chân giữa biến trở
const int DEN = 2;

void setup() {
  pinMode(DEN, OUTPUT);
  Serial.begin(115200);
}

void loop() {
  int anhSang = analogRead(CHAN_LDR);
  int nguong = analogRead(CHAN_BIEN_TRO);
  float dienAp = anhSang * 3.3 / 4095;               // đổi giá trị ADC ra volt
  int phanTram = map(anhSang, 0, 4095, 0, 100);

  Serial.printf("Ánh sáng: %4d (%.2f V, %3d%%)  ngưỡng: %4d -> ", anhSang, dienAp, phanTram, nguong);
  if (anhSang < nguong) {
    digitalWrite(DEN, HIGH);
    Serial.println("TỐI, bật đèn");
  } else {
    digitalWrite(DEN, LOW);
    Serial.println("SÁNG, tắt đèn");
  }
  delay(500);
}

// Bài 5 – PWM: LED "thở" (sáng dần – tối dần).
// Arduino Uno: analogWrite(chân ~PWM, 0..255).   ESP32 (core 3.x): ledcAttach + ledcWrite.
const int LED = 9;

void setup() {
  pinMode(LED, OUTPUT);
}

void loop() {
  for (int doSang = 0; doSang <= 255; doSang += 51) {     // sáng dần
    analogWrite(LED, doSang);
    delay(100);
  }
  for (int doSang = 255; doSang >= 0; doSang -= 51) {     // tối dần
    analogWrite(LED, doSang);
    delay(100);
  }
}

// Bài 5 – Servo theo biến trở và điều tốc động cơ DC bằng PWM trên ESP32 (bộ LEDC)
#include <ESP32Servo.h>      // Arduino Uno dùng <Servo.h> – cách dùng giống hệt

const int CHAN_SERVO = 18;
const int CHAN_BIEN_TRO = 34;
const int CHAN_PWM_DONG_CO = 25;      // nối tới chân ENA của driver L298N / TB6612

Servo servo;

void setup() {
  Serial.begin(115200);
  servo.attach(CHAN_SERVO);
  ledcAttach(CHAN_PWM_DONG_CO, 20000, 8);   // tần số 20 kHz (không kêu rít), độ phân giải 8 bit: 0..255
}

void loop() {
  int bienTro = analogRead(CHAN_BIEN_TRO);          // 0..4095
  int goc = map(bienTro, 0, 4095, 0, 180);
  int tocDo = map(bienTro, 0, 4095, 0, 255);
  servo.write(goc);
  ledcWrite(CHAN_PWM_DONG_CO, tocDo);
  Serial.printf("biến trở %4d -> servo %3d°, động cơ %3d%%\n", bienTro, goc, tocDo * 100 / 255);
  delay(400);
}

// Bài 6 – Giao tiếp Serial: nhận lệnh văn bản từ máy tính / app Bluetooth để điều khiển thiết bị.
// Mở Serial Monitor (115200, kết thúc dòng: Newline) rồi gõ: LED ON, LED OFF, PWM 128, STATUS
const int LED = 2;
const int QUAT = 25;
int tocDoQuat = 0;

void xuLyLenh(String lenh) {
  lenh.trim();
  lenh.toUpperCase();
  if (lenh == "LED ON") {
    digitalWrite(LED, HIGH);
    Serial.println("OK: đèn bật");
  } else if (lenh == "LED OFF") {
    digitalWrite(LED, LOW);
    Serial.println("OK: đèn tắt");
  } else if (lenh.startsWith("PWM ")) {
    tocDoQuat = constrain(lenh.substring(4).toInt(), 0, 255);
    analogWrite(QUAT, tocDoQuat);
    Serial.printf("OK: quạt = %d\n", tocDoQuat);
  } else if (lenh == "STATUS") {
    Serial.printf("Đèn: %s, quạt: %d, chạy được %lu ms\n", digitalRead(LED) ? "bật" : "tắt", tocDoQuat, millis());
  } else {
    Serial.println("Lỗi: không hiểu lệnh \"" + lenh + "\"");
  }
}

void setup() {
  pinMode(LED, OUTPUT);
  Serial.begin(115200);
  Serial.println("Sẵn sàng nhận lệnh: LED ON | LED OFF | PWM <0-255> | STATUS");
}

void loop() {
  if (Serial.available()) {                       // có dữ liệu đang chờ trong bộ đệm
    String lenh = Serial.readStringUntil('\n');   // đọc tới hết dòng
    Serial.print("> ");
    Serial.println(lenh);
    xuLyLenh(lenh);
  }
}

// Bài 7 – Cảm biến nhiệt độ, độ ẩm DHT22: bật quạt khi nóng, cảnh báo khi độ ẩm cao.
// Thư viện: "DHT sensor library" (Adafruit). DHT22 đọc tối đa 1 lần / 2 giây.
#include <DHT.h>

const int CHAN_DHT = 4;
const int QUAT = 26;
DHT dht(CHAN_DHT, DHT22);

void setup() {
  Serial.begin(115200);
  dht.begin();
  pinMode(QUAT, OUTPUT);
}

void loop() {
  float t = dht.readTemperature();
  float h = dht.readHumidity();
  if (isnan(t) || isnan(h)) {                    // luôn kiểm tra: cảm biến lỏng dây sẽ trả về NaN
    Serial.println("Lỗi đọc DHT22!");
  } else {
    Serial.printf("Nhiệt độ: %.1f°C  Độ ẩm: %.1f%%\n", t, h);
    digitalWrite(QUAT, t >= 30 ? HIGH : LOW);
    if (h >= 80) Serial.println("  ! Độ ẩm cao – nguy cơ nấm mốc");
  }
  delay(2000);
}

// Bài 7 – Cảm biến siêu âm HC-SR04: đo khoảng cách, còi kêu nhanh dần khi vật cản tới gần (cảm biến lùi xe).
const int TRIG = 5;
const int ECHO = 18;      // ESP32 3.3 V: dùng HC-SR04P (3.3 V) hoặc cầu phân áp cho chân ECHO
const int COI = 19;

float docKhoangCachCm() {
  digitalWrite(TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH);              // xung kích 10 µs
  delayMicroseconds(10);
  digitalWrite(TRIG, LOW);
  unsigned long thoiGian = pulseIn(ECHO, HIGH, 30000);   // thời gian sóng đi và về (µs)
  if (thoiGian == 0) return -1;          // không nhận được tiếng vọng
  return thoiGian * 0.0343 / 2;          // vận tốc âm thanh 343 m/s = 0.0343 cm/µs, chia 2 vì đi - về
}

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  Serial.begin(115200);
}

void loop() {
  float d = docKhoangCachCm();
  if (d < 0) {
    Serial.println("Ngoài tầm đo");
  } else if (d < 10) {
    Serial.printf("%.1f cm – DỪNG LẠI!\n", d);
    tone(COI, 2000);
  } else if (d < 40) {
    Serial.printf("%.1f cm – gần\n", d);
    tone(COI, 1000, 100);
  } else {
    Serial.printf("%.1f cm – an toàn\n", d);
    noTone(COI);
  }
  delay(300);
}

// Bài 8 – Làm nhiều việc "cùng lúc" bằng millis() (không dùng delay):
//   • LED trạng thái nháy mỗi 250 ms   • đọc cảm biến mỗi 1000 ms   • nút nhấn đổi chế độ phản hồi NGAY
//   • Máy trạng thái (state machine) cho 3 chế độ: TẮT -> TỰ ĐỘNG -> BẬT -> TẮT ...
const int LED_TT = 2, NUT = 0, QUAT = 26, CHAN_NHIET = 34;

enum CheDo { TAT, TU_DONG, BAT };
CheDo cheDo = TU_DONG;
const char* TEN_CHE_DO[] = {"TẮT", "TỰ ĐỘNG", "BẬT"};

unsigned long lanNhay = 0, lanDoc = 0, lanNhan = 0;
bool led = false;
int nutTruoc = HIGH;

void capNhatQuat(float nhietDo) {
  bool bat = (cheDo == BAT) || (cheDo == TU_DONG && nhietDo > 30);
  digitalWrite(QUAT, bat);
}

void setup() {
  pinMode(LED_TT, OUTPUT);
  pinMode(QUAT, OUTPUT);
  pinMode(NUT, INPUT_PULLUP);
  Serial.begin(115200);
}

void loop() {
  unsigned long now = millis();

  // Việc 1: nháy LED trạng thái
  if (now - lanNhay >= 250) {
    lanNhay = now;
    led = !led;
    digitalWrite(LED_TT, led);
  }

  // Việc 2: đọc cảm biến mỗi giây
  if (now - lanDoc >= 1000) {
    lanDoc = now;
    float nhietDo = analogRead(CHAN_NHIET) / 4095.0 * 50;     // giả sử cảm biến 0..50°C
    Serial.printf("[%lu] %.1f°C, chế độ %s\n", now, nhietDo, TEN_CHE_DO[cheDo]);
    capNhatQuat(nhietDo);
  }

  // Việc 3: nút nhấn (có chống dội 50 ms) đổi chế độ
  int nut = digitalRead(NUT);
  if (nut == LOW && nutTruoc == HIGH && now - lanNhan > 50) {
    lanNhan = now;
    cheDo = (CheDo)((cheDo + 1) % 3);
    Serial.printf("[%lu] Nút -> chế độ %s\n", now, TEN_CHE_DO[cheDo]);
  }
  nutTruoc = nut;
}

// Bài 9 – Ngắt ngoài (interrupt): đếm xung encoder bánh xe để tính tốc độ, không bỏ sót xung dù loop() bận.
const int CHAN_ENCODER = 27;
const int XUNG_MOI_VONG = 20;          // đĩa encoder 20 lỗ
const float CHU_VI_BANH_CM = 20.4;     // bánh xe đường kính 6.5 cm

volatile unsigned long demXung = 0;    // volatile: biến dùng chung giữa ISR và loop()

void IRAM_ATTR khiCoXung() {           // ISR: thật ngắn – chỉ đếm
  demXung++;
}

void setup() {
  Serial.begin(115200);
  pinMode(CHAN_ENCODER, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(CHAN_ENCODER), khiCoXung, RISING);
}

void loop() {
  static unsigned long xungTruoc = 0;
  delay(500);                          // loop() làm việc khác 500 ms – ngắt vẫn đếm đủ
  noInterrupts();                      // đọc biến chung an toàn
  unsigned long xung = demXung;
  interrupts();
  unsigned long moi = xung - xungTruoc;
  xungTruoc = xung;
  float vongPhut = moi / (float)XUNG_MOI_VONG / 0.5 * 60;
  float cmGiay = moi / (float)XUNG_MOI_VONG * CHU_VI_BANH_CM / 0.5;
  Serial.printf("%3lu xung/0.5s -> %5.1f vòng/phút, %5.1f cm/s (tổng %lu xung)\n", moi, vongPhut, cmGiay, xung);
}

// Bài 10 – Giao tiếp I2C: quét thiết bị trên bus, hiển thị lên màn hình LCD 16x2 (module I2C PCF8574).
// ESP32: SDA = GPIO 21, SCL = GPIO 22.  Arduino Uno: SDA = A4, SCL = A5.
#include <Wire.h>
#include <LiquidCrystal_I2C.h>
#include <DHT.h>

LiquidCrystal_I2C lcd(0x27, 16, 2);    // địa chỉ 0x27 (có module là 0x3F)
DHT dht(4, DHT22);

void quetI2C() {
  Serial.println("Quét bus I2C...");
  for (uint8_t dc = 1; dc < 127; dc++) {
    Wire.beginTransmission(dc);
    if (Wire.endTransmission() == 0) Serial.printf("  tìm thấy thiết bị tại 0x%02X\n", dc);
  }
}

void setup() {
  Serial.begin(115200);
  Wire.begin(21, 22);
  quetI2C();
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0, 0);
  lcd.print("Tram thoi tiet");
  lcd.setCursor(0, 1);
  lcd.print("BKSTAR v1.0");
  dht.begin();
  delay(1500);
}

void loop() {
  float t = dht.readTemperature();
  float h = dht.readHumidity();
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Nhiet do: ");
  lcd.print(t, 1);
  lcd.print("C");
  lcd.setCursor(0, 1);
  lcd.print("Do am   : ");
  lcd.print(h, 0);
  lcd.print("%");
  delay(2000);
}

// Bài 11 – ESP32 kết nối WiFi và làm WEB SERVER: mở trình duyệt trên điện thoại (cùng WiFi) để bật/tắt đèn, xem nhiệt độ.
#include <WiFi.h>
#include <WebServer.h>

const char* TEN_WIFI = "BKSTAR-Lab";
const char* MAT_KHAU = "12345678";
const int DEN = 2;
const int CHAN_NHIET = 34;

WebServer server(80);

void trangChu() {
  String html = "<h1>Nha thong minh</h1>";
  html += "<p>Den: " + String(digitalRead(DEN) ? "BAT" : "TAT") + "</p>";
  html += "<a href='/den?bat=1'>Bat</a> | <a href='/den?bat=0'>Tat</a>";
  server.send(200, "text/html", html);
}

void dieuKhienDen() {
  if (server.hasArg("bat")) digitalWrite(DEN, server.arg("bat") == "1" ? HIGH : LOW);
  server.send(200, "text/plain", digitalRead(DEN) ? "Den da BAT" : "Den da TAT");
}

void docNhietDo() {                     // trả về JSON cho app / trang web đọc
  float t = analogRead(CHAN_NHIET) / 4095.0 * 50;
  server.send(200, "application/json", "{\"nhiet_do\":" + String(t, 1) + "}");
}

void setup() {
  Serial.begin(115200);
  pinMode(DEN, OUTPUT);
  WiFi.mode(WIFI_STA);
  WiFi.begin(TEN_WIFI, MAT_KHAU);
  Serial.print("Đang kết nối WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("Đã kết nối! Mở trình duyệt: http://");
  Serial.println(WiFi.localIP());

  server.on("/", trangChu);
  server.on("/den", dieuKhienDen);
  server.on("/nhiet-do", docNhietDo);
  server.onNotFound([] { server.send(404, "text/plain", "Khong co trang nay"); });
  server.begin();
}

void loop() {
  server.handleClient();               // phải gọi liên tục để phục vụ trình duyệt
}

// Bài 12 – DỰ ÁN: Nhà thông minh IoT với ESP32 + MQTT
//   • Gửi nhiệt độ, độ ẩm, ánh sáng lên broker MQTT mỗi 2 giây (app điện thoại / Node-RED / Home Assistant hiển thị)
//   • Nhận lệnh bật/tắt đèn, quạt từ app qua topic nha/dieu-khien
//   • Tự động: tối thì bật đèn hiên, nóng quá thì bật quạt (khi đang ở chế độ tự động)
#include <WiFi.h>
#include <PubSubClient.h>
#include <DHT.h>

const int DEN_HIEN = 2, QUAT = 26, CHAN_LDR = 34;
DHT dht(4, DHT22);
WiFiClient wifiClient;
PubSubClient mqtt(wifiClient);
bool tuDong = true;
unsigned long lanGui = 0;

void khiNhanTin(char* topic, byte* duLieu, unsigned int len) {
  String lenh = "";
  for (unsigned int i = 0; i < len; i++) lenh += (char)duLieu[i];
  if (lenh == "den:bat") digitalWrite(DEN_HIEN, HIGH);
  else if (lenh == "den:tat") digitalWrite(DEN_HIEN, LOW);
  else if (lenh == "quat:bat") digitalWrite(QUAT, HIGH);
  else if (lenh == "quat:tat") digitalWrite(QUAT, LOW);
  else if (lenh == "che-do:tu-dong") tuDong = true;
  else if (lenh == "che-do:thu-cong") tuDong = false;
  Serial.printf("Lệnh \"%s\" -> chế độ %s\n", lenh.c_str(), tuDong ? "tự động" : "thủ công");
  (void)topic;
}

void ketNoi() {
  WiFi.begin("BKSTAR-Lab", "12345678");
  while (WiFi.status() != WL_CONNECTED) delay(250);
  Serial.println("WiFi OK, IP " + WiFi.localIP());
  mqtt.setServer("broker.hivemq.com", 1883);
  mqtt.setCallback(khiNhanTin);
  mqtt.connect("bkstar-nha-01");
  mqtt.subscribe("nha/dieu-khien");
}

void setup() {
  Serial.begin(115200);
  pinMode(DEN_HIEN, OUTPUT);
  pinMode(QUAT, OUTPUT);
  dht.begin();
  ketNoi();
}

void loop() {
  mqtt.loop();                                   // nhận tin MQTT
  if (millis() - lanGui >= 2000) {
    lanGui = millis();
    float t = dht.readTemperature(), h = dht.readHumidity();
    int anhSang = analogRead(CHAN_LDR);
    char json[96];
    snprintf(json, sizeof json, "{\"t\":%.1f,\"h\":%.0f,\"anh_sang\":%d}", t, h, anhSang);
    mqtt.publish("nha/cam-bien", json);
    if (tuDong) {
      digitalWrite(DEN_HIEN, anhSang < 1200);
      digitalWrite(QUAT, t > 31);
    }
  }
}