Search Code

ESP32-S3 RGB LED மேட்ரிக்ஸ் திட்டம் 4 - சாய்வு புள்ளி

யூடியூபில் பாருங்கள்

ESP32-S3 RGB LED மேட்ரிக்ஸ் திட்டம் 4 - சாய்வு புள்ளி

திட்டம் 4 – சாய்வு புள்ளி (ESP32-S3 RGB LED மேட்ரிக்ஸை சாய்த்து புள்ளியை நகர்த்தவும்)

திட்டம் 4, ESP32-S3 RGB LED மேட்ரிக்ஸ் தொகுதியில் கட்டமைக்கப்பட்ட இயக்க உணரியை அறிமுகப்படுத்துகிறது. புள்ளியை தானாக நகர்த்துவதற்கு (திட்டம் 1 போல) அல்லது உரையை உருட்டுவதற்கு (திட்டங்கள் 2 மற்றும் 3) பதிலாக, இந்த திட்டம் பலகையை சாய்ப்பதன் மூலம் புள்ளியின் நிலையை கட்டுப்படுத்த உங்களை அனுமதிக்கிறது. தொகுதியின் பின்புறத்தில் உள்ள QMI8658C முடுக்கமானியின் நேரடி அளவீடுகளின் அடிப்படையில் புள்ளி 8×8 RGB காட்சியில் மென்மையாக நகரும்.

இந்த தொடரின் அனைத்து ஆறு திட்டங்களும் ஒரு YouTube வீடியோவில் நிரூபிக்கப்பட்டுள்ளன. அதே வீடியோ இந்த பக்கத்தில் இணைக்கப்பட்டுள்ளது, எனவே பலகை சாயும்போது புள்ளி நேரத்தில் எவ்வாறு நகர்கிறது என்பதை நீங்கள் சரியாகப் பார்க்கலாம். இந்த திட்டத்திற்கான முழுமையான குறியீடு கட்டுரைக்கு கீழே தானாக ஏற்றப்படுகிறது, மேலும் தொகுதிக்கான இணைப்பு விற்பனை இணைப்புகள் குறியீடு பகுதியின் கீழ் தோன்றும்.

ESP32-S3 RGB LED மேட்ரிக்ஸ் தொகுதி கண்ணோட்டம்

இந்த திட்டம் ESP32-S3 RGB LED மேட்ரிக்ஸ் தொகுதியைப் பயன்படுத்துகிறது, இதில் பின்வருவன அடங்கும்:

  • ESP32-S3 மைக்ரோகண்ட்ரோலர் Wi-Fi மற்றும் ப்ளூடூத் உடன்
  • 8×8 RGB LED மேட்ரிக்ஸ் (64 தனித்தனியாக முகவரியிடக்கூடிய LEDகள்)
  • QMI8658C முடுக்கமானி சாய்வு மற்றும் இயக்க கண்டறிதலுக்காக பின்புறத்தில்
  • USB போர்ட் நிரலாக்கம் மற்றும் மின்சக்திக்காக
  • பூட் / ரீசெட் பொத்தான்கள்
  • பயன்படுத்தக்கூடிய GPIO பின்கள் எதிர்கால விரிவாக்கத்திற்காக

QMI8658C சென்சார் X, Y, மற்றும் Z முடுக்கம் மற்றும் திசை மதிப்புகளைப் படிக்கிறது, இது பலகை எவ்வாறு சாய்ந்துள்ளது என்பதன் அடிப்படையில் புள்ளியை மேல்/கீழ்/இடது/வலது நகர்த்த அனுமதிக்கிறது.:contentReference[oaicite:0]{index=0}

வீடியோவில் உள்ளடக்கப்பட்ட திட்டங்கள் (நேர முத்திரைகள்)

  • 00:00 – அறிமுகம்
  • 02:01 – ESP32 பலகைகளை நிறுவுதல்
  • 03:32 – நூலகங்களை நிறுவுதல்
  • 05:32 – திட்டம் 1: நகரும் புள்ளி
  • 11:11 – திட்டம் 2: உரை உருள்
  • 12:59 – திட்டம் 3: HTTP உரை
  • 16:41 – திட்டம் 4: சாய்வு புள்ளி (இந்த திட்டம்)
  • 18:55 – திட்டம் 5: அம்பு மேல்
  • 20:02 – திட்டம் 6: இலக்கு விளையாட்டு

வீடியோவில் சாய்வு ஆர்ப்பாட்டத்தைப் பார்ப்பது மிகவும் பரிந்துரைக்கப்படுகிறது, ஏனெனில் புள்ளி பலகையின் திசைக்கு எவ்வாறு மென்மையாக செயல்படுகிறது என்பதை நீங்கள் பார்க்கலாம்.:contentReference[oaicite:1]{index=1}

Arduino IDE இல் ESP32 பலகைகளை நிறுவுதல்

நீங்கள் முந்தைய திட்டத்தை முடித்திருந்தால், பலகை ஆதரவு ஏற்கனவே நிறுவப்பட்டுள்ளது. இல்லையெனில், இந்த படிகளைப் பின்பற்றவும்:

  1. File > Preferences திறக்கவும் → ESP32 பலகைகள் URL ஐ சேர்க்கவும்.
  2. Tools > Board > Boards Manager… க்குச் சென்று ESP32 ஐ நிறுவவும்.
  3. Tools > Board இன் கீழ் உங்கள் ESP32-S3 பலகையைத் தேர்ந்தெடுக்கவும்.
  4. Tools > Port இன் கீழ் சரியான COM போர்ட்டைத் தேர்ந்தெடுக்கவும்.

தேவையான நூலகங்களை நிறுவுதல்

இந்த திட்டத்திற்கு பின்வரும் நூலகங்கள் தேவை:

  • Adafruit NeoMatrix
  • Adafruit NeoPixel
  • Adafruit GFX Library
  • QMI8658 (இயக்க உணரி)

நூலக மேலாளரில் அவற்றை நிறுவவும்:

  1. Sketch > Include Library > Manage Libraries… திறக்கவும்.
  2. Adafruit NeoMatrix ஐத் தேடவும் → நிறுவவும்.
  3. Adafruit GFX மற்றும் Adafruit NeoPixel தானியங்கி நிறுவலை அனுமதிக்கவும்.
  4. பட்டியலிடப்பட்ட ஆசிரியரால் QMI8658 ஐத் தேடவும் → நிறுவவும்.:contentReference[oaicite:2]{index=2}

திட்டம் 4 எவ்வாறு செயல்படுகிறது

QMI8658C சென்சார் X, Y, மற்றும் Z அச்சுகளில் தொடர்ந்து முடுக்கம் தரவை வழங்குகிறது. இந்த திட்டத்திற்கு, நாங்கள் X மற்றும் Y அச்சுகளை மட்டுமே பயன்படுத்துகிறோம்:

  • புள்ளியை இடது அல்லது வலது எவ்வளவு தூரம் நகர்த்துவது (X அச்சு)
  • புள்ளியை மேல் அல்லது கீழ் எவ்வளவு தூரம் நகர்த்துவது (Y அச்சு)

சென்சார் மதிப்புகள் 0 முதல் 7 வரையிலான ஒருங்கிணைப்பு வரம்பில் (8×8 LED மேட்ரிக்ஸுக்கு) வரைபடமாக்கப்படுகின்றன. புள்ளி நிலை வினாடிக்கு பல முறை புதுப்பிக்கப்படுகிறது, இது தொகுதியை சாய்க்கும்போது மென்மையான சறுக்கல் விளைவை அளிக்கிறது.:contentReference[oaicite:3]{index=3}

திட்டம் 4 – குறியீடு அமைப்புகள் (சாய்வு புள்ளி)

திட்டத்தின் குறியீட்டின் மேற்புறத்தில் காணப்படும் பயனர் திருத்தக்கூடிய அமைப்புகள் கீழே உள்ளன. முழுமையான ஸ்கெட்ச் கட்டுரைக்கு கீழே தானாக தோன்றும்.

மேட்ரிக்ஸ் பின் மற்றும் அளவு


// 8×8 RGB மேட்ரிக்ஸ் உள்ளமைவு
const int MATRIX_PIN    = 14;   // இந்த பலகைக்கு நிலையான பின்
const int MATRIX_WIDTH  = 8;
const int MATRIX_HEIGHT = 8;

MATRIX_PIN ஐ 14 இல் விடவும். இது பலகையில் உள்ள மேட்ரிக்ஸுடன் கடினமாக இணைக்கப்பட்டுள்ளது.

பிரகாசம்


// ஒட்டுமொத்த பிரகாசம் (0–255)
uint8_t matrixBrightness = 40;

தேவைப்பட்டால் அதிகரிக்கவும், ஆனால் நெருக்கமாகப் பார்க்கும்போது தீவிர பிரகாசத்தைத் தவிர்க்கவும்.

புள்ளி நிறம்


// புள்ளி நிறம் (R, G, B)
uint8_t dotRed   = 0;
uint8_t dotGreen = 200;   // வெளிர் பச்சை (இயல்புநிலை)
uint8_t dotBlue  = 0;

எந்த நிறத்தையும் உருவாக்க இந்த மதிப்புகளை மாற்றவும். எடுத்துக்காட்டுகள்:

  • சிவப்பு: (255, 0, 0)
  • மஞ்சள்: (255, 255, 0)
  • வெள்ளை: (255, 255, 255)

இயக்க உணர்திறன்

தீவிர தாவல்களைத் தடுக்க, முடுக்கமானி மதிப்புகள் பொதுவாக கிளாம்ப் செய்யப்படுகின்றன அல்லது அளவிடப்படுகின்றன. ஒரு பொதுவான அமைப்பு இப்படி இருக்கும்:


// சாய்வு இயக்கத்தை எவ்வளவு ஆக்கிரமிப்பாக பாதிக்கிறது
float sensitivity = 4.0f;   // பெரியது = திரையில் வேகமான இயக்கம்

புள்ளி மிக மெதுவாக நகர்ந்தால் → மதிப்பை அதிகரிக்கவும். புள்ளி மிக திடீரென நகர்ந்தால் → அதைக் குறைக்கவும்.

புதுப்பிப்பு வேகம் (புதுப்பிப்பு விகிதம்)

இயக்கத்தை மென்மையாக்க புதுப்பிப்புகளுக்கு இடையே ஒரு சிறிய தாமதத்தை நீங்கள் சேர்க்கலாம்:


// நிலை புதுப்பிப்புகளுக்கு இடையே தாமதம் (மி.நி)
int refreshDelayMs = 20;   // குறைவாக இருந்தால் வேகமான மற்றும் மென்மையான பதில்

10–30 மி.நி இடையே உள்ள மதிப்புகள் மிகவும் பதிலளிக்கக்கூடியதாக உணர்கின்றன.

சுருக்கம்

திட்டம் 4 ESP32-S3’ன் உள்ளமைக்கப்பட்ட QMI8658C முடுக்கமானியை உயிர்ப்பிக்கிறது, இது உடல் இயக்கத்துடன் LED மேட்ரிக்ஸை கட்டுப்படுத்த உங்களை அனுமதிக்கிறது. பலகையின் ஒரு சிறிய சாய்வு புள்ளியை அதே திசையில் நகர்த்துகிறது, இந்த திட்டத்தை மேலும் மேம்பட்ட “Arrow Up” மற்றும் “Target Game” திட்டங்களுக்கு ஒரு சிறந்த படிக்கல்லாக ஆக்குகிறது.

முழு Tilt Dot ஸ்கெட்ச் இந்த கட்டுரைக்கு கீழே (தானாக) ஏற்றப்படுகிறது. சிறந்த புரிதலுக்கு, வீடியோவில் உள்ள சாய்வு நிரூபணத்தைப் பாருங்கள், அங்கு பலகை சுழற்றப்படும்போது புள்ளி எவ்வளவு மென்மையாக நகர்கிறது என்பதை நீங்கள் காணலாம். ESP32-S3 RGB LED மேட்ரிக்ஸ் தொகுதியை வாங்குவதற்கான இணைப்புகள் குறியீடு பிரிவின் கீழ் சேர்க்கப்பட்டுள்ளன.

படங்கள்

ESP32 S3 Matrix
ESP32 S3 Matrix
ESP32 S3 Matrix pin out
ESP32 S3 Matrix pin out
ESP32-S3_RGB_8x8_matrix-3
ESP32-S3_RGB_8x8_matrix-3
ESP32 S3 Matrix displaying rainbow heart
ESP32 S3 Matrix displaying rainbow heart
ESP32-S3_RGB_8x8_matrix1
ESP32-S3_RGB_8x8_matrix1
ESP32-S3_RGB_8x8_matrix-2
ESP32-S3_RGB_8x8_matrix-2

This tutorial is part of: ESP32-S3 RGB LED மேட்ரிக்ஸ்

Please view this page in English if the code is not visible. We’re sorry for the inconvenience.
802-ESP32-S3 RGB LED Matrix Project 4 - Tilt dot
மொழி: C++
/* 
  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);
}

நீங்கள் தேவைப்படும் எண்ணங்கள்

வளங்கள் மற்றும் மேற்கோள்கள்

கோப்புகள்📁

பிரிட்சிங் கோப்பு

சம்பந்தப்பட்ட அமேசான் தயாரிப்புகள்

சம்பந்தப்பட்ட eBay பட்டியல்கள்

சம்பந்தப்பட்ட அலி எக்ஸ்பிரஸ் தயாரிப்புகள்

டேக்

ESP32-S3 MatrixESP32-S3 RGB LED Matrix
Search Code

சமீபத்திய பயிற்சிகள்

யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
யூடியூப் தலையணி
மேலும் காண்க