Komponen · 9 mnt baca

Modul Kompas Arduino: Panduan QMC5883L dan HMC5883L (GY-271)

GY-271 milikmu QMC5883L atau HMC5883L? Alamat I2C (0x0D, 0x1E), arah dengan atan2, deklinasi, kalibrasi, dan kompas OLED, lengkap dengan kode Uno, ESP32, dan Pico.

Modul kompas Arduino adalah sensor medan magnet kecil yang memberi tahu board-mu di mana arah utara. Model yang paling umum, GY-271, mengukur medan magnet Bumi pada tiga sumbu. Dari situ kamu bisa menghitung arah (0–360 derajat) untuk mengarahkan mobil robotmu ke arah tertentu, menampilkan kompas digital di layar OLED, atau menambahkan data arah ke proyek GPS-mu. Modul ini terhubung hanya dengan empat kabel lewat I2C dan bekerja dengan cara yang sama di Arduino Uno, ESP32, dan Raspberry Pi Pico.

Tapi modul ini menyimpan kejutan: sebagian besar board yang dijual sebagai GY-271 sudah tidak memakai chip HMC5883L buatan Honeywell, melainkan QMC5883L buatan QST. Dari luar kedua chip ini nyaris sama, tetapi alamat I2C dan register-nya berbeda. Itulah sebabnya banyak sketch siap pakai melaporkan “sensor tidak ditemukan”. Di artikel ini kamu akan belajar mengetahui chip apa yang ada di board-mu, menghitung arah dengan benar, menambahkan deklinasi magnetik, dan menurunkan galat sampai tinggal beberapa derajat dengan kalibrasi.

Apa itu modul kompas digital dan bagaimana cara kerjanya?

Inti modul ini adalah magnetometer, yaitu sensor yang mengukur medan magnet. Medan magnet Bumi cukup lemah: di Turki kekuatan totalnya sekitar 45–50 mikrotesla (0,45–0,5 gauss), dan komponen horizontal yang sejajar tanah sekitar 25 µT (1 gauss = 100 µT). Chip ini memakai sensor magnetoresistif untuk mengukur komponen X, Y, dan Z dari medan tersebut, lalu memberikan masing-masing sebagai bilangan bulat bertanda. Selama modul dalam posisi datar, X dan Y sudah cukup untuk mencari arah; sudutnya kamu dapatkan dengan fungsi atan2. Sumbu Z berguna untuk hal lanjutan seperti kompensasi kemiringan dan deteksi logam.

FiturQMC5883LHMC5883L
ProdusenQSTHoneywell (sudah tidak diproduksi)
Alamat I2C0x0D0x1E
Rentang pengukuran±2 G atau ±8 G±0,88 G sampai ±8,1 G (8 tingkat)
Resolusi16-bit (12.000 LSB/G pada ±2 G, 3000 LSB/G pada ±8 G)12-bit (1090 LSB/G pada ±1,3 G)
Laju data10, 50, 100, 200 Hz0,75–75 Hz (mode kontinu)
Catu daya chip2,16–3,6 V2,16–3,6 V
Catu daya board GY-2713–5 V (ada regulator di board)3–5 V (ada regulator di board)
Pembacaan suhuAda (nilai relatif)Tidak ada

QMC5883L atau HMC5883L? Cara membedakan kedua chip

Selama bertahun-tahun HMC5883L menjadi chip kompas standar di dunia elektronika hobi. Ketika Honeywell menghentikan produksinya, QMC5883L buatan QST mengisi pasar. Karena penjual sering tidak mengganti nama produk, menemukan QMC5883L di board yang kamu beli sebagai “HMC5883L” itu hal yang sangat wajar. Cara paling pasti untuk membedakannya adalah scan I2C: kalau alamat 0x0D muncul di bus, itu QMC5883L; kalau 0x1E yang muncul, itu HMC5883L. Membaca tulisan di chip dengan kaca pembesar juga membantu. Belakangan ini beberapa board memakai QMC5883P dengan alamat 0x2C; peta register-nya berbeda, jadi kode di artikel ini tidak akan langsung jalan dengan chip itu.

MetodeQMC5883LHMC5883L
Alamat I2C0x0D0x1E
Tulisan di chipDA 5883L883
Register IDRegister 0x0D mengembalikan 0xFFRegister 0x0A–0x0C mengembalikan 'H', '4', '3'
Register data0x00–0x05 (urutan X, Y, Z)0x03–0x08 (urutan X, Z, Y)
Urutan byteByte rendah dulu (LSB)Byte tinggi dulu (MSB)
Mode ketika dinyalakanStandby, tidak mengukurMode pengukuran tunggal
Library yang umumQMC5883LCompassAdafruit HMC5883 Unified
Library HMC seperti Adafruit HMC5883 Unified hanya mencari alamat 0x1E. Kalau board-mu memakai QMC5883L, kamu akan mendapat pesan seperti “no HMC5883 detected” dan mengira modulnya rusak. Padahal tidak; chip-nya saja yang berbeda. Jalankan scan I2C dulu, lalu pakai kode yang berbicara ke alamat yang benar.

Pengkabelan GY-271: Uno, ESP32, dan Pico

Pin GY-271Arduino UnoESP32Raspberry Pi Pico
VCC5V (atau 3.3V)3V33V3 (pin 36)
GNDGNDGNDGND
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)
DRDYTidak dihubungkanTidak dihubungkanTidak dihubungkan

Board GY-271 punya regulator 3,3 V dan resistor pull-up untuk jalur I2C, jadi aman memberi daya modul dari pin 5V di Uno. Di ESP32 dan Pico, beri daya board dari pin 3V3 supaya SDA dan SCL tetap di 3,3 V. Pin DRDY (data ready) memberi sinyal setiap ada pengukuran baru; kamu bisa membiarkannya tidak terhubung kalau tidak membaca lewat interrupt. Kompas ini bisa berbagi bus yang sama dengan perangkat I2C lain seperti layar OLED (0x3C) atau MPU-6050 (0x68), karena alamatnya tidak bentrok. Untuk detail soal alamat dan pull-up, lihat Apa Itu I2C?.

Langkah demi langkah: pembacaan arah pertamamu (Arduino Uno)

  1. Pasang modul di breadboard, dan kalau bisa jauhkan setidaknya 15–20 cm dari motor, speaker, magnet, dan benda baja besar.
  2. Hubungkan kabel VCC, GND, SCL, dan SDA seperti di tabel, dan biarkan pin DRDY tidak terhubung.
  3. Upload kode di bawah; tidak perlu library tambahan, cukup library Wire bawaan Arduino.
  4. Buka Serial Monitor di 9600 baud; baris pertama menunjukkan chip apa yang ditemukan oleh kode.
  5. Letakkan modul datar di meja lalu putar pelan-pelan; perhatikan nilai X dan Y berayun antara positif dan negatif, dan sudutnya bergerak dari 0 sampai 360.
  6. Kalau kompas di ponselmu diatur untuk menunjukkan utara sejati, arahkan panah X di modul ke utara itu; sudutnya seharusnya mendekati 0. Galat 10–30 derajat sebelum kalibrasi itu normal.
C++ (Arduino IDE)
1#include <Wire.h>
2#include <math.h>
3
4const uint8_t QMC_ADDR = 0x0D;   // QMC5883L adresi / QMC5883L address
5const uint8_t HMC_ADDR = 0x1E;   // HMC5883L adresi / HMC5883L address
6const float DECLINATION = 6.0;   // manyetik sapma, doğu + / magnetic declination, east +
7
8uint8_t chipAddr = 0;
9
10bool devicePresent(uint8_t addr) {
11  Wire.beginTransmission(addr);
12  return Wire.endTransmission() == 0;   // 0 = cihaz cevap verdi / 0 = device acknowledged
13}
14
15void writeReg(uint8_t addr, uint8_t reg, uint8_t val) {
16  Wire.beginTransmission(addr);
17  Wire.write(reg);
18  Wire.write(val);
19  Wire.endTransmission();
20}
21
22bool readAxes(int16_t &x, int16_t &y, int16_t &z) {
23  uint8_t startReg = (chipAddr == QMC_ADDR) ? 0x00 : 0x03;
24  Wire.beginTransmission(chipAddr);
25  Wire.write(startReg);
26  if (Wire.endTransmission() != 0) return false;
27  if (Wire.requestFrom(chipAddr, (uint8_t)6) != 6) return false;
28  uint8_t b[6];
29  for (uint8_t i = 0; i < 6; i++) b[i] = Wire.read();
30  if (chipAddr == QMC_ADDR) {          // X, Y, Z; önce düşük bayt / LSB first
31    x = (int16_t)((uint16_t)b[1] << 8 | b[0]);
32    y = (int16_t)((uint16_t)b[3] << 8 | b[2]);
33    z = (int16_t)((uint16_t)b[5] << 8 | b[4]);
34  } else {                             // X, Z, Y; önce yüksek bayt / MSB first
35    x = (int16_t)((uint16_t)b[0] << 8 | b[1]);
36    z = (int16_t)((uint16_t)b[2] << 8 | b[3]);
37    y = (int16_t)((uint16_t)b[4] << 8 | b[5]);
38  }
39  return true;
40}
41
42const char* directionName(float h) {
43  static const char* const names[] = {"K", "KD", "D", "GD", "G", "GB", "B", "KB"};
44  return names[(int)((h + 22.5) / 45.0) % 8];   // 45 derecelik dilimler / 45 degree sectors
45}
46
47void setup() {
48  Serial.begin(9600);
49  Wire.begin();
50  if (devicePresent(QMC_ADDR)) {
51    chipAddr = QMC_ADDR;
52    writeReg(QMC_ADDR, 0x0B, 0x01);   // SET/RESET periyodu / SET/RESET period
53    writeReg(QMC_ADDR, 0x09, 0x1D);   // sürekli, 200 Hz, ±8 G, OSR 512 / continuous, 200 Hz, ±8 G, OSR 512
54    Serial.println(F("QMC5883L bulundu (0x0D)"));
55  } else if (devicePresent(HMC_ADDR)) {
56    chipAddr = HMC_ADDR;
57    writeReg(HMC_ADDR, 0x00, 0x70);   // 8 örnek ortalama, 15 Hz / 8-sample average, 15 Hz
58    writeReg(HMC_ADDR, 0x01, 0x20);   // ±1,3 Ga kazanç / ±1.3 Ga gain
59    writeReg(HMC_ADDR, 0x02, 0x00);   // sürekli ölçüm / continuous measurement
60    Serial.println(F("HMC5883L bulundu (0x1E)"));
61  } else {
62    Serial.println(F("Pusula bulunamadi / Compass not found"));
63    while (true) {}
64  }
65}
66
67void loop() {
68  int16_t x, y, z;
69  if (readAxes(x, y, z)) {
70    float heading = atan2((float)y, (float)x) * 180.0 / PI;   // radyandan dereceye / radians to degrees
71    heading += DECLINATION;
72    if (heading < 0) heading += 360.0;
73    if (heading >= 360.0) heading -= 360.0;
74    Serial.print(F("X: ")); Serial.print(x);
75    Serial.print(F("  Y: ")); Serial.print(y);
76    Serial.print(F("  Z: ")); Serial.print(z);
77    Serial.print(F("  Yon: ")); Serial.print(heading, 1);
78    Serial.print(F(" derece "));
79    Serial.println(directionName(heading));
80  }
81  delay(250);
82}
Kode / registerNilaiArti
QMC 0x0B0x01Periode SET/RESET; nilai yang direkomendasikan datasheet
QMC 0x090x1DOSR 512, rentang ±8 G, 200 Hz, pengukuran kontinu (0x0D untuk ±2 G)
HMC 0x000x70Rata-rata 8 pengukuran, laju data 15 Hz
HMC 0x010x20Rentang ±1,3 Ga, sensitivitas 1090 LSB/Ga
HMC 0x020x00Mode pengukuran kontinu
Wire.endTransmission() == 0-Kalau alamat menjawab, berarti perangkat ada di bus
atan2(y, x) × 180 / π-Sudut dari −180 sampai +180 derajat dari sumbu mentah

Bagaimana arah dihitung?

Selama modul dalam posisi datar, medan magnet horizontal Bumi terbagi antara sumbu X dan Y. Ketika kamu mengarahkan panah X ke utara, seluruh medan jatuh ke X dan Y mendekati nol; begitu modul diputar, porsinya bergeser ke Y. Arah dihitung dengan θ = atan2(Y, X). Kita memakai atan2, bukan atan(Y/X) biasa, karena atan2 melihat tanda kedua nilai untuk membedakan keempat kuadran dan tidak membagi dengan nol ketika X bernilai nol. Hasilnya keluar dalam radian antara −180 dan +180 derajat; kamu mengalikannya dengan 180/π untuk mengubahnya ke derajat, lalu menambahkan 360 kalau hasilnya negatif. Masing-masing dari delapan arah utama mencakup sektor 45 derajat: 337,5 sampai 22,5 derajat adalah Utara (N), 22,5 sampai 67,5 adalah Timur Laut (NE), dan seterusnya; operasi (sudut + 22,5) / 45 di kode memilih sektor yang tepat. Kalau sudutnya malah berkurang ketika modul diputar searah jarum jam, tata letak sumbu di board-mu berbeda; balik tanda Y dan pakai atan2(-y, x) untuk memperbaikinya.

Apa itu deklinasi magnetik?

Jarum kompas menunjuk ke utara magnetik, bukan utara geografis (sejati). Sudut di antara keduanya disebut deklinasi magnetik, dan nilainya berubah tergantung lokasi dan tahun. Di Turki deklinasinya ke arah timur dan sekarang sekitar +5 derajat di provinsi bagian barat dan sekitar +7 derajat di bagian timur; 6 derajat adalah titik awal yang bagus untuk Istanbul dan Ankara. Rumus koreksinya sederhana: arah sejati = arah magnetik + deklinasi, dengan timur ditulis positif dan barat negatif. Cukup cari nilai terkini untuk lokasimu di kalkulator model magnetik milik NOAA atau lembaga serupa, lalu tulis di konstanta DECLINATION di kode. Kalau nilainya kamu dapat dalam derajat dan menit, ubah ke desimal: 5° 48' = 5 + 48/60 = 5,8 derajat. Deklinasi bergeser beberapa menit busur per tahun, jadi sebaiknya dicek setiap beberapa tahun.

Kalibrasi kompas: hard iron dan soft iron

Kompas yang belum dikalibrasi bisa meleset 20–40 derajat, terutama di percobaan pertama. Ada dua penyebabnya. Pada efek hard iron, magnet permanen di dekat modul, sekrup yang termagnetisasi, atau komponen di board menambahkan nilai konstan ke setiap pembacaan; kalau kamu memplot nilai X–Y sambil memutar modul, kamu akan melihat pusat lingkarannya bergeser dari nol. Pada efek soft iron, material di sekitar seperti besi dan nikel membelokkan medan dan mengubah lingkaran menjadi elips. Solusinya sederhana: pegang modul datar di posisi akhirnya di proyekmu, putar pelan-pelan dua atau tiga putaran, lalu catat nilai minimum dan maksimum tiap sumbu. Offset = (maks + min) / 2 memberi koreksi hard iron, dan skala = jari-jari rata-rata / jari-jari sumbu memberi koreksi soft iron sederhana. Kode di bawah ini untuk QMC5883L yang ada di kebanyakan board; kalau kamu memakai HMC5883L, cukup ganti fungsi pembacaannya dengan bagian HMC di sketch pertama.

C++ (Arduino IDE)
1#include <Wire.h>
2
3const uint8_t QMC_ADDR = 0x0D;
4int16_t minX = 32767, maxX = -32768;
5int16_t minY = 32767, maxY = -32768;
6unsigned long samples = 0;
7unsigned long lastPrint = 0;
8
9void qmcInit() {
10  Wire.beginTransmission(QMC_ADDR);
11  Wire.write(0x0B); Wire.write(0x01);    // SET/RESET periyodu / SET/RESET period
12  Wire.endTransmission();
13  Wire.beginTransmission(QMC_ADDR);
14  Wire.write(0x09); Wire.write(0x1D);    // sürekli, 200 Hz, ±8 G / continuous, 200 Hz, ±8 G
15  Wire.endTransmission();
16}
17
18bool qmcRead(int16_t &x, int16_t &y, int16_t &z) {
19  Wire.beginTransmission(QMC_ADDR);
20  Wire.write(0x00);
21  if (Wire.endTransmission() != 0) return false;
22  if (Wire.requestFrom(QMC_ADDR, (uint8_t)6) != 6) return false;
23  uint8_t b[6];
24  for (uint8_t i = 0; i < 6; i++) b[i] = Wire.read();
25  x = (int16_t)((uint16_t)b[1] << 8 | b[0]);
26  y = (int16_t)((uint16_t)b[3] << 8 | b[2]);
27  z = (int16_t)((uint16_t)b[5] << 8 | b[4]);
28  return true;
29}
30
31void setup() {
32  Serial.begin(9600);
33  Wire.begin();
34  qmcInit();
35  Serial.println(F("Modulu duz tutup yavasca 2-3 tur cevir / Rotate it flat, slowly, 2-3 turns"));
36}
37
38void loop() {
39  int16_t x, y, z;
40  if (qmcRead(x, y, z)) {
41    if (x < minX) minX = x;
42    if (x > maxX) maxX = x;
43    if (y < minY) minY = y;
44    if (y > maxY) maxY = y;
45    samples++;
46  }
47  if (samples > 50 && millis() - lastPrint > 1000) {
48    lastPrint = millis();
49    float offX = ((long)maxX + minX) / 2.0;   // hard iron ofseti / hard iron offset
50    float offY = ((long)maxY + minY) / 2.0;
51    float dX = ((long)maxX - minX) / 2.0;     // eksen yarıçapı / axis radius
52    float dY = ((long)maxY - minY) / 2.0;
53    float avg = (dX + dY) / 2.0;              // ortalama yarıçap / average radius
54    Serial.print(F("OFF_X=")); Serial.print(offX, 1);
55    Serial.print(F("  OFF_Y=")); Serial.print(offY, 1);
56    if (dX > 0 && dY > 0) {
57      Serial.print(F("  SCALE_X=")); Serial.print(avg / dX, 3);
58      Serial.print(F("  SCALE_Y=")); Serial.print(avg / dY, 3);
59    }
60    Serial.println();
61  }
62  delay(20);
63}

Kode ini mencetak nilai OFF dan SCALE setiap detik; terus putar sampai angkanya berhenti berubah. Misalnya, kalau kamu mengukur minimum −680 dan maksimum 920 untuk X, offset-nya (920 + (−680)) / 2 = 120 dan jari-jarinya 800. Kalau Y punya minimum −1010 dan maksimum 550, offset-nya −230 dan jari-jarinya 780. Karena jari-jari rata-ratanya 790, skalanya menjadi 790 / 800 ≈ 0,988 dan 790 / 780 ≈ 1,013. Di kode utama, kamu mengoreksi setiap pembacaan mentah sebagai x = (raw_x − OFF_X) × SCALE_X; di contoh ESP32 di bawah, nilai-nilai ini sudah diisi. Karena 1 gauss setara dengan 3000 hitungan di rentang ±8 G, jari-jari 800 berarti medan horizontal sekitar 0,27 G, sesuai dengan yang diharapkan untuk Turki. Kalau kamu memindahkan modul ke tempat lain atau menambahkan komponen logam baru di dekatnya, ulangi kalibrasinya.

Kompas di layar OLED dengan ESP32

Layar OLED I2C 0,96 inci
Layar OLED I2C 0,96 inci (0x3C) berbagi bus I2C yang sama dengan modul kompas (0x0D) tanpa masalah.

Kode Wire yang sama jalan di ESP32; pin I2C-nya GPIO 21 (SDA) dan GPIO 22 (SCL), dan kompas serta layar OLED 0,96 inci terhubung ke bus yang sama. Kode ini menerapkan nilai kalibrasi, menghaluskan X dan Y dengan filter low-pass sederhana, lalu menampilkan jarum kompas yang berputar di sisi kiri layar serta derajat dan huruf arah di sisi kanan. Filter diterapkan ke sumbu, bukan ke sudut, supaya rata-rata sudut di peralihan 359 ke 0 derajat tidak keliru menjadi sekitar 180. Garis pendek di bagian atas layar menandai bagian depan perangkat dan jarumnya menunjuk ke utara; ketika kamu memutar perangkat, jarumnya berputar ke arah sebaliknya, persis seperti kompas sungguhan. Untuk instalasi library layar, lihat layar OLED (SSD1306).

C++ (Arduino IDE)
1#include <Wire.h>
2#include <Adafruit_GFX.h>
3#include <Adafruit_SSD1306.h>
4#include <math.h>
5
6Adafruit_SSD1306 display(128, 64, &Wire, -1);
7
8const uint8_t QMC_ADDR = 0x0D;
9const float DECLINATION = 6.0;                  // şehrine göre değiştir / change for your city
10const float OFF_X = 120.0, OFF_Y = -230.0;      // kalibrasyon kodundan / from calibration sketch
11const float SCALE_X = 0.988, SCALE_Y = 1.013;
12
13float fx = 0, fy = 0;                           // filtrelenmiş eksenler / filtered axes
14bool firstRead = true;
15
16void qmcInit() {
17  Wire.beginTransmission(QMC_ADDR);
18  Wire.write(0x0B); Wire.write(0x01);           // SET/RESET periyodu / SET/RESET period
19  Wire.endTransmission();
20  Wire.beginTransmission(QMC_ADDR);
21  Wire.write(0x09); Wire.write(0x1D);           // sürekli, 200 Hz, ±8 G / continuous, 200 Hz, ±8 G
22  Wire.endTransmission();
23}
24
25bool qmcRead(int16_t &x, int16_t &y, int16_t &z) {
26  Wire.beginTransmission(QMC_ADDR);
27  Wire.write(0x00);
28  if (Wire.endTransmission() != 0) return false;
29  if (Wire.requestFrom(QMC_ADDR, (uint8_t)6) != 6) return false;
30  uint8_t b[6];
31  for (uint8_t i = 0; i < 6; i++) b[i] = Wire.read();
32  x = (int16_t)((uint16_t)b[1] << 8 | b[0]);
33  y = (int16_t)((uint16_t)b[3] << 8 | b[2]);
34  z = (int16_t)((uint16_t)b[5] << 8 | b[4]);
35  return true;
36}
37
38const char* directionName(float h) {
39  static const char* const names[] = {"K", "KD", "D", "GD", "G", "GB", "B", "KB"};
40  return names[(int)((h + 22.5f) / 45.0f) % 8];
41}
42
43void setup() {
44  Serial.begin(115200);
45  Wire.begin(21, 22);                           // SDA = GPIO 21, SCL = GPIO 22
46  qmcInit();
47  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
48    Serial.println(F("OLED bulunamadi / OLED not found"));
49    for (;;) delay(1000);
50  }
51  display.setTextColor(SSD1306_WHITE);
52}
53
54void loop() {
55  int16_t rx, ry, rz;
56  if (!qmcRead(rx, ry, rz)) { delay(100); return; }
57
58  float x = (rx - OFF_X) * SCALE_X;             // kalibrasyonu uygula / apply calibration
59  float y = (ry - OFF_Y) * SCALE_Y;
60  if (firstRead) { fx = x; fy = y; firstRead = false; }
61  fx = 0.8f * fx + 0.2f * x;                    // basit alçak geçiren filtre / simple low-pass filter
62  fy = 0.8f * fy + 0.2f * y;
63
64  float heading = atan2f(fy, fx) * 180.0f / PI + DECLINATION;
65  if (heading < 0) heading += 360.0f;
66  if (heading >= 360.0f) heading -= 360.0f;
67
68  display.clearDisplay();
69  const int cx = 32, cy = 32, r = 30;
70  display.drawCircle(cx, cy, r, SSD1306_WHITE);
71  display.drawFastVLine(cx, 0, 4, SSD1306_WHITE);   // cihazın ön yönü / device forward mark
72
73  float a = heading * PI / 180.0f;
74  int nx = cx - (int)(24 * sinf(a));            // kuzeyi gösteren uç / tip pointing north
75  int ny = cy - (int)(24 * cosf(a));
76  int sx = cx + (int)(12 * sinf(a));            // güney ucu / south tail
77  int sy = cy + (int)(12 * cosf(a));
78  display.drawLine(sx, sy, nx, ny, SSD1306_WHITE);
79  display.fillCircle(nx, ny, 3, SSD1306_WHITE);
80  display.fillCircle(cx, cy, 2, SSD1306_WHITE);
81
82  display.setTextSize(2);
83  display.setCursor(72, 10);
84  display.print((int)(heading + 0.5f) % 360);
85  display.drawCircle(display.getCursorX() + 3, 12, 2, SSD1306_WHITE);   // derece işareti / degree sign
86  display.setCursor(72, 38);
87  display.print(directionName(heading));
88  display.display();
89  delay(100);
90}

Kompas MicroPython dengan Raspberry Pi Pico

Di Pico, class machine.I2C dari MicroPython sudah cukup; tidak perlu file driver terpisah. Kode ini pertama-tama menampilkan daftar alamat di bus dengan i2c.scan(), menulis pengaturan untuk chip yang ditemukan, lalu membaca enam byte sekaligus dengan readfrom_mem. Karena byte di MicroPython datang tanpa tanda, kamu perlu mengurangi 65536 dari nilai di atas 32767 agar menjadi bilangan negatif. Untuk kalibrasi, cukup masukkan nilai OFF dan SCALE yang kamu dapat di Arduino ke konstanta di kode. Kalau kamu baru mengenal MicroPython, dasar-dasar MicroPython dan Apa Itu Raspberry Pi Pico? adalah tempat yang bagus untuk memulai.

MicroPython
1from machine import Pin, I2C
2import math
3import time
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)
6QMC = 0x0D
7HMC = 0x1E
8DECLINATION = 6.0                  # manyetik sapma, doğu + / magnetic declination, east +
9OFF_X, OFF_Y = 0.0, 0.0            # kalibrasyon ofsetleri / calibration offsets
10SCALE_X, SCALE_Y = 1.0, 1.0        # kalibrasyon ölçekleri / calibration scales
11
12found = i2c.scan()
13print("I2C:", [hex(a) for a in found])
14
15if QMC in found:
16    addr = QMC
17    i2c.writeto_mem(QMC, 0x0B, bytes([0x01]))   # SET/RESET periyodu / SET/RESET period
18    i2c.writeto_mem(QMC, 0x09, bytes([0x1D]))   # sürekli, 200 Hz, ±8 G / continuous, 200 Hz, ±8 G
19elif HMC in found:
20    addr = HMC
21    i2c.writeto_mem(HMC, 0x00, bytes([0x70]))   # 8 ortalama, 15 Hz / 8 samples, 15 Hz
22    i2c.writeto_mem(HMC, 0x01, bytes([0x20]))   # ±1,3 Ga kazanç / ±1.3 Ga gain
23    i2c.writeto_mem(HMC, 0x02, bytes([0x00]))   # sürekli mod / continuous mode
24else:
25    raise OSError("Pusula bulunamadi / Compass not found")
26
27def to_int16(v):
28    return v - 65536 if v > 32767 else v
29
30def read_xyz():
31    if addr == QMC:
32        b = i2c.readfrom_mem(QMC, 0x00, 6)      # X, Y, Z; önce düşük bayt / LSB first
33        x = to_int16(b[1] << 8 | b[0])
34        y = to_int16(b[3] << 8 | b[2])
35        z = to_int16(b[5] << 8 | b[4])
36    else:
37        b = i2c.readfrom_mem(HMC, 0x03, 6)      # X, Z, Y; önce yüksek bayt / MSB first
38        x = to_int16(b[0] << 8 | b[1])
39        z = to_int16(b[2] << 8 | b[3])
40        y = to_int16(b[4] << 8 | b[5])
41    return x, y, z
42
43NAMES = ("K", "KD", "D", "GD", "G", "GB", "B", "KB")
44
45while True:
46    x, y, z = read_xyz()
47    x = (x - OFF_X) * SCALE_X
48    y = (y - OFF_Y) * SCALE_Y
49    heading = (math.degrees(math.atan2(y, x)) + DECLINATION) % 360
50    name = NAMES[int((heading + 22.5) // 45) % 8]
51    print("Yon: {:.1f} derece {}".format(heading, name))
52    time.sleep(0.2)

Kompensasi kemiringan: kenapa modul harus tetap datar?

Arah yang dihitung hanya dari sumbu X dan Y hanya benar selama modul sejajar dengan tanah. Di lintang menengah seperti Turki, medan magnet masuk ke tanah dengan sudut inklinasi sekitar 55–60 derajat, sehingga komponen vertikal (Z) jelas lebih besar daripada komponen horizontal. Ketika modul miring 10 derajat, sebagian komponen Z bocor ke X atau Y dan arahnya bisa meleset hingga 15 derajat. Untuk perangkat genggam atau yang bergoyang, solusinya adalah kompensasi kemiringan: kamu mencari sudut roll dan pitch dengan akselerometer MPU-6050 lalu memutar nilai magnetometer ke bidang horizontal. Untuk proyek sederhana seperti mobil robot atau kotak yang diam, memasang modul datar dan kokoh di bodi sering kali sudah cukup.

Ide proyek dengan modul kompas

  • Mobil robot penjaga arah: ajari mobil robot-mu berbelok ke sudut tertentu dan melaju lurus; pasang modul di tiang plastik yang jauh dari motor.
  • Navigasi GPS ke tujuan: hitung arah ke tujuan dengan GPS NEO-6M dan tampilkan selisihnya dengan kompas sebagai panah di layar.
  • Kompas berjarum servo: putar lengan motor servo supaya selalu menunjuk ke utara, ke mana pun kotaknya kamu putar.
  • Penunjuk arah kiblat: tulis sudut kiblat kotamu di kode dan putar panah di OLED berdasarkan sudut itu, bukan ke utara.
  • Orientasi panel surya: pakai kompas untuk memastikan panel menghadap ke arah yang benar di sistem pelacak matahari.
  • Tongkat penunjuk arah: tambahkan mode di proyek tongkat pintar yang memberi getaran singkat ketika pengguna menghadap ke utara.
  • Detektor magnet dan logam: hitung kekuatan medan total dari ketiga sumbu dan bunyikan buzzer ketika nilainya tiba-tiba naik.

Kesalahan umum dan cara mengatasinya

GejalaKemungkinan penyebabSolusi
Error “No HMC5883 detected”Board-nya memakai QMC5883LPakai kode untuk alamat 0x0D atau library QMC5883LCompass
Tidak ada alamat sama sekali di scan I2CSDA dan SCL tertukar, tidak ada daya, atau kabel putusCek kabel dan ukur tegangan di pin VCC
X, Y, Z selalu 0 atau tidak pernah berubahQMC5883L dalam mode standby ketika dinyalakanTulis pengaturan mode kontinu (0x1D) ke register 0x09
Sudut tidak mencakup 360 derajat penuhOffset hard iron terlalu besarLakukan kalibrasi dan kurangi dengan nilai OFF
Sudut berkurang ketika diputar searah jarum jamTata letak sumbu board-nya berbedaPakai atan2(-y, x)
Arah bergeser ketika motor berjalanMagnet motor dan kabel berarus tinggiPindahkan modul 15–20 cm menjauh, ke sebuah tiang
Arah meleset ketika dimiringkanTidak ada kompensasi kemiringanPasang modul datar atau kompensasi dengan MPU-6050
Selama pengujian, bahkan meja logam, speaker laptop, ponsel, atau ferrite bead di kabel USB bisa membuat pembacaan meleset. Lakukan kalibrasi dan pengujian di posisi akhir dan dengan pengkabelan akhir yang akan dipakai modul di proyekmu; kompas yang terkalibrasi sempurna di meja bisa meleset lagi begitu dipasang di dalam robot.

Begitu chip yang benar sudah dikenali dan dikalibrasi, modul kompas GY-271 adalah salah satu cara termurah untuk memberi proyekmu rasa arah. Untuk menampilkan arah, kamu bisa memakai layar LCD I2C atau OLED, dan untuk mengubahnya menjadi gerakan kamu bisa memakai servo, motor stepper, atau mobil robot. Di aplikasi BlueGrays kamu akan menemukan proyek layar, motor, dan robot ini lengkap dengan skema rangkaian dan kode langkah demi langkah, dan kamu bisa dengan mudah menambahkan modul kompas ke proyek-proyek itu.

Pertanyaan umum

GY-271 milikku memakai QMC5883L atau HMC5883L?

Cara termudah adalah scan I2C: kalau alamat 0x0D muncul, itu QMC5883L; kalau 0x1E yang muncul, itu HMC5883L. Kamu juga bisa melihat tulisan di chip; QMC5883L biasanya bertuliskan DA 5883 dan HMC5883L bertuliskan L883. Sebagian besar board GY-271 yang dijual sekarang memakai QMC5883L.

Apakah library HMC5883L bisa dipakai untuk QMC5883L?

Tidak. Kedua chip punya alamat I2C, alamat register, urutan byte, dan pengaturan yang berbeda; library HMC mencari alamat 0x1E dan tidak bisa menemukan QMC5883L. Untuk QMC5883L kamu perlu library seperti QMC5883LCompass atau kode yang ditulis langsung dengan Wire.

Kenapa modul kompas Arduino-ku menunjukkan arah yang salah?

Penyebab paling umum adalah belum dikalibrasi; magnet dan komponen logam di sekitar menambahkan offset ke pembacaan dan bisa menggeser sudut hingga puluhan derajat. Modul yang miring, dekat dengan motor dan kabel berarus, serta deklinasi magnetik yang belum ditambahkan juga menyebabkan galat. Memasang modul datar dan mengkalibrasinya di posisi akhir biasanya menurunkan galat sampai tinggal beberapa derajat.

Berapa deklinasi magnetik di Turki?

Di Turki deklinasi magnetiknya ke arah timur dan sekarang kira-kira antara 5 dan 7 derajat; lebih kecil di provinsi bagian barat dan lebih besar di bagian timur. Sekitar 6 derajat bisa dipakai untuk Istanbul dan Ankara. Karena nilainya berubah perlahan dari tahun ke tahun, cek kalkulator model magnetik terkini untuk hasil yang tepat.

Apakah modul kompas GY-271 bisa bekerja di 5 V?

Bisa. Karena board GY-271 punya regulator 3,3 V, kamu bisa memberi pin VCC 3–5 V dan menghubungkan board langsung ke Arduino Uno. Chip-nya sendiri bekerja di 3,3 V; di ESP32 dan Raspberry Pi Pico sebaiknya beri daya board dari pin 3V3.

Apakah modul kompas mengukur dengan benar ketika dimiringkan?

Arah yang dihitung hanya dari X dan Y hanya benar selama modul sejajar dengan tanah. Karena di Turki medan magnet masuk ke tanah dengan sudut inklinasi sekitar 55–60 derajat, kemiringan kecil saja bisa menggeser arah 10–15 derajat. Untuk perangkat genggam kamu perlu kompensasi kemiringan dengan akselerometer seperti MPU-6050.

Lihat semua proyek
Menggunakan Layar LCD dengan I2C
AR-32Pemula
Premium

Menggunakan Layar LCD dengan I2C

Beri Arduino-mu layar sendiri dan buat ia menulis pesan pertamanya. Layar LCD dua baris tersambung hanya dengan beberapa kabel; sapaan muncul di baris atas, lalu pesan kedua di baris bawah, layar…

4.8(53)
70
Layar LCD I2C ESP32 (16x2)
ES-17Menengah
Premium

Layar LCD I2C ESP32 (16x2)

Di proyek ini, kita menampilkan teks dengan menyambungkan layar LCD karakter 16x2 ke ESP32 lewat protokol I2C. Berkat I2C, kita bisa mengendalikan layar hanya dengan dua pin data (SDA dan SCL), sehingga tidak perlu memboroskan 6+ pin seperti pada sambungan paralel klasik. Kode mencetak pesan tetap di baris pertama dan penghitung yang naik setiap detik di baris kedua. Selain itu, kita menjalankan pemindai I2C di awal untuk mencetak alamat layar ke Serial Monitor (biasanya 0x27).

4.9(23)
40
HTTPClient + API Cuaca ESP32 (dengan Layar OLED SSD1306)
ES-32Mahir
Premium

HTTPClient + API Cuaca ESP32 (dengan Layar OLED SSD1306)

Di proyek ini, kita memakai ESP32 untuk melakukan panggilan REST API ke API cuaca (wttr.in) lewat internet dengan HTTPClient.h. Berbeda dengan versi LCD I2C sebelumnya, di sini kita memakai layar OLED SSD1306 (128×64), yang memungkinkan font besar, ikon vektor, dan tampilan visual yang kaya di satu layar. Tujuh ikon vektor untuk kondisi cuaca (cerah, berawan sebagian, berawan, hujan, salju, badai, berkabut) digambar ketika program berjalan (tanpa file bitmap).

4.3(10)
22
Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)
ES-33Mahir
Premium

Deep Sleep ESP32: Hemat Baterai (OLED + Penghitung RTC RAM)

Mode Deep Sleep ESP32 menurunkan konsumsi arus hingga ~10 µA dengan mematikan CPU dan sebagian besar periferal, sehingga sangat penting untuk perangkat IoT bertenaga baterai. Di proyek ini, kita memakai tiga sumber bangun yang berbeda: timer (15 detik), pin eksternal (EXT0, tombol GPIO 33), dan sentuhan (T0/GPIO 4). Variabel yang ditandai RTC_DATA_ATTR dipertahankan selama deep sleep; penghitung boot, penghitung bangun karena timer, dan penghitung bangun karena tombol terus dilacak.

4.3(10)
16
Menggunakan Motor Servo
AR-35Pemula
Premium

Menggunakan Motor Servo

Lengan motor servo kecil berputar ke tiga posisi bergantian: penuh ke awal, tepat ke tengah, dan penuh ke akhir, menunggu dua detik di setiap perhentian.

4.7(48)
67
Menggunakan Motor Stepper
AR-67Menengah
Premium

Menggunakan Motor Stepper

Motor yang berputar selangkah demi selangkah, persis sejauh yang kamu mau, seperti jarum jam.

4.5(31)
42
Mobil Kendali Bluetooth dengan L298N
AR-80Mahir
Premium

Mobil Kendali Bluetooth dengan L298N

Jadikan ponselmu remote dan kendarai mobil robotmu sendiri. Arduino menerima perintah dari aplikasi remote control di ponselmu lewat modul Bluetooth dan memutar roda dengan driver motor; mobil maju…

5.0(39)
66
Robot Penghindar Rintangan
AR-81Mahir
Premium

Robot Penghindar Rintangan

Bagaimana kalau membuat kendaraan pintar yang mencari jalannya sendiri? Robot Penghindar Rintangan terus memindai sekelilingnya berkat sensor ultrasonik di depannya.

5.0(38)
49