Parçalar · 8 dk okuma

Arduino Pusula Modülü: QMC5883L ve HMC5883L (GY-271) Kullanımı

GY-271 pusula modülü QMC5883L mi HMC5883L mi? I2C adresleri (0x0D, 0x1E), yön hesabı, manyetik sapma, kalibrasyon ve OLED pusula; Uno, ESP32, Pico kodu.

Arduino pusula modülü, kartına kuzeyin nerede olduğunu söyleyen küçük bir manyetik alan sensörüdür. En yaygın model olan GY-271, Dünya'nın manyetik alanını üç eksende ölçer; bu ölçümden yön açısını (0–360 derece) hesaplayıp robot arabanı belirli bir yöne sürebilir, OLED ekranda dijital bir pusula gösterebilir ya da GPS projene yön bilgisi ekleyebilirsin. Modül yalnızca dört kabloyla I2C üzerinden bağlanır ve Arduino Uno, ESP32 ve Raspberry Pi Pico ile aynı mantıkla çalışır.

Ancak bu modülün bir sürprizi var: GY-271 adıyla satılan kartların çoğunda artık Honeywell'in HMC5883L yongası değil, QST firmasının QMC5883L yongası bulunur. İki yonga dışarıdan neredeyse aynı görünse de I2C adresleri ve register yapıları farklıdır; bu yüzden hazır kodların birçoğu "sensör bulunamadı" hatası verir. Bu yazıda önce kartında hangi yonganın olduğunu anlamayı, sonra yön açısını doğru hesaplamayı, manyetik sapmayı eklemeyi ve kalibrasyonla hatayı birkaç dereceye indirmeyi öğreneceksin.

Dijital pusula modülü nedir, nasıl çalışır?

Pusula modülünün kalbinde bir manyetometre, yani manyetik alan ölçer vardır. Dünya'nın manyetik alanı oldukça zayıftır: Türkiye'de toplam şiddeti yaklaşık 45–50 mikrotesla (0,45–0,5 gauss), yere paralel yatay bileşeni ise 25 µT civarındadır (1 gauss = 100 µT). Yonga, manyetoresistif algılayıcılarla bu alanın X, Y ve Z eksenlerindeki bileşenlerini ölçer ve her birini işaretli bir tam sayı olarak verir. Modül yere paralel dururken yön için yalnızca X ve Y değerleri yeterlidir; bu iki bileşenden atan2 fonksiyonuyla açıyı bulursun. Z ekseni ise eğim telafisi ve metal algılama gibi ileri uygulamalarda işe yarar.

ÖzellikQMC5883LHMC5883L
ÜreticiQSTHoneywell (üretimi durduruldu)
I2C adresi0x0D0x1E
Ölçüm aralığı±2 G ya da ±8 G±0,88 G ile ±8,1 G arası (8 kademe)
Çözünürlük16 bit (±2 G'de 12000 LSB/G, ±8 G'de 3000 LSB/G)12 bit (±1,3 G'de 1090 LSB/G)
Veri hızı10, 50, 100, 200 Hz0,75–75 Hz (sürekli modda)
Yonga besleme2,16–3,6 V2,16–3,6 V
GY-271 kart besleme3–5 V (kartta regülatör var)3–5 V (kartta regülatör var)
Sıcaklık ölçümüVar (bağıl değer)Yok

QMC5883L mi HMC5883L mi? İki yongayı ayırt etmek

HMC5883L uzun yıllar hobi elektroniğinin standart pusula yongasıydı. Honeywell üretimi durdurunca piyasayı QST'nin QMC5883L yongası doldurdu. Satıcılar ürün adını çoğu zaman değiştirmediği için "HMC5883L" diye aldığın kartta QMC5883L çıkması son derece olağandır. Ayırt etmenin en kesin yolu bir I2C taramasıdır: hatta 0x0D adresi görünüyorsa QMC5883L, 0x1E görünüyorsa HMC5883L vardır. Yonganın üzerindeki yazıyı büyüteçle okumak da işe yarar. Son dönemde bazı kartlarda 0x2C adresli QMC5883P de görülebiliyor; onun register haritası farklı olduğu için bu yazıdaki kodlar o yongayla doğrudan çalışmaz.

YöntemQMC5883LHMC5883L
I2C adresi0x0D0x1E
Yonga üzerindeki yazıDA 5883L883
Kimlik register'ı0x0D register'ı 0xFF döner0x0A–0x0C register'ları 'H', '4', '3' döner
Veri register'ları0x00–0x05 (X, Y, Z sırasıyla)0x03–0x08 (X, Z, Y sırasıyla)
Bayt sırasıÖnce düşük bayt (LSB)Önce yüksek bayt (MSB)
Açılıştaki modBekleme (standby), ölçüm yapmazTek ölçüm modu
Yaygın kütüphaneQMC5883LCompassAdafruit HMC5883 Unified
Adafruit HMC5883 Unified gibi HMC kütüphaneleri yalnızca 0x1E adresini arar. Kartında QMC5883L varsa "no HMC5883 detected" benzeri bir mesaj alırsın ve modülün bozuk olduğunu sanırsın. Modül bozuk değildir, yalnızca yonga farklıdır. Önce I2C taraması yap, sonra doğru adresle konuşan kodu kullan.

GY-271 bağlantısı: Uno, ESP32 ve Pico

GY-271 piniArduino UnoESP32Raspberry Pi Pico
VCC5V (ya da 3.3V)3V33V3 (pin 36)
GNDGNDGNDGND
SCLA5GPIO 22GP5 (pin 7)
SDAA4GPIO 21GP4 (pin 6)
DRDYBağlanmazBağlanmazBağlanmaz

GY-271 kartında 3,3 V regülatör ve I2C hatları için pull-up dirençleri bulunur; bu yüzden Uno'da modülü 5V pininden beslemek güvenlidir. ESP32 ve Pico'da kartı 3V3 pininden besle ki SDA ve SCL hatları 3,3 V seviyesinde kalsın. DRDY (veri hazır) pini her yeni ölçümde sinyal verir; kesme ile okuma yapmayacaksan boş bırakabilirsin. Pusula, OLED ekran (0x3C) ya da MPU-6050 (0x68) gibi diğer I2C cihazlarıyla aynı hattı paylaşabilir, çünkü adresleri çakışmaz. Adres ve pull-up mantığının ayrıntıları için I2C nedir yazısına bakabilirsin.

Adım adım: ilk yön okuması (Arduino Uno)

  1. Modülü breadboard'a tak; mümkünse motor, hoparlör, mıknatıs ve büyük çelik parçalardan en az 15–20 cm uzakta tut.
  2. Tablodaki gibi VCC, GND, SCL ve SDA kablolarını bağla, DRDY pinini boş bırak.
  3. Aşağıdaki kodu yükle; ek kütüphane gerekmez, yalnızca Arduino'nun kendi Wire kütüphanesi kullanılır.
  4. Seri Monitör'ü 9600 baud hızında aç; ilk satırda kodun hangi yongayı bulduğunu görürsün.
  5. Modülü masaya düz koy ve yavaşça kendi etrafında çevir; X ve Y değerlerinin artı ile eksi arasında gidip geldiğini, açının 0'dan 360'a ilerlediğini izle.
  6. Telefon pusulan gerçek kuzeyi gösterecek şekilde ayarlıysa, modüldeki X okunu o kuzeye çevir; açı 0'a yaklaşmalı. Kalibrasyondan önce 10–30 derecelik sapma normaldir.
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}
Kod / registerDeğerAnlamı
QMC 0x0B0x01SET/RESET periyodu; veri sayfasının önerdiği değer
QMC 0x090x1DOSR 512, ±8 G aralık, 200 Hz, sürekli ölçüm (±2 G için 0x0D)
HMC 0x000x708 ölçümün ortalaması, 15 Hz veri hızı
HMC 0x010x20±1,3 Ga aralık, 1090 LSB/Ga hassasiyet
HMC 0x020x00Sürekli ölçüm modu
Wire.endTransmission() == 0-Adres cevap verdiyse cihaz hatta var demektir
atan2(y, x) × 180 / π-Ham eksenlerden −180 ile +180 derece arası açı

Yön açısı nasıl hesaplanır?

Modül düz dururken Dünya'nın yatay manyetik alanı X ve Y eksenleri arasında paylaşılır. X okunu kuzeye çevirdiğinde alanın tamamı X eksenine düşer ve Y sıfıra yaklaşır; modülü döndürdükçe pay Y eksenine kayar. Yön açısı θ = atan2(Y, X) formülüyle bulunur. Basit atan(Y/X) yerine atan2 kullanmanın sebebi, atan2'nin iki değerin işaretine bakarak dört çeyreği de ayırt etmesi ve X sıfır olduğunda sıfıra bölme hatası vermemesidir. Sonuç −180 ile +180 derece arasında radyan olarak gelir; 180/π ile çarpıp dereceye çevirir, negatifse 360 eklersin. Sekiz ana yönün her biri 45 derecelik bir dilim kaplar: 337,5 ile 22,5 derece arası Kuzey (K), 22,5 ile 67,5 arası Kuzeydoğu (KD) olur ve böyle devam eder; koddaki (açı + 22,5) / 45 işlemi doğru dilimi seçer. Modülü saat yönünde çevirdiğinde açı artacağına azalıyorsa kartındaki eksen yerleşimi farklıdır; Y'nin işaretini değiştirip atan2(-y, x) kullanman sorunu çözer.

Manyetik sapma (deklinasyon) nedir?

Pusula iğnesi coğrafi (gerçek) kuzeyi değil, manyetik kuzeyi gösterir. İkisi arasındaki açıya manyetik sapma ya da deklinasyon denir ve bulunduğun yere ve yıla göre değişir. Türkiye'de sapma doğu yönlüdür ve günümüzde batı illerinde yaklaşık +5 derece, doğu illerinde +7 derece civarındadır; İstanbul ve Ankara için 6 derece iyi bir başlangıçtır. Düzeltme formülü basittir: gerçek yön = manyetik yön + sapma; doğu sapma pozitif, batı sapma negatif yazılır. Bulunduğun yerin güncel değerini NOAA'nın ya da benzeri bir kurumun manyetik model hesaplayıcısından öğrenip koddaki DECLINATION sabitine yazman yeterli. Değeri derece ve dakika olarak bulursan ondalığa çevir: 5° 48' = 5 + 48/60 = 5,8 derece. Sapma yılda birkaç açı dakikası kaydığından birkaç yılda bir kontrol etmek iyi olur.

Pusula kalibrasyonu: hard iron ve soft iron

Kalibre edilmemiş bir pusula, özellikle ilk denemede 20–40 derece yanılabilir. Bunun iki sebebi vardır. Hard iron (sert demir) etkisinde modülün yakınındaki kalıcı mıknatıslar, mıknatıslanmış vidalar ya da kart üzerindeki parçalar her ölçüme sabit bir değer ekler; modülü çevirirken X–Y değerlerini grafiğe dökersen çemberin merkezinin sıfırdan kaydığını görürsün. Soft iron (yumuşak demir) etkisinde ise yakındaki demir ve nikel gibi malzemeler alanı büker ve çemberi elipse çevirir. Çözüm basittir: modülü projede duracağı son konumda düz tutup yavaşça iki üç tur çevirirken her eksenin en küçük ve en büyük değerini kaydedersin. Ofset = (max + min) / 2 hard iron etkisini, ölçek = ortalama yarıçap / eksen yarıçapı ise basit bir soft iron düzeltmesini verir. Aşağıdaki kod kartların çoğunda bulunan QMC5883L içindir; HMC5883L kullanıyorsan okuma fonksiyonunu ilk koddaki HMC kısmıyla değiştirmen yeterli.

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}

Kod her saniye OFF ve SCALE değerlerini yazar; sayılar artık değişmeyene kadar çevirmeye devam et. Örneğin X için en küçük −680, en büyük 920 ölçtüysen ofset (920 + (−680)) / 2 = 120, yarıçap 800 olur. Y için en küçük −1010, en büyük 550 ise ofset −230, yarıçap 780'dir. Ortalama yarıçap 790 olduğundan ölçekler 790 / 800 ≈ 0,988 ve 790 / 780 ≈ 1,013 çıkar. Ana kodda her ham okumayı x = (ham_x − OFF_X) × SCALE_X biçiminde düzeltirsin; aşağıdaki ESP32 örneğinde bu değerler hazır yazılıdır. ±8 G aralığında 1 gauss 3000 sayıya karşılık geldiği için 800'lük yarıçap yaklaşık 0,27 G'lik yatay alan demektir; bu, Türkiye için beklenen değerle uyumludur. Modülü başka bir yere taşırsan ya da yakına yeni bir metal parça eklersen kalibrasyonu tekrarla.

ESP32 ile OLED ekranda pusula

0,96 inç I2C OLED ekran
0,96 inç I2C OLED ekran (0x3C), pusula modülüyle (0x0D) aynı I2C hattını sorunsuz paylaşır.

ESP32'de aynı Wire kodu çalışır; I2C pinleri GPIO 21 (SDA) ve GPIO 22 (SCL)'dir ve pusula ile 0,96 inç OLED ekran aynı hatta bağlanır. Kod kalibrasyon değerlerini uygular, X ve Y'yi basit bir alçak geçiren filtreyle yumuşatır, ekranın solunda dönen bir pusula iğnesi, sağında ise derece ile yön harfini gösterir. Filtreyi açıya değil eksenlere uygulamamızın nedeni, 359 ile 0 derece arasındaki geçişte açıların ortalamasının yanlışlıkla 180 civarı çıkmasını önlemektir. Ekranın üstündeki kısa çizgi cihazın ön yönünü, iğne ise kuzeyi gösterir; sen cihazı döndürdükçe iğne ters yöne döner, tıpkı gerçek bir pusula gibi. Ekran kütüphanelerinin kurulumu için OLED ekran (SSD1306) yazısına bakabilirsin.

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}

Raspberry Pi Pico ile MicroPython pusula

Pico'da MicroPython'un machine.I2C sınıfı yeterlidir, ayrı bir sürücü dosyası gerekmez. Kod önce i2c.scan() ile hattaki adresleri listeler, bulduğu yongaya göre ayarları yazar ve readfrom_mem ile altı baytı tek seferde okur. MicroPython'da baytlar işaretsiz geldiği için 32767'den büyük değerlerden 65536 çıkararak negatif sayılara çevirmen gerekir. Kalibrasyon için Arduino'da bulduğun OFF ve SCALE değerlerini koddaki sabitlere yazman yeterli. MicroPython'a yeni başlıyorsan MicroPython temelleri ve Raspberry Pi Pico nedir yazıları iyi bir başlangıç olur.

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)

Eğim telafisi: modül neden düz durmalı?

Yalnızca X ve Y eksenleriyle hesaplanan yön, modül yere paralelken doğrudur. Türkiye gibi orta enlemlerde manyetik alan yere yaklaşık 55–60 derecelik bir eğimle girer; bu yüzden düşey (Z) bileşen yatay bileşenden belirgin biçimde büyüktür. Modül 10 derece eğildiğinde Z bileşeninin bir kısmı X ya da Y eksenine karışır ve yön 15 dereceye varan bir hatayla kayabilir. Elde taşınan ya da sallanan cihazlarda çözüm eğim telafisidir: bir MPU-6050 ivmeölçer ile yuvarlanma (roll) ve yunuslama (pitch) açılarını bulup manyetometre değerlerini yatay düzleme döndürürsün. Robot araba ya da sabit kutu gibi basit projelerde modülü gövdeye düz ve sağlam monte etmek çoğu zaman yeterlidir.

Pusula modülüyle proje fikirleri

  • Yön tutan robot araba: Robot arabana belirlediğin açıya dönmeyi ve düz gitmeyi öğret; modülü motorlardan uzak, plastik bir direğe yerleştir.
  • GPS ile hedefe yönlendirme: NEO-6M GPS ile hedefin yön açısını hesapla, pusulayla aradaki farkı ekranda bir ok olarak göster.
  • Servo ibreli pusula: Bir servo motorun kolunu, kutuyu nasıl çevirirsen çevir hep kuzeyi gösterecek şekilde döndür.
  • Kıble yönü bulucu: Şehrine ait kıble açısını koda yaz, OLED ekrandaki oku kuzey yerine bu açıya göre çevir.
  • Güneş paneli yönlendirme: Güneş takip sisteminde panelin doğru yöne bakıp bakmadığını pusulayla doğrula.
  • Yön söyleyen baston: Akıllı baston projesine, kullanıcı kuzeye döndüğünde kısa bir titreşim veren bir mod ekle.
  • Mıknatıs ve metal dedektörü: Üç eksenden toplam alan şiddetini hesapla, değer aniden yükseldiğinde buzzer çaldır.

Sık yapılan hatalar ve çözümleri

BelirtiOlası sebepÇözüm
"No HMC5883 detected" hatasıKartta QMC5883L var0x0D adresli kodu ya da QMC5883LCompass kütüphanesini kullan
I2C taramasında hiç adres yokSDA ve SCL ters, besleme yok ya da kablo kopukKabloları kontrol et, VCC pinindeki gerilimi ölç
X, Y, Z hep 0 ya da hiç değişmiyorQMC5883L açılışta bekleme modunda0x09 register'ına sürekli mod ayarını (0x1D) yaz
Açı 360 derecenin tamamını taramıyorHard iron ofseti çok büyükKalibrasyon yap ve OFF değerlerini çıkar
Saat yönünde çevirince açı azalıyorKartın eksen yerleşimi farklıatan2(-y, x) kullan
Motor çalışınca yön kayıyorMotor mıknatısı ve yüksek akımlı kablolarModülü 15–20 cm uzağa, bir direğe taşı
Eğik tutunca yön sapıyorEğim telafisi yokModülü düz monte et ya da MPU-6050 ile telafi et
Test sırasında metal masa, dizüstü bilgisayarın hoparlörü, telefon ve hatta USB kablosundaki ferrit halka bile ölçümü saptırabilir. Kalibrasyonu ve testleri, modülün projede kullanılacağı son konumda ve son kablolamayla yap; masada kusursuz kalibre edilen bir pusula robotun içine girince yeniden sapabilir.

GY-271 pusula modülü, doğru yongayı tanıdıktan ve bir kez kalibre ettikten sonra projelerine yön duygusu katmanın en ucuz yollarından biridir. Yön bilgisini göstermek için I2C LCD ya da OLED ekran, yönü harekete çevirmek için servo, step motor ya da robot araba kullanabilirsin. BlueGrays uygulamasında bu ekran, motor ve robot projelerini adım adım devre şeması ve kodlarıyla bulabilir, pusula modülünü bu projelerin üzerine kolayca ekleyebilirsin.

Sıkça sorulan sorular

GY-271 modülümde QMC5883L mi HMC5883L mi var?

En kolay yol bir I2C taraması yapmaktır: 0x0D adresi görünüyorsa QMC5883L, 0x1E görünüyorsa HMC5883L vardır. Yonganın üzerindeki yazıya da bakabilirsin; QMC5883L'de genellikle DA 5883, HMC5883L'de L883 yazar. Günümüzde satılan GY-271 kartlarının büyük çoğunluğunda QMC5883L bulunur.

HMC5883L kütüphanesi QMC5883L ile çalışır mı?

Hayır. İki yonganın I2C adresi, register adresleri, bayt sırası ve ayar değerleri farklıdır; HMC kütüphanesi 0x1E adresini arar ve QMC5883L'yi bulamaz. QMC5883L için QMC5883LCompass gibi bir kütüphane ya da doğrudan Wire ile yazılmış bir kod kullanmalısın.

Arduino pusula modülü neden yanlış yön gösteriyor?

En sık sebep kalibrasyon yapılmamasıdır; yakındaki mıknatıslar ve metal parçalar ölçüme ofset ekleyip açıyı onlarca derece kaydırabilir. Modülün eğik durması, motorlara ve akım taşıyan kablolara yakınlık ve manyetik sapmanın eklenmemesi de hataya yol açar. Modülü düz monte edip son konumunda kalibre etmek hatayı genellikle birkaç dereceye indirir.

Türkiye'de manyetik sapma kaç derece?

Türkiye'de manyetik sapma doğu yönlüdür ve günümüzde yaklaşık 5 ile 7 derece arasındadır; batı illerinde daha küçük, doğu illerinde daha büyüktür. İstanbul ve Ankara için 6 derece civarı kullanılabilir. Değer yıllar içinde yavaşça değiştiği için kesin sonuç için güncel bir manyetik model hesaplayıcısına bakmak gerekir.

GY-271 pusula modülü 5 V ile çalışır mı?

Evet, GY-271 kartının üzerinde 3,3 V regülatör bulunduğu için VCC pinine 3–5 V verilebilir ve kart Arduino Uno'ya doğrudan bağlanabilir. Yonganın kendisi 3,3 V ile çalışır; ESP32 ve Raspberry Pi Pico'da kartı 3V3 pininden beslemek en doğrusudur.

Pusula modülü eğik tutulunca doğru ölçer mi?

Yalnızca X ve Y eksenleriyle hesaplanan yön, modül yere paralelken doğrudur. Türkiye'de manyetik alan yere yaklaşık 55–60 derece eğimle girdiği için küçük bir eğim bile yönü 10–15 derece kaydırabilir. Elde taşınan cihazlarda MPU-6050 gibi bir ivmeölçerle eğim telafisi yapmak gerekir.

Tüm projeleri gör
I2C İle LCD Ekran Kullanımı
AR-32Başlangıç
Premium

I2C İle LCD Ekran Kullanımı

Arduino'ya kendi ekranını kazandır ve ilk mesajını yazdır. İki satırlık LCD ekran yalnızca birkaç kabloyla bağlanır; önce üst satıra bir selam, ardından alt satıra ikinci bir yazı gelir, ekran…

4.8(53)
70
ESP32 I2C LCD Ekran (16x2)
ES-17Orta
Premium

ESP32 I2C LCD Ekran (16x2)

Bu projede 16x2 karakter LCD ekranı I2C protokolü üzerinden ESP32'ye bağlayarak metin görüntülüyoruz. I2C sayesinde sadece 2 data pini (SDA ve SCL) ile ekranı kontrol edebiliyoruz; klasik paralel bağlantıdaki 6+ pin israfı ortadan kalkıyor. Kod ilk satıra sabit bir mesaj, ikinci satıra ise her saniye artan bir sayaç yazdırıyor. Ayrıca başlangıçta I2C tarayıcı çalıştırarak ekranın adresini Serial Monitor'a yazdırıyoruz (genelde 0x27 veya 0x3F).

4.9(23)
40
ESP32 HTTPClient + Hava Durumu API (SSD1306 OLED Ekranlı)
ES-32İleri
Premium

ESP32 HTTPClient + Hava Durumu API (SSD1306 OLED Ekranlı)

Bu projede ESP32 ile internet üzerinden hava durumu API'sine (wttr.in) HTTPClient.h kullanarak REST API çağrısı yapıyoruz. I2C LCD sürümünden farklı olarak burada SSD1306 OLED (128×64) ekran kullanıyoruz; büyük yazı ve vektör ikonlarla zengin bir görünüm elde ediliyor. Hava durumu için 7 vektör ikon (güneşli, yağmurlu, karlı ve diğerleri) bitmap dosyası gerekmeden çiziliyor.

4.3(10)
22
ESP32 Deep Sleep — Pil Tasarrufu (OLED + RTC RAM Sayaç)
ES-33İleri
Premium

ESP32 Deep Sleep — Pil Tasarrufu (OLED + RTC RAM Sayaç)

ESP32'nin Deep Sleep modu, CPU'yu ve çoğu çevre birimini kapatarak akım tüketimini yaklaşık 10µA seviyesine düşürür; pille çalışan IoT cihazları için kritik öneme sahiptir. Bu projede üç uyandırma kaynağı kullanıyoruz: zamanlayıcı (15 sn), harici pin (EXT0, GPIO 33'teki buton) ve dokunmatik pin (T0/GPIO 4). RTC_DATA_ATTR ile işaretlenen sayaçlar deep sleep boyunca korunur.

4.3(10)
16
Servo Motor Kullanım
AR-35Başlangıç
Premium

Servo Motor Kullanım

Küçük bir servo motorun kolu sırayla üç konuma döner: en başa, tam ortaya ve en sona, her durakta iki saniye bekleyerek.

4.7(48)
67
Step Motor Kullanımı
AR-67Orta
Premium

Step Motor Kullanımı

Saatin akrebi gibi adım adım, tam istediğin kadar dönen bir motor. Arduino, küçük bir step motoru sürücü kartı üzerinden önce bir yöne tam bir tur çevirir, bir saniye bekler, sonra ters yöne bir tur…

4.5(31)
42
L298N ile Bluetooth Kontrollü Araba
AR-80İleri
Premium

L298N ile Bluetooth Kontrollü Araba

Telefonunu kumandaya çevirip kendi robot arabanı sür. Arduino, Bluetooth modülü üzerinden telefondaki bir kumanda uygulamasından gelen komutları alır ve motor sürücüyle tekerlekleri döndürür; araba…

5.0(39)
66
Engelden Kaçan Robot
AR-81İleri
Premium

Engelden Kaçan Robot

Kendi yolunu bulan akıllı bir araç yapmaya ne dersin? Engelden Kaçan Robot, önündeki ultrasonik sensör sayesinde çevresini sürekli tarar.

5.0(38)
49