Mashruuca LED Matrix RGB ee ESP32-S3 4 - Dhibicda leexinta

Mashruuca LED Matrix RGB ee ESP32-S3 4 - Dhibicda leexinta

Mashruuc 4 – Dhibic Taagista (Dhaqaaqida Dhibcaha Adigoo Taagaya ESP32-S3 RGB LED Matrix)

Mashruuc 4 wuxuu soo bandhigayaa dareemaha dhaqdhaqaaqa ee ku dhex jira qaybta ESP32-S3 RGB LED Matrix. Halkii aad si otomaatig ah u dhaqaajin lahayd dhibcaha (sida Mashruuca 1) ama qoraalka rogaya (Mashruucyada 2 iyo 3), mashruucani wuxuu kuu ogolaanayaa inaad xakamayso booska dhibcaha adigoo si fudud u taagaya looxa. Dhibcuhu wuxuu si habsami leh ugu dhaqaaqaa shaashadda RGB ee 8×8 iyadoo lagu salaynayo akhrinta tooska ah ee QMI8658C accelerometer-ka ee dhabarka qaybta.

Dhammaan lixda mashruuc ee taxanahan waxaa lagu soo bandhigay hal fiidiyow oo YouTube ah. Isla fiidiyowga ayaa lagu dhex daray boggan, si aad si sax ah u aragto sida dhibcuhu u dhaqaaqo waqtiga dhabta ah marka looxa la taagayo. Koodhka dhammaystiran ee mashruucan waxaa si toos ah hoos loogu shubay maqaalka, iyo xiriiriyaha iibsashada ee qaybta ayaa ka hoos muuqda qaybta koodhka.

Qaybta ESP32-S3 RGB LED Matrix Overview

Mashruucani wuxuu isticmaalaa qaybta ESP32-S3 RGB LED Matrix, oo ay ku jiraan:

• Microcontroller-ka ESP32-S3 oo leh Wi-Fi iyo Bluetooth
• 8×8 RGB LED matrix (64 LED oo si gaar ah loo xakameyn karo)
• QMI8658C accelerometer oo dhabarka ku yaal oo loogu talagalay taagista iyo ogaanshaha dhaqdhaqaaqa
• Dekedda USB oo loogu talagalay barnaamijyaynta iyo korontada
• Badhamada Boot / Reset
• GPIO pins-ka la isticmaali karo oo loogu talagalay ballaarinta mustaqbalka

Dareemaha QMI8658C wuxuu akhriyaa qiimaha X, Y, iyo Z ee xawaaraha iyo jihada, taasoo u oggolaanaysa dhibcaha inuu u dhaqaaqo kor/hoos/bidix/dhanna iyadoo ku xiran sida looxa loo taagay.:contentReference[oaicite:0]{index=0}

Mashruucyada Ku Dhex Jira Fiidiyowga (Waqtiyada)

• 00:00 – Hordhac
• 02:01 – Rakibista looxyada ESP32
• 03:32 – Rakibista maktabadaha
• 05:32 – Mashruuc 1: Dhibic Dhaqaaqaysa
• 11:11 – Mashruuc 2: Qoraal Rogaya
• 12:59 – Mashruuc 3: Qoraal HTTP
• 16:41 – Mashruuc 4: Dhibic Taagista (mashruucan)
• 18:55 – Mashruuc 5: Fallaro Kor u Taag
• 20:02 – Mashruuc 6: Ciyaarta Bartilmaameedka

Daawashada muujinta taagista ee fiidiyowga ayaa si aad ah loogu talinayaa, maadaama aad arki karto sida dhibcuhu si habsami leh ugu falceliyo jihada looxa.:contentReference[oaicite:1]{index=1}

Rakibista Looxyada ESP32 ee Arduino IDE

Haddii aad dhammeysay mashruuc hore, taageerada looxa ayaa horay loo rakibay. Haddii kale, raac tillaabooyinkan:

1. Fur File > Preferences → Ku dar URL-ka Looxyada ESP32.
2. Tag Tools > Board > Boards Manager… oo rakib ESP32.
3. Dooro looxaaga ESP32-S3 ee hoos yimaada Tools > Board.
4. Dooro dekedda COM ee saxda ah ee hoos yimaada Tools > Port.

Rakibista Maktabadaha Loo Baahan Yahay

Mashruucani wuxuu u baahan yahay maktabadahan soo socda:

• Adafruit NeoMatrix
• Adafruit NeoPixel
• Adafruit GFX Library
• QMI8658 (dareemaha dhaqdhaqaaqa)

Ku rakib Maareeyaha Maktabadda:

1. Fur Sketch > Include Library > Manage Libraries….
2. Raadi Adafruit NeoMatrix → Rakib.
3. U oggolow rakibista otomaatiga ah ee Adafruit GFX iyo Adafruit NeoPixel.
4. Raadi QMI8658 qoraaga qoran → Rakib.:contentReference[oaicite:2]{index=2}

Sida Mashruuca 4 U Shaqeeyo

Dareemaha QMI8658C wuxuu si joogto ah u bixiyaa xogta xawaaraha ee dhinacyada X, Y, iyo Z. Mashruucan, waxaan kaliya u isticmaalnaa dhinacyada X iyo Y si aan u go'aamino:

• Inta uu dhibcuhu u dhaqaaqo bidix ama midig (dhinaca X)
• Inta uu dhibcuhu u dhaqaaqo kor ama hoos (dhinaca Y)

Qiimaha dareemaha waxaa loo qaabaynayaa isku-duwayaal u dhexeeya 0 ilaa 7 (oo loogu talagalay 8×8 LED matrix). Booska dhibcaha wuxuu ku cusboonaadaa jeer badan ilbiriqsi kasta, isagoo siinaya saameynta simbiriirixashada ee habsami leh markaad taagto qaybta.:contentReference[oaicite:3]{index=3}

Mashruuc 4 – Goobaha Koodhka (Dhibic Taagista)

Hoos waxaa ku yaal goobaha uu isticmaaluhu wax ka beddeli karo ee ku yaal meel u dhow bilowga koodhka mashruuca. Qoraalka dhammaystiran ayaa si otomaatig ah hoos uga muuqda maqaalka.

Pin-ka Matrix-ka iyo Cabbirka

// 8×8 RGB matrix configuration
const int MATRIX_PIN    = 14;   // pin go'an oo loogu talagalay looxan
const int MATRIX_WIDTH  = 8;
const int MATRIX_HEIGHT = 8;

Ka tag MATRIX_PIN at 14. Waxay si toos ah ugu xiran tahay matrix-ka ku jira looxa.

Iftiinka

// Iftiinka guud (0–255)
uint8_t matrixBrightness = 40;

Kordhi haddii loo baahdo, laakiin iska ilaali iftiinka aad u xooggan markaad u dhowaanayso.

Midabka Dhibcaha

// Midabka dhibcaha (R, G, B)
uint8_t dotRed   = 0;
uint8_t dotGreen = 200;   // cagaar khafiif ah (midabka caadiga ah)
uint8_t dotBlue  = 0;

Beddel qiimahan si aad u abuurto midab kasta. Tusaalooyin:

• Casaan: (255, 0, 0)
• Jaalle: (255, 255, 0)
• Cad: (255, 255, 255)

Xasaasiyadda Dhaqdhaqaaqa

Si looga hortago boodboodka xad-dhaafka ah, qiimaha accelerometer-ka waxaa badanaa la xakameeyaa ama la cabbiraa. Goob caadi ah waxay u egtahay:

// Sida xooggan ee taagista u saameyso dhaqdhaqaaqa
float sensitivity = 4.0f;   // ka weyn = dhaqdhaqaaq ka dhakhso badan shaashadda

Haddii dhibcuhu si gaabis ah u dhaqaaqo → kordhi qiimaha. Haddii dhibcuhu si lama filaan ah u dhaqaaqo → hoos u dhig.

Xawaaraha Cusboonaysiinta (Heerka Cusboonaysiinta)

Waxaad ku dari kartaa daahitaan yar oo u dhexeeya cusboonaysiinta si aad u simiso dhaqdhaqaaqa:

// Daahitaanka u dhexeeya cusboonaysiinta booska (ms)
int refreshDelayMs = 20;   // hoose = jawaab celin siman oo degdeg ah

Qiimayaasha u dhexeeya 10–30 ms waxay dareen u leeyihiin jawaab celin aad u fiican.

Soo Koobid

Mashruuca 4 wuxuu soo nooleeyaa QMI8658C accelerometer-ka ku dhex jira ESP32-S3 adiga oo kuu ogolaanaya inaad ku xakamayso shaxanka LED-ka dhaqdhaqaaqa jirka. Tilf yar oo loo rogo guddiga ayaa dhaqaajiya dhibcaha isla jihadaas, taasoo ka dhigaysa mashruucan tillaabo fiican oo loogu gudbo mashruucyada horumarsan ee “Arrow Up” iyo “Target Game”.

Qoraalka buuxa ee Tilt Dot ayaa hoos ku shuban maqaalkan (si toos ah). Si aad u fahanto sida ugu fiican, daawo muujinta tilfka ee fiidiyowga, halkaas oo aad ku arki karto sida siman ee dhibcuhu u dhaqaaqaan marka guddiga la rogo. Linkiyada lagu iibsado module-ka ESP32-S3 RGB LED Matrix ayaa ku qoran hoosta qaybta koodka.

Sawirro

ESP32 S3 Matrix

ESP32 S3 Matrix pin out

ESP32-S3_RGB_8x8_matrix-3

ESP32 S3 Matrix displaying rainbow heart

ESP32-S3_RGB_8x8_matrix1

ESP32-S3_RGB_8x8_matrix-2

ESP32 S3 Matrix

ESP32 S3 Matrix pin out

ESP32-S3_RGB_8x8_matrix-3

ESP32 S3 Matrix displaying rainbow heart

ESP32-S3_RGB_8x8_matrix1

ESP32-S3_RGB_8x8_matrix-2

/* 
  Project 4: Tilt Dot – ESP32-S3 RGB LED Matrix (Waveshare)

  This sketch reads tilt from the QMI8658C IMU and smoothly moves a dot 
  on the 8×8 RGB LED matrix based on board orientation.

  ▶️ Video Tutorial:
  https://youtu.be/JKLuYrRcLMI

  📚⬇️ Resources & Code Page:
  https://robojax.com/RJT829

  QMI8658_RGB_2
*/

#include <Arduino.h>
#include <math.h>

#include <Adafruit_GFX.h>
#include <Adafruit_NeoMatrix.h>
#include <Adafruit_NeoPixel.h>

#include <QMI8658.h>   // by Lahav Gahali

// -------- LED MATRIX SETUP --------
#define MATRIX_PIN    14
#define MATRIX_WIDTH  8
#define MATRIX_HEIGHT 8

Adafruit_NeoMatrix matrix = Adafruit_NeoMatrix(
  MATRIX_WIDTH, MATRIX_HEIGHT, MATRIX_PIN,
  NEO_MATRIX_TOP + NEO_MATRIX_LEFT +
  NEO_MATRIX_ROWS + NEO_MATRIX_PROGRESSIVE,
  NEO_RGB + NEO_KHZ800
);

// -------- QMI8658 IMU SETUP --------
QMI8658 imu;
QMI8658_Data imuData;

// -------- USER SETTINGS --------

// true  -> dot on opposite side: USB↔OUSB, 34↔15
// false -> dot on same side as UP
bool useOppositeMapping = false;

// Dot color (0–255 each)
uint8_t dotRed   = 0;
uint8_t dotGreen = 100;
uint8_t dotBlue  = 0;

// Board sides
enum Side {
  SIDE_CENTER = 0,
  SIDE_USB,
  SIDE_OUSB,
  SIDE_15,
  SIDE_34
};

// Smooth dot position (in pixel coordinates, but kept as float for easing)
float dotPosX = 3.0f;   // start at center
float dotPosY = 3.0f;

// Smoothing factor: smaller = slower movement (0.1 very slow, 0.5 faster)
const float dotSmooth = 0.25f;


bool isFlat = false;

const char* sideName(Side s) {
  switch (s) {
    case SIDE_CENTER: return "CENTER";
    case SIDE_USB:    return "USB";
    case SIDE_OUSB:   return "OUSB";
    case SIDE_15:     return "15";
    case SIDE_34:     return "34";
    default:          return "?";
  }
}

// Detect which side is UP using calibrated axes:
// +X = USB, -X = OUSB, +Y = 34, -Y = 15
Side detectSideUp(float ax_g, float ay_g, float az_g) {
  // Flat detection
  const float flatThreshXY = 0.15f;
  const float flatThreshZ  = 0.15f;

  if (fabs(ax_g) < flatThreshXY &&
      fabs(ay_g) < flatThreshXY &&
      fabs(az_g - 1.0f) < flatThreshZ) {
    isFlat = true;
    return SIDE_CENTER;
  }
  isFlat = false;

  // Thresholds to say "this axis is really tilted"
  const float tiltThreshY = 0.5f;
  const float tiltThreshX = 0.5f;

  // 1) Prefer Y axis for 15 / 34 if it's clearly tilted
  if (fabs(ay_g) >= tiltThreshY) {
    if (ay_g > 0) {
      return SIDE_15;   // +Y = 34 up
    } else {
      return SIDE_34;   // -Y = 15 up
    }
  }

  // 2) Otherwise, check X axis for USB / OUSB
  if (fabs(ax_g) >= tiltThreshX) {
    if (ax_g > 0) {
      return SIDE_USB;  // +X = USB up
    } else {
      return SIDE_OUSB; // -X = OUSB up
    }
  }

  // 3) If nothing is strongly tilted, just call it CENTER
  return SIDE_CENTER;
}

// Map from UP side to where the dot should go
Side dotSideFromUpSide(Side upSide) {
  switch (upSide) {
    case SIDE_USB:
      return useOppositeMapping ? SIDE_OUSB : SIDE_USB;

    case SIDE_OUSB:
      return useOppositeMapping ? SIDE_USB : SIDE_OUSB;

    case SIDE_34:
      return useOppositeMapping ? SIDE_15 : SIDE_34;

    case SIDE_15:
      return useOppositeMapping ? SIDE_34 : SIDE_15;

    case SIDE_CENTER:
    default:
      return SIDE_CENTER;
  }
}

// Convert dot side to matrix coordinates
void getDotPixel(Side dotSide, int &px, int &py) {
  // Matrix (0,0) = top-left
  // top center:    (3,0) → USB
  // bottom center: (3,7) → OUSB
  // left center:   (0,3) → 15
  // right center:  (7,3) → 34
  // center:        (3,3)

  switch (dotSide) {
    case SIDE_USB:   px = 3; py = 0; break;
    case SIDE_OUSB:  px = 3; py = 7; break;
    case SIDE_15:    px = 0; py = 3; break;
    case SIDE_34:    px = 7; py = 3; break;
    case SIDE_CENTER:
    default:         px = 3; py = 3; break;
  }
}

void setup() {
  Serial.begin(115200);
  delay(500);

  matrix.begin();
  matrix.setBrightness(20);
  matrix.fillScreen(0);
  matrix.show();

  // IMU: SDA=11, SCL=12 for ESP32-S3-Matrix
  if (!imu.begin(11, 12)) {
    Serial.println("Failed to initialize QMI8658!");
    while (1) { delay(1000); }
  }

  imu.setAccelUnit_mg(true);
  imu.setGyroUnit_dps(true);
  imu.setDisplayPrecision(4);

  Serial.print("QMI8658 initialized. useOppositeMapping = ");
  Serial.println(useOppositeMapping ? "TRUE" : "FALSE");
}

void loop() {
  if (!imu.readSensorData(imuData)) {
    return;
  }

  float ax_g = imuData.accelX / 1000.0f;
  float ay_g = imuData.accelY / 1000.0f;
  float az_g = imuData.accelZ / 1000.0f;

  Side upSide  = detectSideUp(ax_g, ay_g, az_g);
  Side dotSide = dotSideFromUpSide(upSide);

  int targetX, targetY;
  getDotPixel(dotSide, targetX, targetY);

  // --- Smooth movement toward target ---
  dotPosX += (targetX - dotPosX) * dotSmooth;
  dotPosY += (targetY - dotPosY) * dotSmooth;

  // Convert to integer pixel coordinates
  int px = (int)round(dotPosX);
  int py = (int)round(dotPosY);

  // Clamp just in case
  if (px < 0) px = 0;
  if (px > 7) px = 7;
  if (py < 0) py = 0;
  if (py > 7) py = 7;

  // --- Draw dot ---
  matrix.fillScreen(0);
  uint16_t color = matrix.Color(dotRed, dotGreen, dotBlue);
  matrix.drawPixel(px, py, color);
  matrix.show();

  // Debug
  Serial.print("AX="); Serial.print(ax_g, 3);
  Serial.print(" AY="); Serial.print(ay_g, 3);
  Serial.print(" AZ="); Serial.print(az_g, 3);
  Serial.print(" | UP=");  Serial.print(sideName(upSide));
  Serial.print(" | DOT="); Serial.print(sideName(dotSide));
  Serial.print(" | px=");  Serial.print(px);
  Serial.print(" py=");    Serial.println(py);

  delay(80);
}