IOT123 - SOLAR TRACKER - CONTROLLER: 8 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:20

ეს არის ინსტრუქციის გაფართოება

IOT123 - SOLAR TRACKER - TILT/PAN, PANEL FRAME, LDR MOUNTS RIG. აქ ჩვენ კონცენტრირებული ვართ სერვოების კონტროლერზე და მზის პოზიციის სენსორებზე. მნიშვნელოვანია აღინიშნოს, რომ ეს დიზაინი ითვალისწინებს 2 MCU– ს გამოყენებას: ერთი (3.3V 8mHz Arduino Pro Mini) მზის ტრეკერისთვის და ერთი დამოუკიდებელი MCU თქვენი სენსორებისთვის/მსახიობებისთვის.

ეს არის 0.3 ვერსია

იმის ნაცვლად, რომ გამოვაქვეყნო ყველა პროექტი სრული კმაყოფილების შემდეგ, მე ვივარჯიშებ უწყვეტ ინტეგრაციასთან და უფრო ხშირად გამოვაქვეყნებ რაღაცას, რაც მოვახდინე იმის შეცვლისას, რაც მე მჭირდება. მე დავწერ კიდევ ერთ ინსტრუქციას ბატარეის დამტენისთვის, _ როდესაც_ კონტროლერის პროგრამული უზრუნველყოფის/ტექნიკის ოპტიმიზაცია დასრულდება. მე აღვნიშნავ, სად არის საჭირო ოპტიმიზაცია, როდესაც ამას გადავდგამთ.

ამ მიდგომის მიზეზის ნაწილი არის კლიენტის კავშირი. თუ თქვენ ხედავთ საჭიროებას ან გაქვთ უკეთესი მიდგომა, გთხოვთ კომენტარი გააკეთოთ, მაგრამ გაითვალისწინეთ, რომ მე არ შემიძლია ყველაფერი მივაწოდო და შესაძლოა არა თქვენთვის სასურველ ვადებში. ვინაიდან ეს განმარტებები ნაკლებად აქტუალური ჩანს, ისინი წაიშლება ამ სტატიიდან.

რას მოიცავს ეს:

1. გამოიყენეთ LDR– ები ორიგინალური ინსტრუქციიდან, რათა იგრძნოთ მზის სავარაუდო მდებარეობა.
2. გადაიტანეთ სერვოები მზისკენ.
3. მოძრაობების მგრძნობელობის პარამეტრები.
4. ნაბიჯის ზომის პარამეტრები მზეზე გადასვლისას.
5. სერვოზე გამოყენებული კუთხის შეზღუდვების პარამეტრები.
6. მოძრაობების შეფერხების ვარიანტები.
7. I2C ინტერფეისი MCU– ებს შორის მნიშვნელობების დასადგენად/მისაღებად.
8. ღრმა ძილი მოძრაობებს შორის.

რასაც ეს არ შეიცავს (და განხილული იქნება როგორც დრო ნებადართულია):

1. ენერგიის მოხმარება მხოლოდ დღის საათებში.
2. ცისკრის პოზიციის გახსენება და შებინდებისას იქ წასვლა.
3. მარეგულირებლის ამოღება MCU– დან.
4. გამორთეთ LED (ები) MCU– ზე.
5. ენერგიის გადამისამართება VCC- ს საშუალებით და არა RAW- ის საშუალებით.
6. USB– დან სერიულ TTL კონვერტორზე რეგულირებადი ენერგიის გარეშე მოციმციმე გამოსავლის უზრუნველყოფა.
7. ბატარეის ძაბვის მონიტორი.

ისტორია

2017 წლის 20 დეკემბერი V0.1 კოდი

პირველადი ვერსია აკონტროლებს სინათლის წყაროს, ყოველთვის ჩართულია, დატენვის გარეშე

7 იანვარი, 2018 V0.2 კოდი

• HARDWARE ცვლილებები

  • დაამატეთ I2C ქინძისთავები
  • დაამატეთ გადამრთველი სერვო GND- ებზე
  • დაბეჭდილი ეტიკეტი საკონტროლო ყუთის ფასციაზე

• პროგრამული ცვლილებები

  • წაიკითხეთ კონფიგურაცია EEPROM– დან
  • I2C ავტობუსის მხარდაჭერა, როგორც სხვა MCU- ს მონა (3.3V)
  • დააყენეთ კონფიგურაცია I2C საშუალებით
  • დაყენება ჩართულია I2C საშუალებით
  • მიიღეთ კონფიგურაცია I2C საშუალებით
  • მიიღეთ გაშვების თვისებები I2C საშუალებით (ამჟამად ჩართულია და სინათლის ამჟამინდელი ინტენსივობა)
  • წაშალეთ სერიული ჟურნალი (ეს იმოქმედა I2C მნიშვნელობებზე)

19 იანვარი, 2018 V0.3 კოდი

• HARDWARE

  ეტიკეტი განახლებულია. ახლა გადამრთველი გამოიყენება კონფიგურაციის ან საჩვენებელი რეჟიმის ასარჩევად

• პროგრამული უზრუნველყოფა

  • I2C გამოიყენება მხოლოდ კონფიგურაციისთვის
  • კონტროლერი ელოდება 5 წამს თვალთვალის დაწყებამდე, იძლევა ხელების გადაადგილების საშუალებას
  • I2C კონფიგურაციის გამოსაყენებლად, SPDT უნდა იყოს CONFIG- ში, როგორც ერთეული ჩექმები
  • მოძრაობის თვალთვალს შორის, მოწყობილობა ღრმა ძილის რეჟიმშია SLEEP MINUTES (ნაგულისხმევი 20 წუთი) კონფიგურაციის მნიშვნელობისთვის.

ნაბიჯი 1: მასალები და ინსტრუმენტები

ახლა არის მასალებისა და წყაროების სრული სია.

1. 3D ბეჭდვის ნაწილები.
2. Arduino Pro Mini 3.3V 8mHz
3. 1 4x6 სმ ორმაგი გვერდითი პროტოტიპი PCB უნივერსალური ნაბეჭდი მიკროსქემის დაფა (უნდა გაიჭრას შუაზე)
4. 1 off 40P მამრობითი header (უნდა შემცირდეს ზომა).
5. 1 off 40P ქალი header (უნდა შემცირდეს ზომა).
6. 4 off 10K 1/4W რესისტორი.
7. დასაკავშირებელი მავთული.
8. Solder და რკინის.
9. 20 off 4G x 6 მმ უჟანგავი ტაფის თავი თვითმმართველობის მოსმენების ხრახნები.
10. 4 off 4G x 6 მმ უჟანგავი საწინააღმდეგო თვითმმართველობის მოსმენების ხრახნები.
11. 1 off 3.7V LiPo ბატარეა და დამჭერი (დამთავრებული 2P dupont კონექტორებში).
12. 1 off 2P მამრობითი მარჯვენა კუთხის სათაური
13. 1 გამორთული SPDT გადამრთველი 3 პინიანი 2.54 მმ მოედანზე
14. ძლიერი ციანოაკრილატის წებო
15. Dupont კონექტორები ქალი 1P სათაურით (1 ლურჯიდან, 1 მწვანედან).

ნაბიჯი 2: წრის შეკრება

წრედს ამჟამად არ აქვს ძაბვის გამყოფი წრე (ვოლტ მეტრი).

1. 4x6 სმ ორმაგი გვერდითი პროტოტიპის PCB უნივერსალური ნაბეჭდი მიკროსქემის დაფა გაჭერით შუაზე გრძელი ღერძის გასწვრივ.

2. 40P მამრობითი სათაური დაჭერით ნაწილებად:

   1. 2 ფასდაკლებით 12P
   2. 3 off 3P
   3. 6 off 2P.

3. 40P ქალი სათაური დაჭერით ნაწილებად:

   1. 2 ფასდაკლებით 12P
   2. 1 ფასდაკლებით 6P
4. Solder 2 off 12Pfemale header როგორც ნაჩვენებია.
5. მიამაგრეთ 3P მამრობითი (დამატებითი) სათაურიდან ამოღებული გამყოფი SPDT გადამრთველის ქვედა მხარეზე ციანოაკრილატის წებოთი
6. მეორე მხარეს შემდეგ შეაერთეთ 6 off 2P, 2 off 3Pmale header და SPDT switch როგორც ნაჩვენებია.
7. შეაერთეთ 4 გამორთული 10K რეზისტორი (A, B, C, D შავი) ტყვიის მეშვეობით GND pin header (#2 შავი) და A0 - A3 header pin (#5, #6, #7, #8) შემდეგ ხვრელში (ყვითელი) როგორც ნაჩვენებია (3 ფოტო + 1 დიაგრამა).
8. მიაკვლიეთ 3.3V LDR PINS- ისგან soldering PINS #4, #6, #8, #10 და ძაფი, თუმცა ხვრელი ყურძნის სათაურში VCC pin (მწვანე).
9. მიჰყევით 3.3 ვ ქალს სათაურის მხარეს, როგორც ნაჩვენებია (წითელი) შედუღების პინზე #1, #12, #15.
10. 3.3V ხვრელის მეშვეობით შედუღებული გვერდით (წითელი) RAW სათაურის PIN #1.
11. მიჰყევით ფორთოხლის კავშირს PIN #11 -დან ხვრელში, რათა შეაერთოთ მდედრი პინი მეორე მხარეს, როგორც ნაჩვენებია.
12. მიაკვლიეთ და შეაერთეთ ლურჯი მავთული #20 -დან #30 -მდე და #31 -დან #13 -მდე და #16 -დან.
13. Solder ქალი სათაურის PIN #11 მამაკაცის სათაურის PIN #11 მეშვეობით ხვრელი.
14. მოამზადეთ 2 დუპონტის კონექტორი 30 მმ სიგრძის მდედრობითი 1P სათაურით (1 ცისფერი, 1 მწვანე). სტრიპტიზი და კალის მეორე ბოლო.
15. შედუღების ლურჯი Dupont მავთულები #28; შეაერთეთ მწვანე დიუპონის მავთული #29 -ზე.
16. Arduino– ს ზედა ნაწილში დააფიქსირეთ 6P ქალი სათაური, შემდეგ შედგით.
17. Arduino– ს ზედა ნაწილში დააფიქსირეთ 2P მარჯვენა კუთხის მდედრის სათაური int #29 და #30, შემდეგ შედგით.
18. Arduino– ს ქვედა ნაწილში დააფიქსირეთ 2 12P და 1 off 3P მამრობითი ქინძისთავები, შემდეგ შეაერთეთ.
19. ჩადეთ Arduino მამრობითი 12P ქინძისთავები PCB 12P ქალის სათაურებში.

ნაბიჯი 3: MCU მოციმციმე

Arduino Pro Mini მოხერხებულად ანათებს FTDI232 USB to TTL გადამყვანის გამოყენებით 6P ქალი სათაურის გამოყენებით. იხილეთ ფოტო ზემოთ, 2 დაფის გასწორებისთვის.

დარწმუნდით, რომ 3.3V პარამეტრი არჩეულია თქვენს FTDI232- ზე. მიჰყევით აქ მითითებებს ქვემოთ მოყვანილი კოდის გამოყენებით (გამოიყენეთ ბმული GIST– ზე).

დაბალი სიმძლავრის ბიბლიოთეკა (მიმაგრებულია და https://github.com/rocketscream/Low-Power) უნდა იყოს დაინსტალირებული.

მას შემდეგ, რაც Arduino Pro Mini + PCB დაინსტალირდება გარსაცმში, ის მაინც შეიძლება აინთოს, რადგან სათაურის ქინძისთავები გამოაშკარავებულია. უბრალოდ გათიშეთ კონტროლერის განყოფილება პანელის ჩარჩოდან, რომელიც ასახავს სათაურს.

Tilt pan მზის ტრეკერი I2C/EEPROM კონფიგურაციით და ძილის ციკლი მოძრაობებს შორის. ძილის ციკლის ხანგრძლივობა მცირდება ხანგრძლივობის მატებასთან ერთად, მაგრამ საკმარისია ამ მიზნით

/*

* შეცვლილია კოდიდან

* მათასი ლეროის მიერ

*

* V0.2 მოდიფიკაციები

** I2C SET GET

** EEPROM SET GET

** სერიული გამოსვლის ამოღება - დაზარალებული I2C

** ჩართვა/გამორთვა თვალყურის დევნება

** გადაადგილება სერვერებზე LIMITS VIA I2C– ით

** წაიკითხეთ მიმდინარე AVG ინტენსიურობა I2C– ით

* V0.3 მოდიფიკაციები

** გადართვა 2 რეჟიმზე - ბილიკი (NO I2C) და კონფიგურაცია (იყენებს I2C)

** დაიძინეთ გზაზე (ძალიან დაბალი სიზუსტით, 8 წამის გამო)

** ძილის/გაღვიძების სერვისების გატანა/მიმაგრება (ტრანზისტორი გამოიყენება ექსკლუზიურად)

** კონფიგურირებადი საწყისი პოზიციის ამოღება (ზედმეტი)

** წაშალეთ კონფიგურირებადი გაღვიძების წამები (შემცირება)

** კონფიგურაციის ამოღება/გამორთვა (შემცირება)

** კონფიგურირებადი ტრეკერის ამოღება ჩართული (გამოიყენეთ მძიმე გადამრთველი)

** ძაბვის მოშორება - გამოიყენებს ცალკე I2C კომპონენტს

** დაამატეთ სერიული ბლოკი, როდესაც არ იყენებთ I2C- ს

*/

#ჩართეთ

#ჩართეთ

#ჩართეთ

#ჩართეთ

#ჩართეთ

#განსაზღვრებაEEPROM_VERSION1

#defineI2C_MSG_IN_SIZE3

#განსაზღვრეთ PIN_LDR_TL A0

#განსაზღვრეთ PIN_LDR_TR A1

#განსაზღვრეთ PIN_LDR_BR A3

#განსაზღვრეთ PIN_LDR_BL A2

#განსაზღვრეთ PIN_SERVO_V11

#განსაზღვრეთ PIN_SERVO_H5

#defineIDX_I2C_ADDR0

#defineIDX_V_ANGLE_MIN1

#defineIDX_V_ANGLE_MAX2

#defineIDX_V_SENSITIVITY3

#defineIDX_V_STEP4

#defineIDX_H_ANGLE_MIN5

#defineIDX_H_ANGLE_MAX6

#defineIDX_H_SENSITIVITY7

#defineIDX_H_STEP8

#defineIDX_SLEEP_MINUTES9

#defineIDX_V_DAWN_ANGLE10

#defineIDX_H_DAWN_ANGLE11

#defineIDX_DAWN_INTENSITY12 // ყველა LDRS- ის საშუალო

#defineIDX_DUSK_INTENSITY13 // ყველა LDRS- ის საშუალო

#defineIDX_END_EEPROM_SET14

#defineIDX_CURRENT_INTENSITY15 // ყველა LDRS- ის საშუალო - გამოიყენება გამოსათვლელად IDX_DAWN_INTENSITY ამბიციური არა -პირდაპირი შუქისათვის

#defineIDX_END_VALUES_GET16

#defineIDX_SIGN_117

#defineIDX_SIGN_218

#defineIDX_SIGN_319

სერვო _ სერვოჰ;

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;

voidsetup ()

{

Serial.begin (115200);

getFromEeprom ();

თუ (inConfigMode ()) {

Serial.println ("კონფიგურაციის რეჟიმი");

Serial.print ("I2C მისამართი:");

Serial.println (_i2cVals [IDX_I2C_ADDR]);

Wire.begin (_i2cVals [IDX_I2C_ADDR]);

Wire.onReceive (ieveEvent);

Wire.onRequest (requestEvent);

} სხვა {

Serial.println ("თვალთვალის რეჟიმი");

დაგვიანება (5000); // დრო, რომ ხელი მოვაშოროთ ბატარეას და ა.

}

}

voidloop ()

{

getLightValues ();

თუ (! _inConfigMode) {

// ToDo: ჩართეთ TRANSISTOR SWITCH

_servoH.atach (PIN_SERVO_H);

_servoV.attach (PIN_SERVO_V);

for (int i = 0; i <20; i ++) {

თუ (მე! = 0) {

getLightValues ();

}

moveServos ();

}

დაგვიანება (500);

_servoH.detach ();

_servoV.detach ();

// ToDo: გამორთეთ TRANSISTOR SWITCH

დაგვიანება (500);

მძინარეFor ((_ _ 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. წაიკითხე (IDX_SIGN_2)! = 'T' ||

EEPROM. წაიკითხე (IDX_SIGN_3)! = EEPROM_VERSION

EEPROM_write_default_configuration ();

EEPROM_read_configuration ();

}

voidEEPROM_write_default_configuration () {

Serial.println ("EEPROM_write_default_configuration");

for (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

EEPROM.update (i, _i2cVals );

}

EEPROM. განახლება (IDX_SIGN_1, 'S');

EEPROM. განახლება (IDX_SIGN_2, 'T');

EEPROM. განახლება (IDX_SIGN_3, EEPROM_VERSION);

}

voidEEPROM_read_configuration () {

Serial.println ("EEPROM_read_configuration");

for (int i = 0; i <IDX_END_EEPROM_SET; i ++) {

_i2cVals = EEPROM.read (i);

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

}

}

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

voidreceiveEvent (int რაოდენობა) {

თუ (დათვლა == I2C_MSG_IN_SIZE)

{

char cmd = Wire.read ();

ბაიტის ინდექსი = Wire.read ();

ბაიტის მნიშვნელობა = Wire.read ();

გადართვა (სმდ) {

საქმე 'G':

თუ (ინდექსი <IDX_END_VALUES_GET) {

_i2cResponse = _i2cVals [ინდექსი];

}

შესვენება;

საქმე 'S':

თუ (ინდექსი <IDX_END_EEPROM_SET) {

_i2cVals [ინდექსი] = მნიშვნელობა;

EEPROM.update (ინდექსი, _i2cVals [ინდექსი]);

}

შესვენება;

ნაგულისხმევი:

დაბრუნების;

}

}

}

voidrequestEvent ()

{

Wire.write (_i2cResponse);

}

// --------------------------------- LDR

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] = რუკა (საშუალო ინტენსივობა, 0, 1024, 0, 255);

}

// ------------------------------------ სერვო

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);

for (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH. დაწერეთ (_angleH--);

დაგვიანებით (_servoLoopDelay);

}

}

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

// მიდის მარჯვნივ

Serial.println ("moveServos მიდის მარცხნივ");

დაგვიანება (_slowingDelay);

for (int i = 0; i <_i2cVals [IDX_H_STEP]; i ++) {

_servoH. დაწერეთ (_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);

for (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);

for (int i = 0; i <_i2cVals [IDX_V_STEP]; i ++) {

_servoV.write (_angleV--);

დაგვიანებით (_servoLoopDelay);

}

}

სხვა {

Serial.println ("moveServos არაფერს აკეთებს");

დაგვიანება (_slowingDelay);

}

}

// --------------------------------- დაიძინე

voidasleepFor (ხელმოუწერელი რვა მეორე სეგმენტი) {

Serial.println ("მძინარე ამისთვის");

for (unsignedint sleepCounter = რვა მეორე სეგმენტი; sleepCounter> 0; sleepCounter--)

{

LowPower.powerDown (SLEEP_8S, ADC_OFF, BOD_OFF);

}

}

rawtilt_pan_tracker_0.3.ino ნახვა hosted ერთად GitHub

ნაბიჯი 4: წრიული გარსაცმის შეკრება

1. დარწმუნდით, რომ Ardiuno Pro Mini არის ჩასმული PCB– ის სათაურებში.
2. ჩადეთ SOLAR TRACKER კონტროლერის ყუთის ბაზა SOLAR TRACKER კონტროლერის ყუთის კედლებში და დააფიქსირეთ 2 -დან 4G x 6 მმ უჟანგავი საწინააღმდეგო ხრახნიანი ხრახნები.
3. ჩასვით Ardiuno Pro Mini + PCB 6P სათაურით, რომელიც მოთავსებულია სიცარიელეში SOLAR TRACKER კონტროლერის ყუთში.
4. ჩადეთ SOLAR TRACKER კონტროლერის ყუთის სახურავი SOLAR TRACKER მაკონტროლებლის ყუთის კედლებში და დააფიქსირეთ 2 -დან 4G x 6 მმ უჟანგავი საწინააღმდეგო ხრახნიანი ხრახნები.
5. მიამაგრეთ ასამბლეა პანელის ჩარჩოს ბაზაზე 4 4G x 6 მმ უჟანგავი უჟანგავი ხრახნიანი ხრახნით.

ნაბიჯი 5: რიგის მიერთება კონტროლერთან

შესაბამისი კავშირები მზად არის წინა ინსტრუქციიდან, არის 4 off 2P LDR კავშირი და 2 off 3P კავშირი servos– დან. რაც დროებითია სანამ დატენვა არ იქნება მზად არის ბატარეა. გამოიყენეთ 3.7V LiPo, რომელიც მთავრდება 2P DuPont კავშირში ახლავე.

1. ჩადეთ LDR კავშირები (პოლარობის გარეშე) ზემოდან:

   1. Ზედა მარჯვენა
   2. Ზედა მარცხენა
   3. ქვედა მარჯვენა
   4. Ქვედა მარცხენა

2. ჩადეთ სერვო კავშირი (სიგნალის მავთულით მარცხნივ) ზემოდან:

   1. Ჰორიზონტალური
   2. ვერტიკალური
3. დაელოდეთ მზადაა შემდეგ გამოცდისთვის: ჩადეთ 3.7V DC დენის დენი +ve ზემოდან, -ბოლომდე.

ნაბიჯი 6: კონტროლერის ტესტირება

როგორც უკვე აღვნიშნეთ, პროგრამული უზრუნველყოფა არ არის ოპტიმიზირებული მზის დატენვის სამუშაო პროცესისთვის. მისი შემოწმება და შეცვლა შესაძლებელია ბუნებრივი (მზის) და არაბუნებრივი სინათლის წყაროების გამოყენებით.

თვალთვალის შესამოწმებლად კონტროლირებად გარემოში შეიძლება მოსახერხებელი იყოს SLEEP MINUTES- ის დაყენება უფრო დაბალ მნიშვნელობაზე (იხილეთ შემდეგი ნაბიჯი).

ნაბიჯი 7: V2 I2C– ის კონფიგურაცია კონსოლის შეყვანის გამოყენებით

ეს განმარტავს კონტროლერის კონფიგურაციას მეორე MCU– ს საშუალებით, პარამეტრების შეყვანას კონსოლის ფანჯარაში.

1. ატვირთეთ შემდეგი სკრიპტი D1M WIFI ბლოკზე (ან Wemos D1 Mini).
2. გათიშეთ USB კომპიუტერიდან

3. PIN კავშირები: -ve (კონტროლერი) => GND (D1M)+ve (კონტროლერი) => 3V3 (D1M) SCL (კონტროლერი) => D1 (D1M)

   SDA (კონტროლერი) => D2 (D1M)

4. ჩართეთ SPDT გადამრთველი კონფიგურაციაზე
5. შეაერთეთ USB კომპიუტერთან
6. Arduino IDE– დან დაიწყეთ კონსოლის ფანჯარა სწორი COM პორტით
7. დარწმუნდით, რომ შერჩეულია "Newline" და "9600 baud"
8. ბრძანებები შეიტანება Send Textbox– ში, რასაც მოჰყვება Enter ღილაკი
9. ბრძანებები არის ფორმატში Character byte byte
10. თუ მეორე ბაიტი (მესამე სეგმენტი) არ შედის 0 (ნულოვანი) იგზავნება სკრიპტით
11. ფრთხილად იყავით სერიული შეყვანის გამოყენებით; გადახედეთ იმას, რაც შეიყვანეთ "Enter" ღილაკზე დაჭერით. თუ ჩაკეტილი ხართ (მაგალითად, I2C მისამართის შეცვლა დაგავიწყდათ), თქვენ კვლავ უნდა აანთოთ კონტროლერის firmware.

ბრძანების პირველი სიმბოლოს მხარდაჭერილი ვარიაციებია:

• E (ჩართეთ servo tracking) სასარგებლოა კონფიგურაციის დროს მოძრაობის შესაჩერებლად. ეს არის შეყვანილი გამოყენებით: E 0
• D (გამორთვა servo tracking) სასარგებლოა ავტომატური თვალთვალის დასაწყებად, თუ არ გადატვირთავთ მოწყობილობას. ეს არის შეყვანილი გამოყენებით: D 0
• G (მიიღეთ კონფიგურაციის მნიშვნელობა) კითხულობს მნიშვნელობებს EEPROM და IN -MEMORY: ეს არის შეყვანილი გამოყენებით: G (ინდექსი მოქმედებს ბაიტის მნიშვნელობების 0 - 13 და 15)
• S (Set EEPROM value) ადგენს EEPROM- ის მნიშვნელობებს, რომლებიც ხელმისაწვდომია გადატვირთვის შემდეგ. ეს არის შეყვანილი: S (ინდექსი მოქმედებს ბაიტის მნიშვნელობებით 0 - 13, მნიშვნელობა მოქმედებს ბაიტის მნიშვნელობებზე და იცვლება თითო თვისებაზე)

კოდი არის ინდექსების ჭეშმარიტების წერტილი, მაგრამ შემდეგი გამოიყენება სწორი მნიშვნელობების/კომენტარების სახელმძღვანელოდ:

• I2C ADDRESS 0 - კონტროლერის მონა მისამართი, მასტერს ეს სჭირდება კონტროლერთან დასაკავშირებლად (ნაგულისხმევი 10)
• მინიმალური ვერტიკალური კუთხე 1 - კუთხის ვერტიკალური სერვო ქვედა ზღვარი (ნაგულისხმევი 10, დიაპაზონი 0 - 180)
• MAXIMUM VERTICAL ANGLE 2 - კუთხის ვერტიკალური სერვო ზედა ზღვარი (ნაგულისხმევი 170, დიაპაზონი 0 - 180)
• მგრძნობიარობა ვერტიკალური LDR 3 - ვერტიკალური LDR კითხვის ზღვარი (ნაგულისხმევი 20, დიაპაზონი 0 - 1024)
• ვერტიკალური კუთხე ნაბიჯი 4 - კუთხის ვერტიკალური servo ნაბიჯები თითოეულ კორექტირებაზე (ნაგულისხმევი 5, დიაპაზონი 1 - 20)
• მინიმალური ჰორიზონტალური კუთხე 5 - კუთხის ჰორიზონტალური სერვო ქვედა ზღვარი (ნაგულისხმევი 10, დიაპაზონი 0 - 180)
• მაქსიმალური ჰორიზონტალური კუთხე 6 - კუთხის ჰორიზონტალური სერვო ზედა ზღვარი (ნაგულისხმევი 170, დიაპაზონი 0 - 180)
• მგრძნობელობის ჰორიზონტალური LDR 7 - ჰორიზონტალური LDR კითხვის ზღვარი (ნაგულისხმევი 20, დიაპაზონი 0 - 1024)
• ჰორიზონტალური კუთხის ნაბიჯი 8 - კუთხის ჰორიზონტალური servo ნაბიჯები თითოეულ კორექტირებაზე (ნაგულისხმევი 5, დიაპაზონი 1 - 20)
• SLEEP MINUTES 9 - ძილის სავარაუდო პერიოდი თვალყურს შორის (ნაგულისხმევი 20, დიაპაზონი 1 - 255)
• ვერტიკალური გარიჟრაჟის კუთხე 10 - მომავალი გამოყენება - მზის ჩასვლისას ვერტიკალური კუთხე უნდა დაბრუნდეს
• ჰორიზონტალური გარიჟრაჟის კუთხე 11 - მომავალი გამოყენება - ჰორიზონტალური კუთხე მზის ჩასვლისას დასაბრუნებლად
• გამთენიისას ინტენსივობა 12 - მომავალი გამოყენება - LDR– ების მინიმალური საშუალო მაჩვენებელი, რაც იწვევს მზის ყოველდღიური თვალთვალის დაწყებას
• ბინდის ინტენსივობა 13 - მომავალი გამოყენება - LDR– ების მინიმალური საშუალო მაჩვენებელი, რაც იწვევს მზის ყოველდღიური თვალთვალის დასრულებას
• EEPROM ღირებულებების მარკერი 14 - მნიშვნელობა არ გამოიყენება
• მიმდინარე ინტენსივობა 15 - სინათლის ინტენსივობის ამჟამინდელი საშუალო პროცენტი
• დასამახსოვრებელი ღირებულებების მარკერი 16 - მნიშვნელობა არ გამოიყენება.

იღებს სერიულ შეყვანას (კლავიატურის შეყვანა კონსოლის ფანჯარაში) და გადასცემს I2C მონას ფორმატში char, byte, byte

#ჩართეთ

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

ლოგიკური _ ახალი მონაცემები = ყალბი;

const byte _numChars = 32;

char _receivedChars [_numChars]; // მასივი მიღებული მონაცემების შესანახად

voidsetup () {

სერიული.დაწყება (9600);

Wire.begin (D2, D1);

დაგვიანება (5000);

}

voidloop () {

recvWithEndMarker ();

parseSendCommands ();

}

voidrecvWithEndMarker () {

სტატიკური ბაიტი ndx = 0;

char endMarker = '\ n';

char rc;

ხოლო (Serial.available ()> 0 && _newData == ყალბი) {

rc = Serial.read ();

თუ (rc! = endMarker) {

_receivedChars [ndx] = rc;

ndx ++;

თუ (ndx> = _numChars) {

ndx = _numChars - 1;

}

} სხვა {

_receivedChars [ndx] = '\ 0'; // სტრიქონის შეწყვეტა

ndx = 0;

_newData = ჭეშმარიტი;

}

}

}

voidparseSendCommands () {

თუ (_newData == ჭეშმარიტი) {

კონსტრუქციული დელიმი [2] = "";

char *ნიშანი;

ნიშანი = სტრტოკი (_ მიღებულია ჩარსი, დელიმი);

char cmd = _receivedChars [0];

ბაიტის ინდექსი = 0;

ბაიტის მნიშვნელობა = 0;

int i = 0;

ხოლო (ნიშანი! = NULL) {

// სერიული.პრინტლნ (ნათქვამი);

მე ++;

გადართვა (i) {

შემთხვევა 1:

ნიშანი = სტრტოკი (NULL, delim);

ინდექსი = ატოი (ნიშანი);

შესვენება;

შემთხვევა 2:

ნიშანი = სტრტოკი (NULL, delim);

თუ (ნიშანი! = NULL) {

მნიშვნელობა = ატოი (ნიშანი);

}

შესვენება;

ნაგულისხმევი:

ნიშანი = NULL;

}

}

sendCmd (cmd, ინდექსი, მნიშვნელობა);

_newData = ყალბი;

}

}

voidsendCmd (char cmd, byte index, byte value) {

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

Serial.println ("გაგზავნის ბრძანება:");

Serial.println ("\ t" + სიმებიანი (სმდ) + "" + სიმებიანი (ინდექსი) + "" + სიმებიანი (მნიშვნელობა));

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

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // გადაეცემა მოწყობილობას

Wire.write (cmd); // აგზავნის ჩარტს

Wire.write (ინდექსი); // აგზავნის ერთ ბაიტს

Wire.write (მნიშვნელობა); // აგზავნის ერთ ბაიტს

Wire.endTransmission ();

ბაიტის პასუხი = 0;

bool hadResponse = ყალბი;

თუ (cmd == 'G') {

მავთული. მოთხოვნა (I2C_SLAVE_ADDRESS, 1);

ხოლო (Wire.available ()) // მონას შეუძლია გამოაგზავნოს მოთხოვნაზე ნაკლები

{

hadResponse = ჭეშმარიტი;

პასუხი = Wire.read ();

}

თუ (hadResponse == ჭეშმარიტი) {

Serial.println ("პასუხის მიღება:");

Serial.println (პასუხი);

} სხვა {

Serial.println ("პასუხი არ არის, შეამოწმეთ მისამართი/კავშირი");

}

}

}

rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino ნახვა hosted with GitHub

ნაბიჯი 8: შემდეგი ნაბიჯები

პერიოდულად შეამოწმეთ პროგრამული უზრუნველყოფის/აპარატურის ცვლილებები.

შეცვალეთ პროგრამული უზრუნველყოფა/აპარატურა თქვენს მოთხოვნებზე.

კომენტარი გააკეთეთ ნებისმიერ მოთხოვნაზე/ოპტიმიზაციაზე.