IOT123 - TRACKER SOLAR - בקר: 8 שלבים

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

זוהי הרחבה של ה- Instructable

IOT123 - גשש סולארי - TILT/PAN, מסגרת פאנל, LDR MOUNTS RIG. כאן אנו מתרכזים בבקר הסרוווס ובחיישני מיקום השמש. חשוב לציין כי עיצוב זה מניח כי 2 MCUs יועסקו: אחד (3.3V 8mHz Arduino Pro Mini) עבור הגשש הסולארי ואחד MCU עצמאי לחיישנים/שחקנים שלך.

זוהי גרסה 0.3

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

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

מה זה כולל:

1. השתמש ב- LDRs מהמדריך המקורי כדי לחוש את המיקום המשוער של השמשות.
2. העבר את הסרווואים מול השמש.
3. אפשרויות לרגישות התנועות.
4. אפשרויות לגודל המדרגה בעת מעבר לשמש.
5. אפשרויות לאילוצים הזוויתיים המשמשים את סרוווס.
6. אפשרויות לעיכוב התנועות.

7. ממשק I2C להגדרת/קבלת ערכים בין מרכזי MCU.

8. שינה עמוקה בין תנועות.

מה זה לא כולל (ויטופלו ככל שיותר זמן):

1. שימוש בחשמל רק בשעות היום.
2. זוכרים את עמדת השחר ויוצאים לשם עם כיבוי דמדומים.
3. הסרת הרגולטור מה- MCU.
4. השבתת הנורות (LED) ב- MCU.
5. ניתוב מחדש של הכוח באמצעות VCC ולא RAW.
6. מתן דרכים לעקיפת הבעיה להבהב ללא הספק מוסדר מממיר ה- TTL הטורי.
7. צג מתח סוללה.

הִיסטוֹרִיָה

20 בדצמבר 2017 V0.1 CODE

הגרסה הראשונית עוקבת אחר מקור האור, תמיד דולקת, ללא טעינה

7 בינואר, 2018 V0.2 CODE

• שינויי חומרה

  • הוסף סיכות I2C
  • הוסף מתג ל- GND של סרוו
  • תווית מודפסת על גבי קופסת בקר

• שינויי תוכנה

  • קרא תצורה מ- EEPROM
  • תמיכה באוטובוס I2C כעבד ל- MCU אחר (3.3V)
  • הגדר תצורה באמצעות I2C
  • הגדר מופעל באמצעות I2C
  • קבל תצורה באמצעות I2C
  • קבל נכסי זמן ריצה באמצעות I2C (מופעל כעת ועוצמת האור הנוכחית)
  • הסר רישום סדרתי (זה השפיע על ערכי I2C)

19 בינואר 2018 V0.3 CODE

• חוּמרָה

  התווית עודכנה. מתג משמש כעת לבחירת מצב CONFIG או TRACK

• תוֹכנָה

  • I2C משמש רק לתצורה
  • הבקר ממתין 5 שניות לפני אתחול המעקב, מאפשר הזזת ידיים
  • כדי להשתמש בתצורת I2C, SPDT חייב להיות ב- CONFIG כמגפי יחידה
  • בין תנועת המעקב, היחידה נמצאת במצב שינה עמוק לערך התצורה SLEEP MINUTES (ברירת מחדל 20 דקות).

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

כעת קיימת רשימה מלאה של חומרים ומקורות.

1. חלקים מודפסים בתלת מימד.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 מתוך 4 x 6 ס"מ אב טיפוס כפול צד PCB מעגל מודפס אוניברסלי (לחתוך לשניים)
4. כותרת זכר אחת של 40P (לחתוך לפי מידה).
5. כותרת נקבה אחת של 40P (לחתוך לפי מידה).
6. 4 כניסות 10K 1/4W.
7. חוט חיבור.
8. הלחמה וברזל.
9. 20 ברגים עם ראש מחבת נירוסטה 4G x 6 מ"מ.
10. 4 ברגים כפולים על 4 x 6 מ"מ נירוסטה שהובילו.

11. סוללת מחזיק LiPo חד פעמית 3.7V (מסתיימת במחברי דופונט 2P).

12. 1 כותרת זווית ישרה זווית ישרה
13. מתג SPDT כבוי 3 פינים בגובה 2.54 מ"מ
14. דבק ציאנואקרילט חזק
15. מחברי Dupont כותרת 1P נקבה (אחד כחול, ירוק אחד).

שלב 2: הרכבת המעגל

במעגל אין כיום מעגל מחלק המתח (מד וולט).

1. חותכים את מעגל המודפס האוניברסלי המודפס האוניברסלי של הצד השני בגודל 4x6 ס"מ לחצי על הציר הארוך.

2. חותכים את הכותרת הגברית 40P לחתיכות:

   1. 2 הנחה על 12P
   2. 3 הנחה על 3P
   3. 6 הנחה על 2P.

3. חותכים את הכותרת הנקבה 40P לחתיכות:

   1. 2 הנחה על 12P
   2. 1 הנחה על 6P
4. הלחמה 2 כבוי 12 כותרת נקבה כפי שמוצג.
5. הדבק את המרווח שהוסר מכותרת זכר 3P (נוסף) על החלק התחתון של מתג SPDT בעזרת דבק ציאנואקרילט
6. בצד השני מקום ואז הלחמה 6 off 2P, 2 off 3Pmale כותרת ומתג SPDT כפי שמוצג.
7. הלחמה 4 נגדים של 10K (A, B, C, D שחור) באמצעות הובלה לכותרת סיכות GND (מספר 2 שחור) ולסיכות A0 - A3 (#5, #6, #7, #8) ואז דרך חור (צהוב) כפי שמוצג (3 תמונות + דיאגרמה אחת).
8. עקוב אחר 3.3V מ- LDR PINS הלחמת PINS #4, #6, #8, #10 וברג חור לפין VCC של כותרת נקבה (ירוק).
9. עקוב אחר 3.3V בצד הכותרת הנשית כפי שמוצג (הלחמה אדומה) לפינים מספר 1, #12, #15.
10. 3.3V דרך חור, פין כותרת RAW בצד אחד מולחם (אדום).
11. עקוב אחר חיבור כתום מ- PIN #11 דרך חור להלחמה סיכה נקבה בצד השני כפי שמוצג.
12. עקוב אחר הלחמת חיבור כחול מהמספר 20 ל- #30 וממספר 31 עד #13 ו- #16.
13. הלחמה PIN כותרת נקבה מספר 11 עד קוד כותרת זכר מספר 11 דרך חור.
14. הכן 2 מחבר דופונט באורך 30 מ"מ עם כותרת 1P נקבה (אחד כחול, ירוק אחד). רצו ופח קצה אחר.
15. חוט Dupont כחול הלחמה למספר 28; חוט דופונט ירוק הלחמה למספר 29.
16. בצד העליון של ה- Arduino תקן את הכותרת הנשית 6P ואז הלחמה.

17. בחלקו העליון של ה- Arduino תקן את הכותרת הנקבה 2P בזווית ישרה int #29 ו- #30 ואז הלחמה.

18. בצד התחתון של Arduino לתקן את 2 מ 12P ו 1 off 3P סיכות זכר ואז הלחמה.
19. הכנס סיכות 12P זכר Arduino לכותרות נקבות PCB 12P.

שלב 3: מהבהב ה- MCU

ה- Arduino Pro Mini מהבהב בנוחות באמצעות ממיר USB FTDI232 ל- TTL באמצעות הכותרת הנשית 6P. עיין בתמונה למעלה ליישור של 2 הלוחות.

ודא שהגדרת 3.3V נבחרה ב- FTDI232 שלך. בצע את ההוראות כאן באמצעות הקוד שלהלן (השתמש בקישור ל- GIST).

יש להתקין את ספריית ה- lowpower (המצורפת ו-

לאחר התקנת לוח ה- Arduino Pro Mini + PCB במארז עדיין ניתן להבהב כאשר סיכות הכותרת נחשפות. פשוט נתק את יחידת הבקר ממסגרת הלוח וחושפת את הכותרת.

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

/*

* שונה מהקוד

* מאת מתיאס לרוי

*

* שינויים V0.2

** I2C SET GET

** EEPROM SET GET

** הסר פלט סדרתי - I2C מושפע

** הפעלה/השבתה של מעקב

** העבר שירותים לגבולות באמצעות I2C

** קרא את עוצמת הממוצע הנוכחי ב- I2C

* שינויים V0.3

** מתג לשני מצבים - TRACK (NO I2C) וקונפיגור (USES I2C)

** שינה בשיטת מסלול (דיוק נמוך מאוד בגלל 8 נתחים שניים)

** ניתוק/הצמדת שירותים על שינה/התעוררות (טרנזיסטור בשימוש באופן סופי)

** הסר עמדה ראשונית ניתנת להגדרה (מיותר)

** הסר שניות ערות ניתנות להגדרה (מיותר)

** הסר הופעה ניתנת לביטול/השבתה (מיותרת)

** הסר מסלול הגדרה מופעל (השתמש במתג חומרה)

** הסר מתח מתח - ישתמש ברכיב I2C נפרד

** הוסף רישום סידורי כאשר לא משתמשים ב- I2C

*/

#לִכלוֹל

#לִכלוֹל

#לִכלוֹל

#לִכלוֹל

#לִכלוֹל

#הגדר EEPROM_VERSION1

#defineI2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#הגדר PIN_LDR_BR A3

#definePIN_LDR_BL A2

#הגדר PIN_SERVO_V11

#הגדר PIN_SERVO_H5

#defineIDX_I2C_ADDR0

#להגדיר IDX_V_ANGLE_MIN1

#להגדיר IDX_V_ANGLE_MAX2

#defineIDX_V_SENSITIVITY3

#להגדיר IDX_V_STEP4

#להגדיר IDX_H_ANGLE_MIN5

#להגדיר IDX_H_ANGLE_MAX6

#להגדיר IDX_H_SENSITIVITY7

#להגדיר IDX_H_STEP8

#להגדיר IDX_SLEEP_MINUTES9

#להגדיר IDX_V_DAWN_ANGLE10

#להגדיר IDX_H_DAWN_ANGLE11

#defineIDX_DAWN_INTENSITY12 // ממוצע של כל LDRS

#defineIDX_DUSK_INTENSITY13 // ממוצע של כל LDRS

#להגדיר IDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15 // ממוצע של כל LDRS - משמש לחישוב IDX_DAWN_INTENSITY אור לא ישיר אווירי

#להגדיר IDX_END_VALUES_GET16

#defineIDX_SIGN_117

#defineIDX_SIGN_218

#defineIDX_SIGN_319

Servo _servoH;

Servo _servoV;

בתים _i2cVals [20] = {10, 10, 170, 20, 5, 10, 170, 20, 5, 20, 40, 10, 30, 40, 0, 0, 0, 0, 0, 0};

int _servoLoopDelay = 10;

int _slowingDelay = 0;

int _angleH = 90;

int _angleV = 90;

int _averageTop = 0;

int _averageRight = 0;

int _averageBottom = 0;

int _averageLeft = 0;

בתים _i2cResponse = 0;

bool _inConfigMode = false;

הגדרת voids ()

{

Serial.begin (115200);

getFromEeprom ();

if (inConfigMode ()) {

Serial.println ("מצב תצורה");

Serial.print ("כתובת I2C:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (ReceiveEvent);

Wire.onRequest (requestEvent);

}אַחֵר{

Serial.println ("מצב מעקב");

עיכוב (5000); // זמן להוציא ידיים מהדרך בעת חיבור הסוללה וכו '.

}

}

voidloop ()

{

getLightValues ();

אם (! _inConfigMode) {

// ToDo: הפעל את מתג הטרנזיסטור

_servoH.attach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

עבור (int i = 0; i <20; i ++) {

אם (i! = 0) {

getLightValues ();

}

moveServos ();

}

עיכוב (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: כבה את מתג הטרנזיסטור

עיכוב (500);

sleepFor ((_ i2cVals [IDX_SLEEP_MINUTES] * 60) / 8);

}

}

// --------------------------------- מצב הנוכחי

boolinConfigMode () {

pinMode (PIN_SERVO_H, INPUT);

_inConfigMode = digitalRead (PIN_SERVO_H) == 1;

החזר _inConfigMode;

}

// --------------------------------- EEPROM

voidgetFromEeprom () {

אם(

EEPROM.read (IDX_SIGN_1)! = 'S' ||

EEPROM.read (IDX_SIGN_2)! = 'T' ||

EEPROM.read (IDX_SIGN_3)! = EEPROM_VERSION

) EEPROM_write_default_configuration ();

EEPROM_read_configuration ();

}

voidEEPROM_write_default_configuration () {

Serial.println ("EEPROM_write_default_configuration");

עבור (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

EEPROM.update (i, _i2cVals );

}

EEPROM.update (IDX_SIGN_1, 'S');

EEPROM.update (IDX_SIGN_2, 'T');

EEPROM.update (IDX_SIGN_3, EEPROM_VERSION);

}

voidEEPROM_read_configuration () {

Serial.println ("EEPROM_read_configuration");

עבור (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

_i2cVals = EEPROM.read (i);

//Serial.println(String(i) + "=" + _i2cVals );

}

}

// --------------------------------- I2C

voidreceiveEvent (int count) {

אם (count == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

אינדקס בתים = Wire.read ();

ערך בתים = Wire.read ();

מתג (cmd) {

case'G ':

אם (אינדקס <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [אינדקס];

}

לשבור;

מקרה 's':

אם (אינדקס <IDX_END_EEPROM_SET) {

_i2cVals [אינדקס] = ערך;

EEPROM.update (אינדקס, _i2cVals [אינדקס]);

}

לשבור;

בְּרִירַת מֶחדָל:

לַחֲזוֹר;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDRs

voidgetLightValues () {

int valueTopLeft = analogRead (PIN_LDR_TL);

int valueTopRight = analogRead (PIN_LDR_TR);

int valueBottomRight = analogRead (PIN_LDR_BR);

int valueBottomLeft = analogRead (PIN_LDR_BL);

_averageTop = (valueTopLeft + valueTopRight) / 2;

_averageRight = (valueTopRight + valueBottomRight) / 2;

_averageBottom = (valueBottomRight + valueBottomLeft) / 2;

_averageLeft = (valueBottomLeft + valueTopLeft) / 2;

int avgIntensity = (valueTopLeft + valueTopRight + valueBottomRight + valueBottomLeft) / 4;

_i2cVals [IDX_CURRENT_INTENSITY] = מפה (avgIntensity, 0, 1024, 0, 255);

}

// --------------------------------- SERVOS

voidmoveServos () {

Serial.println ("moveServos");

if ((_averageLeft-_averageRight)> _ i2cVals [IDX_H_SENSITIVITY] && (_angleH-_i2cVals [IDX_H_STEP])> _ i2cVals [IDX_H_ANGLE_MIN]) {

// ללכת שמאלה

Serial.println ("moveServos הולך שמאלה");

עיכוב (_slowingDelay);

עבור (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH.write (_angleH--);

עיכוב (_servoLoopDelay);

}

}

elseif ((_averageRight-_averageLeft)> _ i2cVals [IDX_H_SENSITIVITY] && (_angleH+_i2cVals [IDX_H_STEP]) <_ i2cVals [IDX_H_ANGLE_MAX]) {

// הולך נכון

Serial.println ("moveServos הולך שמאלה");

עיכוב (_slowingDelay);

עבור (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH.write (_angleH ++);

עיכוב (_servoLoopDelay);

}

}

אחר {

// לא עושה דבר

Serial.println ("moveServos לא עושה כלום");

עיכוב (_slowingDelay);

}

if ((_averageTop-_averageBottom)> _ i2cVals [IDX_V_SENSITIVITY] && (_angleV+_i2cVals [IDX_V_STEP]) <_ i2cVals [IDX_V_ANGLE_MAX]) {

// עולה

Serial.println ("moveServos עולה");

עיכוב (_slowingDelay);

עבור (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV ++);

עיכוב (_servoLoopDelay);

}

}

elseif ((_averageBottom-_averageTop)> _ i2cVals [IDX_V_SENSITIVITY] && (_angleV-_i2cVals [IDX_V_STEP])> _ i2cVals [IDX_V_ANGLE_MIN]) {

// לרדת למטה

Serial.println ("moveServos יורד");

עיכוב (_slowingDelay);

עבור (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV--);

עיכוב (_servoLoopDelay);

}

}

אחר {

Serial.println ("moveServos לא עושה כלום");

עיכוב (_slowingDelay);

}

}

//---------------------------------לִישׁוֹן

voidasleepFor (unsignedint eightSecondSegments) {

Serial.println ("sleepFor");

for (unsignedint sleepCounter = eightSecondSegments; sleepCounter> 0; sleepCounter--)

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

הצג rawtilt_pan_tracker_0.3.ino המתארח אצל ❤ על ידי GitHub

שלב 4: הרכבת מעטפת המעגל

1. ודא ש- Ardiuno Pro Mini מוכנס לכותרות הלוח.
2. הכנס את בסיס קופסת הבקר של SOLAR TRACKER לתוך קירות תיבת הבקר של SOLAR TRACKER והדבק עם 2 ברגים כפולים נירוסטה עם כיבוי עצמי.
3. הכנס את Ardiuno Pro Mini + PCB עם כותרת 6P החורקת לתוך החלל בבסיס תיבת הבקר של SOLAR TRACKER.
4. הכנס את מכסה קופסת הבקר של SOLAR TRACKER לתוך קירות תיבת הבקר של SOLAR TRACKER והדבק עם 2 ברגי נירוסטה עם כיבוי עצמי.
5. הדבק הרכבה למעלה לבסיס מסגרת הפאנל עם 4 ברגים כפולים נירוסטה כפופים ל -4 x 6 מ"מ.

שלב 5: חיבור מוליכי המתקן לבקר

החיבורים הרלוונטיים המוכנים מההוראה הקודמת הם 4 חיבורי 2P LDR ו -2 חיבורי 3P מהשרווסים. מה שהוא זמני עד שהטעינה מוכנה היא הסוללה. השתמש ב- 3.7V LiPo המסתיים בחיבור 2P DuPont לעת עתה.

1. הכנס את חיבורי LDR (ללא קוטביות) מלמעלה:

   1. למעלה מימין
   2. שמאלי עליון
   3. למטה מימין
   4. שמאל תחתון

2. הכנס את חיבורי סרוו (עם חוט האות משמאל) מלמעלה:

   1. אופקי
   2. אֲנָכִי
3. המתן עד לבדיקה: הכנס את כבל החשמל +7.7V DC למעלה למעלה, -למטה.

שלב 6: בדיקת הבקר

כפי שצוין קודם לכן, התוכנה לא עברה אופטימיזציה לזרימת עבודה של טעינה סולארית. עם זאת, ניתן לבדוק ולשפר זאת באמצעות מקורות אור טבעיים (שמש) ולא טבעיים.

כדי לבדוק את המעקב בסביבה מבוקרת ייתכן שיהיה נוח להגדיר את דקות השינה לערך נמוך יותר (ראה שלב הבא).

שלב 7: הגדרת Via I2C באמצעות קלט מסוף

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

1. העלה את הסקריפט הבא ל- D1M WIFI BLOCK (או Wemos D1 Mini).
2. נתק את ה- USB מהמחשב

3. חיבורי PIN: -ve (בקר) => GND (D1M)+ve (בקר) => 3V3 (D1M) SCL (בקר) => D1 (D1M)

   SDA (בקר) => D2 (D1M)

4. סובב את מתג SPDT ל- CONFIG
5. חבר USB למחשב
6. מ- Arduino IDE התחל חלון קונסולה עם יציאת COM הנכונה
7. ודא כי "Newline" ו- "9600 baud" נבחרו
8. הפקודות נכנסות לתיבת הטקסט שלח ולאחר מכן מקש Enter
9. הפקודות הן בפורמט בייט תווים
10. אם הבייט השני (קטע שלישי) אינו כלול 0 (אפס) נשלח על ידי התסריט
11. היזהר באמצעות קלט טורי; בדוק את מה שהזנת לפני הלחיצה על מקש "Enter". אם אתה נעול (למשל שינוי כתובת I2C לערך ששכחת) יהיה עליך להבהב שוב את קושחת הבקר.

הווריאציות הנתמכות בתו הראשון של הפקודה הן:

• E (אפשר מעקב סרוו) שימושי לעצירת תנועה במהלך התצורה. זה קלט באמצעות: E 0
• D (השבת מעקב סרוו) שימושי להפעלת מעקב אוטומטי אם לא אתחול מחדש של המכשיר. זה קלט באמצעות: D 0
• G (קבל ערך תצורה) קורא ערכים מ- EEPROM ו- IN -MEMORY: זוהי קלט באמצעות: G (האינדקס הוא ערכי בתים חוקיים 0 - 13 ו -15)
• S (הגדר ערך EEPROM) קובע ערכים ל- EEPROM הזמינים לאחר אתחול מחדש. זה קלט באמצעות: S (האינדקס הוא ערכי בתים חוקיים 0 - 13, הערך הוא ערכי בתים חוקיים ומשתנים לפי נכס)

הקוד הוא נקודת האמת של האינדקסים, אך הדברים הבאים משמשים כמדריך לערכים/הערות תקפים:

• I2C ADDRESS 0 - כתובת עבד בקר, המאסטר צריך זאת כדי לתקשר עם הבקר (ברירת מחדל 10)
• זווית אנכית מינימלית 1 - גבול תחתון של סרוו אנכי זווית (ברירת מחדל 10, טווח 0 - 180)
• זווית אנכית מקסימלית 2 - גבול סרוו אנכי זווית עליון (ברירת מחדל 170, טווח 0 - 180)
• רגישות ורטיקלית LDR 3 - שולי קריאה אנכיים של LDR (ברירת מחדל 20, טווח 0 - 1024)
• שלב WERTICAL ANGLE STEP 4 - שלבי סרוו אנכיים בזווית בכל התאמה (ברירת מחדל 5, טווח 1 - 20)
• זווית אופקית מינימלית 5 - גבול תחתון של סרוו אופקי זווית (ברירת מחדל 10, טווח 0 - 180)
• זווית אופקית מקסימלית 6 - גבול סרוו אופקי זוויתי גבול (ברירת מחדל 170, טווח 0 - 180)
• רגישות הוריזונטלית LDR 7 - שולי קריאה אופקי LDR (ברירת מחדל 20, טווח 0 - 1024)
• שלב זווית הוריזונטלית 8 - שלבי סרוו אופקיים בזווית בכל התאמה (ברירת מחדל 5, טווח 1 - 20)
• דקות שינה 9 - תקופת השינה המשוערת בין המעקב (ברירת מחדל 20, טווח 1 - 255)
• זווית שמש אנכית 10 - שימוש עתידי - הזווית האנכית שאליה כדאי לחזור כאשר השמש שוקעת
• זווית זריחה הוריזונטלית 11 - שימוש עתידי - הזווית האופקית שאליה כדאי לחזור כאשר השמש שוקעת
• עוצמת השחר 12 - שימוש עתידי - הממוצע המינימלי של כל ה- LDR שמעורר התחלה של מעקב אחר השמש היומית.
• DUSK INTENSITY 13 - שימוש עתידי - הממוצע המינימלי של כל ה- LDR שמעורר סיום של מעקב אחר השמש היומית.
• סיום שווי ערכי EEPROM 14 - ערך שלא נעשה בו שימוש
• עוצמת זרם 15 - האחוז הממוצע הנוכחי של עוצמת האור
• סיום שווי ערכי הזיכרון 16 - ערך שלא נעשה בו שימוש.

לוכד קלט סדרתי (קלט מקלדת בחלון הקונסולה) ומעביר אותו לעבד I2C בתבנית char, byte, byte

#לִכלוֹל

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

בוליאני _newData = false;

const byte _numChars = 32;

char _receivedChars [_numChars]; // מערך לאחסון הנתונים שהתקבלו

הגדרת voids () {

Serial.begin (9600);

Wire.begin (D2, D1);

עיכוב (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

בתים סטטיים ndx = 0;

char endMarker = '\ n';

char rc;

בעוד (Serial.available ()> 0 && _newData == false) {

rc = Serial.read ();

if (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

אם (ndx> = _numChars) {

ndx = _numChars - 1;

}

} אחר {

_receivedChars [ndx] = '\ 0'; // לסיים את המחרוזת

ndx = 0;

_newData = true;

}

}

}

voidparseSendCommands () {

אם (_newData == true) {

constchar delim [2] = "";

אסימון *צ'אר;

אסימון = strtok (_receivedChars, delim);

char cmd = _receivedChars [0];

אינדקס בתים = 0;

ערך בתים = 0;

int i = 0;

while (אסימון! = NULL) {

//Serial.println(token);

i ++;

לעבור (i) {

תיק 1:

אסימון = strtok (NULL, delim);

אינדקס = atoi (אסימון);

לשבור;

מקרה 2:

אסימון = strtok (NULL, delim);

אם (אסימון! = NULL) {

value = atoi (אסימון);

}

לשבור;

בְּרִירַת מֶחדָל:

אסימון = NULL;

}

}

sendCmd (cmd, אינדקס, ערך);

_newData = false;

}

}

voidsendCmd (char cmd, אינדקס בתים, ערך בתים) {

Serial.println ("-----");

Serial.println ("פקודת שליחה:");

Serial.println ("\ t" + מחרוזת (cmd) + "" + מחרוזת (אינדקס) + "" + מחרוזת (ערך));

Serial.println ("-----");

שידור Wire.beginTransmission (I2C_SLAVE_ADDRESS); // לשדר למכשיר

Wire.write (cmd); // שולח צ'ארמה

Wire.write (אינדקס); // שולח בתים אחד

Wire.write (ערך); // שולח בתים אחד

Wire.endTransmission ();

תגובת בתים = 0;

bool hadResponse = false;

אם (cmd == 'G') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

בעוד (Wire.available ()) // העבד עשוי לשלוח פחות מהמתבקש

{

hadResponse = true;

תגובה = Wire.read ();

}

if (hadResponse == true) {

Serial.println ("קבלת תגובה:");

Serial.println (תגובה);

}אַחֵר{

Serial.println ("אין תגובה, בדוק את הכתובת/החיבור");

}

}

}

הצג rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino המתארח אצל ❤ על ידי GitHub

שלב 8: השלבים הבאים

בדוק מדי פעם מחדש אם יש שינויים בתוכנה/חומרה.

שנה את התוכנה/חומרה לדרישותיך.

הגיבו על כל בקשה/אופטימיזציה.