שלט רחוק הניתן לפריצה למיקרוקר ZenWheels: 7 שלבים

2024 מְחַבֵּר: John Day | [email protected]. שונה לאחרונה: 2024-01-30 09:13

במדריך זה אנו הולכים לבנות שלט רחוק בהתאמה אישית למיקרו -מכונית ZenWheels. מכונית המיקרו ZenWheels היא מכונית צעצוע בגודל 5 סנטימטרים הניתנת לשליטה באמצעות אפליקציית אנדרואיד או אייפון. אני הולך להראות לך כיצד להנדס לאחור את אפליקציית האנדרואיד כדי לברר על פרוטוקול התקשורת וכיצד תוכל לבנות שלט רחוק באמצעות ארדואינו וג'ירוסקופ.

שלב 1: רכיבים וכלים

חלקים:

1. המיקרו -מכונית ZenWheels

2. Arduino pro mini 328p

3. לוח לחם

4. ג'ירוסקופ MPU6050

5. מקור חשמל <= 5 וולט (סוללה כלשהי שנוכל לחבר ללוח הלחם)

6. כבלי מגשר בצורת U (אופציונלי). השתמשתי בכבלי המגשר האלה מכיוון שהם נראים טוב יותר על לוח הלחם. במקום זאת ניתן להשתמש בכבלי מגשר רגילים

7. מודול בלוטות 'HC-05 (עם כפתור לכניסה למצב AT)

כלים:

1. מתאם USB FTDI טורי FT232RL לתכנות ה- Arduino pro mini

2. Arduino IDE

3. טלפון אנדרואיד

4. Android Studio [אופציונלי]

שלב 2: הנדסה הפוכה יישום אנדרואיד ZenWheels [אופציונלי]

נדרש ידע מסוים ב- Java ו- Android כדי להבין את החלק הזה.

מטרת הפרויקט היא לשלוט על המיקרו -מכונית באמצעות ג'ירוסקופ. לשם כך עלינו לברר מידע נוסף על תקשורת ה- Bluetooth בין הצעצוע הזה לאפליקציית האנדרואיד.

בשלב זה אסביר כיצד להנדס לאחור את פרוטוקול התקשורת בין המיקרו -מכשיר לאפליקציית האנדרואיד. אם אתה רק רוצה לבנות את השלט זה לא הכרחי. אחת הדרכים לגלות את הפרוטוקול היא להסתכל על קוד המקור. הממ אבל זה לא פשוט קדימה, יישומי אנדרואיד נאספים ואפשר להתקין את ה- APK באמצעות Google Play.

אז הכנתי מדריך בסיסי לכך:

1. הורד את ה- APK. ערכת חבילות אנדרואיד (בקיצור APK) היא פורמט קובץ החבילה המשמש את מערכת ההפעלה אנדרואיד להפצה והתקנה של אפליקציות לנייד

תחילה חפש את האפליקציה בחנות Google Play, במקרה שלנו חפש "zenwheels" ותקבל את הקישור לאפליקציה

לאחר מכן חפש בגוגל "הורדת APK מקוונת" והשתמש באחד כדי להוריד את ה- APK. בדרך כלל הם יבקשו את קישור האפליקציה (זה שקיבלנו קודם לכן), ואז נלחץ על כפתור הורדה ונשמור אותו במחשב שלנו.

2. פרק את ה- APK. מפענח במצבנו הוא כלי שלוקח את ה- APK ומייצר קוד מקור של Java.

הפתרון הפשוט ביותר הוא להשתמש בפענוח מקוון לביצוע העבודה. חיפשתי בגוגל "מפרק מקוון" ובחרתי https://www.javadecompilers.com/. אתה רק צריך להעלות את ה- APK שקיבלת קודם לכן ו-

לחץ על החילוץ. ואז פשוט תוריד את המקורות.

3. נסה להנדס לאחור מבט על הקוד

כדי לפתוח את הפרויקט צריך עורך טקסט או עדיף IDE (סביבת פיתוח משולבת). ברירת המחדל של IDE לפרויקטים של Android היא Android Studio (https://developer.android.com/studio). לאחר שהתקנת את Android Studio פתח את תיקיית הפרוייקט.

מכיוון שהמכונית שלנו נשלטת על ידי Bluetooth התחלתי את החיפוש שלי בקוד המורכב עם מילת המפתח "bluetooth", מהמקרים שגיליתי ש- "BluetoothSerialService" ניהל את התקשורת. אם מחלקה זו מטפלת בתקשורת, היא חייבת להיות בעלת שיטת פקודה שלח. מסתבר שיש שיטת כתיבה אחת ששולחת נתונים דרך ערוץ ה- Bluetooth:

כתיבת חלל ציבורי (בייט החוצה)

זוהי התחלה טובה, חיפשתי את ה-.write (בשיטה בשימוש ויש מחלקה "ZenWheelsMicrocar" המרחיבה את "BluetoothSerialService" שלנו. מחלקה זו מכילה את רוב ההיגיון של התקשורת שלנו באמצעות Bluetooth. החלק השני של ההיגיון נמצא בבקרים: BaseController ו- StandardController.

ב- BaseController יש לנו אתחול השירות, וגם הגדרות של ערוצי ההיגוי והמצערת, ערוצים הם למעשה קידומות פקודה כדי לציין כי סוג פקודה כלשהו יבוא:

מוגן ZenWheelsMicrocar = חדש ZenWheelsMicrocar (זה, this.btHandler);

יציאות ChannelOutput מוגנות = {new TrimChannelOutput (ZenWheelsMicrocar. STEERING_CHANNEL), TrimChannelOutput חדש (ZenWheelsMicrocar. THROTTLE_CHANNEL)};

ב- StandardController ההיגוי מטופל ב:

ידית חלל ציבורי Steering (TouchEvent touchEvent) {

… this.microcar.setChannel (steeringOutput.channel, steeringOutput.resolveValue ()); }

בניתוח השיטה, לערוץ SteeringOutput.chan יש הערך 129 (ערוץ המשמש לניהול) ו- SteeringOutput.resolveValue () עשוי להיות בעל ערך בין -90 ל -90. ערך הערוץ (129) נשלח ישירות, וערך ההיגוי משתנה על ידי יישום פעולות ביט -סיביות:

private int value_convert_out (int int) פרטי סופי {

שלילי בוליאני = שקר; אם (ערך <0) {שלילי = f6D; } int value2 = value & 63; אם (שלילי) {value return2 | 64; } ערך החזרה 2; }

יש שיטה דומה ב- StandardController שנקראת

ידית חלל ציבורי חנק (TouchEvent touchEvent)

שלב 3: רכיבים

חלקים:

1. Arduino pro mini 328p 2 $

2. לוח לחם

3. ג'ירוסקופ MPU6050 1.2 $

4. מודול 6 פינים מאסטר-עבד HC-05 3 $

5. מארז סוללות 4 x AA עם 4 סוללות

6. כבלי מגשר בצורת U (אופציונלי). השתמשתי בכבלי המגשר האלה מכיוון שהם נראים טוב יותר על לוח הלחם, והנורות נראות יותר כך. אם אין לך כבלים אלה תוכל להחליף אותם בחוטי דופונט.

המחירים לעיל לקוחים מאיביי.

כלים:

1. מתאם USB FTDI טורי FT232RL לתכנת ה- arduino pro mini

2. Arduino IDE

3. Android Studio (אופציונלי אם אתה רוצה להנדס לאחור בעצמך)

שלב 4: הרכבה

ההרכבה פשוטה מאוד מכיוון שאנו עושים זאת על קרש לחם:)

- ראשית אנו ממקמים את הרכיבים שלנו על לוח הלחם: המיקרו -בקר, מודול בלוטות 'וג'ירוסקופ

- חבר את סיכות ה- bluetooth RX ו- TX של HC-05 ל- arduino 10 ו -11 פינים. יש לחבר את הג'ירוסקופ SDA ו- SCL לסיכות ה- Arduino A4 ו- A5

- חבר את סיכות החשמל ל- bluetooth, לג'ירו ולארדואינו. הסיכות צריכות להיות מחוברות ל- + ו- - בצד לוח הלחם

- חיבור אחרון של ספק כוח (בין 3.3V ל -5V) ללוח הלחם, השתמשתי בסוללת תא LiPo אחת קטנה אבל כל אחת תעשה כל עוד היא בטווח ההספק.

אנא בדוק את התמונות למעלה לפרטים נוספים

שלב 5: חבר את Bluetooth HC-05 ל- Microcar

לשם כך תצטרך טלפון אנדרואיד, מודול Bluetooth HC-05 ומתאם FTDI טורי עם חוטים. כמו כן נשתמש ב- Arduino IDE לתקשר עם מודול ה- Bluetooth.

ראשית עלינו לברר את כתובת ה- bluetooth של המיקרו -מכונית:

- אפשר bluetooth בטלפון שלך

- הפעל את המכונית ועבור לקטע ה- Bluetooth בהגדרות שלך ב- Android

- צריך לחפש מכשירים חדשים והתקן כלשהו בשם "Microcar"

- זוג עם מכשיר זה

- ואז כדי לחלץ את ה- Bluetooth של MAC, השתמשתי באפליקציה זו ממסוף Bluetooth Play סידורי של Bluetooth

לאחר התקנת האפליקציה הזו, עבור אל התפריט -> מכשירים ושם תהיה לך רשימה עם כל המכשירים המשויכים ל- Bluetooth. אנו מעוניינים רק שהקוד שמתחת למכרה "מיקרו -קאר" הוא 00: 06: 66: 49: A0: 4B

לאחר מכן חבר את מתאם ה- FTDI למודול ה- Bluetooth. ראשית סיכות VCC ו- GROUND ולאחר מכן FTDI RX ל- Bluetooth TX ו- FTDI TX ל- Bluetooth RX. כמו כן צריך להיות סיכה על מודול ה- Bluetooth שצריך להיות מחובר ל- VCC. בכך, מודול ה- Bluetooth נכנס ל"מצב לתכנות ". במודול שלי יש כפתור שמחבר את ה- VCC לסיכה המיוחדת הזו. כאשר אתה מחבר את ה- FTDI ל- USB זה אמור להיות כשהסיכה מחוברת / כפתור נלחץ בכניסה למצב תכנות מיוחד זה. ה- Bluetooth מאשר את כניסתו למצב פעולה זה על ידי מהבהב לאט כל 2 שניות.

ב- Arduino IDE בחר את היציאה הטורית, ולאחר מכן פתח את הצג הטורי (הן NL והן CR עם קצב שידור 9600). הקלד AT והמודול אמור לאשר באמצעות "אישור".

הקלד "AT+ROLE = 1" כדי להכניס את המודול למצב אב. כדי להתאים למודול bluetooh שלך כתוב: "AT+BIND = 0006, 66, 49A04B", שים לב כיצד "00: 06: 66: 49: A0: 4B" שלנו הופך ל "0006, 66, 49A04B". ובכן, עליך לבצע את אותה השינוי עבור ה- bluetooh MAC שלך.

כעת הפעל את מכונית Zenwheels ואז נתק את ה- FTDI וחבר אותו שוב ללא לחיצה על הכפתור / סיכה מיוחדת מחוברת. כעבור זמן מה הוא אמור להתחבר לרכב ותבחין במכונית שעושה חיבור ספציפי צליל מוצלח.

פתרון תקלות:

- גיליתי שמכל מודולי הבלוטות 'שיש לי, רק זה עם כפתור עובד כמאסטר!

- ודא שהרכב טעון במלואו

- וודא שהמכונית אינה מחוברת לטלפון

- אם ה- Bluetooth נכנס למצב AT (מהבהב לאט) אך הוא אינו מגיב לפקודה וודא שיש לך שני NL & CR, והתנסה גם בשיעורי BAUD אחרים

- בדוק שוב שה- RX מחובר ל- TX ולהיפך

- נסה את ההדרכה הזו

שלב 6: קוד ושימוש

ראשית עליך להוריד ולהתקין שתי ספריות:

1. ספריית MPU6050 לג'ירוסקופ

2. מקור ספריית I2CDev

לאחר מכן הורד והתקן את הספרייה שלי מכאן או העתק אותה מלמטה:

/** * ספריות: * https://github.com/jrowberg/i2cdevlib * https://github.com/jrowberg/i2cdevlib */#include "I2Cdev.h" #include "MPU6050_6Axis_MotionApps20.h" #include "Wire.h "#include" SoftwareSerial.h"

const int MAX_ANGLE = 45;

const byte commandStering = 129; const byte commandSpeed = 130;

אתחול בול = שקר; // set true אם DMP init הצליח

uint8_t mpuIntStatus; // מחזיק בתור סטטוס בפסיקה ממשית מ- MPU uint8_t devStatus; // סטטוס החזרה לאחר כל פעולת מכשיר (0 = הצלחה,! 0 = שגיאה) uint16_t packetSize; // גודל מנות DMP צפוי (ברירת המחדל היא 42 בתים) uint16_t fifoCount; // ספירת כל הבייטים הנמצאים כעת ב- FIFO uint8_t fifoBuffer [64]; // מאגר אחסון FIFO Quaternion q; // [w, x, y, z] מיכל הרבעון VectorFloat gravity; // [x, y, z] צף וקטור הכבידה ypr [3]; // [yaw, pitch, roll] מיכל yaw/pitch/roll ו- gravity וקטור נדיף bool mpuInterrupt = false; // מציין אם סיכת ההפרעה של MPU עלתה גבוה

unsPrintTime long unsrigned long, lastMoveTime = 0;

תוכנת Serial BTserial (10, 11);

MPU6050 mpu;

הגדרת חלל ()

{Serial.begin (9600); BTserial.begin (38400); Serial.println ("התוכנית התחילה"); אתחול = initializeGyroscope (); }

לולאת חלל () {

אם (! אתחול) {return; } mpuInterrupt = false; mpuIntStatus = mpu.getIntStatus (); fifoCount = mpu.getFIFOCount (); if (hasFifoOverflown (mpuIntStatus, fifoCount)) {mpu.resetFIFO (); לַחֲזוֹר; } if (mpuIntStatus & 0x02) {while (fifoCount <packetSize) {fifoCount = mpu.getFIFOCount (); } mpu.getFIFOBytes (fifoBuffer, packetSize); fifoCount -= packetSize; mpu.dmpGetQuaternion (& q, fifoBuffer); mpu.dmpGetGravity (& כוח הכבידה, & q); mpu.dmpGetYawPitchRoll (ypr, & q, & כוח הכבידה); לנווט (ypr [0] * 180/M_PI, ypr [1] * 180/M_PI, ypr [2] * 180/M_PI); }}

/*

* מקבל זווית מ 0 עד 180 כאשר 0 הוא מקסימום שמאל ו 180 הוא מקסימום ימין * מקבל מהירות מ -90 עד 90 כאשר -90 הוא מקסימום לאחור ו 90 הוא מקסימום קדימה */ מהלך חלל ZwheelsCar (זווית בתים, מהירות אינט) {if (millis () - lastMoveTime = 90) {resultAngle = מפה (זווית, 91, 180, 1, 60); } אחרת אם (זווית 0) {resultSpeed = מפה (מהירות, 0, 90, 0, 60); } אחרת אם (מהירות <0) {resultSpeed = map (מהירות, 0, -90, 120, 60); } Serial.print ("actualAngle ="); Serial.print (זווית); Serial.print (";"); Serial.print ("actualSpeed ="); Serial.print (resultSpeed); Serial.println (";"); BTserial.write (commandStering); BTserial.write (resultAngle); BTserial.write (commandSpeed); BTserial.write ((בייט) resultSpeed); lastMoveTime = millis (); }

היגוי חלל (int x, int y, int z)

{x = אילוץ (x, -1 * MAX_ANGLE, MAX_ANGLE); y = אילוץ (y, -1 * MAX_ANGLE, MAX_ANGLE); z = אילוץ (z, -MAX_ANGLE, MAX_ANGLE); זווית int = מפה (y, -MAX_ANGLE, MAX_ANGLE, 0, 180); מהירות int = מפה (z, -MAX_ANGLE, MAX_ANGLE, 90, -90); printDebug (x, y, z, זווית, מהירות); moveZwheelsCar (זווית, מהירות); }

void printDebug (int x, int y, int z, int angle, int speed)

{if (millis () - lastPrintTime <1000) {return; } Serial.print ("z ="); Serial.print (x); Serial.print (";"); Serial.print ("y ="); Serial.print (y); Serial.print (";"); Serial.print ("z ="); Serial.print (z); Serial.print (";"); Serial.print ("angle ="); Serial.print (זווית); Serial.print (";"); Serial.print ("speed ="); Serial.print (מהירות); Serial.println (";"); lastPrintTime = millis (); }

בול לאתחל גירוסקופ ()

{Wire.begin (); mpu.initialize (); Serial.println (mpu.testConnection ()? F ("חיבור MPU6050 מוצלח"): F ("חיבור MPU6050 נכשל")); devStatus = mpu.dmpInitialize (); mpu.setXGyroOffset (220); mpu.setYGyroOffset (76); mpu.setZGyroOffset (-85); mpu.setZAccelOffset (1788); if (devStatus! = 0) {Serial.print (F ("אתחול DMP נכשל (קוד")); Serial.println (devStatus); החזר false;} mpu.setDMPEnabled (true); Serial.println (F ("הפעלת זיהוי הפרעות (Arduino interrupt extern 0)… ")); attachInterrupt (0, dmpDataReady, RISING); mpuIntStatus = mpu.getIntStatus (); Serial.println (F (" DMP מוכן! מחכה להפרעה ראשונה … ")); packetSize = mpu.dmpGetFIFOPacketSize (); החזר נכון;}

void dmpDataReady ()

{mpuInterrupt = true; }

boolean hasFifoOverflown (int mpuIntStatus, int fifoCount)

{return mpuIntStatus & 0x10 || fifoCount == 1024; }

העלה את הקוד באמצעות מתאם FTDI לארדואינו ולאחר מכן חבר את הסוללות.

שימוש בשלט:

לאחר שהארדואינו מופעל, הפעל גם את המכונית. מודול HC-05 אמור להתחבר לרכב, כאשר זה יקרה המכונית תשמיע צליל. אם זה לא עובד אנא בדוק את השלב הקודם ואת סעיף פתרון הבעיות.

אם אתה נוטה את לוח הלחם קדימה המכונית צריכה לנוע קדימה, ימינה והמכונית צריכה לנוע ימינה. הוא גם מבצע תנועות הדרגתיות יותר כמו נטייה קצת קדימה וקצת שמאלה במקרה זה המכונית הייתה נוסעת לאט שמאלה.

אם המכונית נוסעת בדרך אחרת כאשר אתה נוטה את לוח הלחם תחזיק תחילה את לוח הלחם לכיוונים שונים.

איך זה עובד:

הסקיצה מקבלת את קואורדינטות הג'ירוסקופ כל 100 אלפיות השנייה, מבצעת חישובים ולאחר מכן מעבירה באמצעות בלוטות את הפקודות של המכונית. ראשית יש שיטת "היגוי" הנקראת בזוויות x, y ו- z הגולמיות. שיטה זו הופכת את ההיגוי בין 0 ל -180 מעלות והתאוצה בין -90 ל -90. שיטה זו קוראת

void moveZwheelsCar (זווית בתים, מהירות אינט) הממיר את ההיגוי והתאוצה למפרטי ZenWheels ולאחר מכן מעביר את הפקודות באמצעות בלוטות '.

הסיבה שעשיתי את השינוי בשני שלבים היא שימוש חוזר. אם אצטרך להתאים את הסקיצה הזו לשלט רחוק במכשיר אחר הייתי מתחיל משיטת הבסיס "היגוי" שכבר ממפה את המהירות וההיגוי לכמה ערכים שימושיים.

שלב 7: חלופות

חלופה ל"הנדסה הפוכה ". דיברתי על איך להנדס את הפרויקט על ידי התחלת אפליקציית האנדרואיד. אבל יש אלטרנטיבה לכך שתוכל להגדיר עבד FTDI + בלוטות סדרתי (HC-05 רגיל מבלי לציין את הגדרות האב). לאחר מכן, מאפליקציית ZenWheels התחבר ל- HC-05 במקום ל- "מיקרו קאר".

כדי לפענח את הפקודות יהיה עליך להחזיק את ההגה במיקום כלשהו, ולאחר מכן באמצעות סקריפט פייתון לנתח את התקשורת הטורית. אני מציע סקריפט פייתון מכיוון שיש תווים שאינם ניתנים להדפסה ו- Arduino IDE זה לא מתאים לזה. תבחין שאם אתה מחזיק את ההגה במיקום אחד האפליקציה תשדר באופן קבוע את אותם שני בתים. אם תשנה את מיקום הגלגל, בית האגרוף יישאר זהה השני ישתנה. לאחר ניסויים רבים אתה יכול להמציא את אלגוריתם ההיגוי, ואז מצערת הנדסה לאחור וכו '.

חלופה לשלט מבוסס הארדואינו תהיה שלט RaspberryPi. לפטל הפאי יש מודול בלוטות 'מוטבע, שאין כאבים להתקנה במצב "מאסטר" וספריית הבלוטות' של פייתון פועלת כמו קסם. כמו כן, אפשריים עוד כמה פרויקטים מעניינים כמו שליטה במכונית באמצעות הד Alexa:)

אני מקווה שנהניתם מהפרויקט אנא השאירו הערות למטה!