IOT123 - सौर ट्रैकर - नियंत्रक: 8 कदम

2024 लेखक: John Day | [email protected]. अंतिम बार संशोधित: 2024-01-30 09:22

यह इंस्ट्रक्शनल का विस्तार है

IOT123 - सोलर ट्रैकर - टिल्ट/पैन, पैनल फ्रेम, LDR माउंट्स रिग। यहां हम सर्वो के नियंत्रक और सूर्य की स्थिति के सेंसर पर ध्यान केंद्रित करते हैं। यह इंगित करना महत्वपूर्ण है कि यह डिज़ाइन मानता है कि 2 MCU कार्यरत होंगे: एक (3.3V 8mHz Arduino Pro Mini) सौर ट्रैकर के लिए, और एक स्वतंत्र MCU आपके सेंसर/अभिनेताओं के लिए।

यह संस्करण 0.3 है।

पूरी संतुष्टि के बाद सभी परियोजनाओं को प्रकाशित करने के बजाय, मैं निरंतर एकीकरण का अभ्यास करूंगा और कुछ और अधिक बार वितरित करूंगा, जो मैंने दिया है उसे संशोधित करना। मैं बैटरी चार्जर के लिए एक और निर्देश लिखूंगा, _जब_ कंट्रोलर सॉफ्टवेयर / हार्डवेयर का अनुकूलन पूरा हो गया है। मैं यह बताऊंगा कि अनुकूलन की आवश्यकता कहाँ है क्योंकि हम इसके माध्यम से कदम रखते हैं।

इस दृष्टिकोण का कारण क्लाइंट फीडबैक है। यदि आप लोगों को कोई आवश्यकता दिखाई देती है या आपके पास बेहतर दृष्टिकोण है, तो कृपया टिप्पणी करें, लेकिन ध्यान रखें कि मैं सब कुछ वितरित नहीं कर सकता और संभवत: उस समय-सीमा में नहीं जो आपके अनुकूल हो। चूंकि ये स्पष्टीकरण कम प्रासंगिक लगते हैं, इसलिए उन्हें इस लेख से हटा दिया जाएगा।

इसमें क्या शामिल है:

1. सूर्य के अनुमानित स्थान को समझने के लिए मूल निर्देश से एलडीआर का उपयोग करें।
2. सूर्य का सामना करने के लिए सर्वो को स्थानांतरित करें।
3. आंदोलनों की संवेदनशीलता के लिए विकल्प।
4. सूर्य की ओर बढ़ते समय चरण आकार के विकल्प।
5. सर्वो पर प्रयुक्त कोणीय बाधाओं के लिए विकल्प।
6. आंदोलनों की देरी के लिए विकल्प।
7. एमसीयू के बीच मान सेट करने/प्राप्त करने के लिए I2C इंटरफ़ेस।
8. आंदोलनों के बीच गहरी नींद।

इसमें क्या शामिल नहीं है (और समय परमिट के रूप में संबोधित किया जाएगा):

1. केवल दिन के उजाले के दौरान बिजली का उपयोग करना।
2. भोर की स्थिति को याद करना और शाम को बंद होने पर वहां जाना।
3. एमसीयू से नियामक को हटाना।
4. MCU पर LED (ओं) को अक्षम करना।
5. रॉ के बजाय वीसीसी के माध्यम से शक्ति को पुन: व्यवस्थित करना।
6. यूएसबी से सीरियल टीटीएल कनवर्टर के लिए विनियमित शक्ति के बिना फ्लैशिंग के लिए वर्कअराउंड प्रदान करना।
7. बैटरी वोल्टेज मॉनिटर।

इतिहास

दिसंबर 20, 2017 वी0.1 कोड

प्रारंभिक संस्करण प्रकाश स्रोत को ट्रैक करता है, हमेशा चालू, कोई चार्ज नहीं

जनवरी 7, 2018 वी0.2 कोड

• हार्डवेयर परिवर्तन

  • I2C पिन जोड़ें
  • सर्वो जीएनडी में स्विच जोड़ें
  • नियंत्रक बॉक्स प्रावरणी पर मुद्रित लेबल

• सॉफ्टवेयर परिवर्तन

  • EEPROM से कॉन्फ़िगरेशन पढ़ें
  • I2C बस दूसरे MCU (3.3V) के दास के रूप में समर्थन करता है
  • I2C के माध्यम से कॉन्फ़िगरेशन सेट करें
  • I2C के माध्यम से सक्षम सेट करें
  • I2C के माध्यम से कॉन्फ़िगरेशन प्राप्त करें
  • I2C के माध्यम से रनटाइम गुण प्राप्त करें (वर्तमान में सक्षम, और वर्तमान प्रकाश तीव्रता)
  • सीरियल लॉगिंग निकालें (इससे I2C मान प्रभावित हुए)

जनवरी १९, २०१८ वी०.३ कोड

• हार्डवेयर

  लेबल अपडेट किया गया। स्विच का उपयोग अब CONFIG या TRACK मोड में से किसी एक को चुनने के लिए किया जाता है

• सॉफ्टवेयर

  • I2C केवल कॉन्फ़िगरेशन के लिए उपयोग किया जाता है
  • ट्रैकिंग शुरू करने से पहले नियंत्रक 5 सेकंड प्रतीक्षा करता है, हाथ हिलाने की अनुमति देता है
  • I2C कॉन्फ़िगरेशन का उपयोग करने के लिए, SPDT को CONFIG पर यूनिट बूट के रूप में होना चाहिए
  • ट्रैकिंग गति के बीच, इकाई स्लीप मिनट (डिफ़ॉल्ट 20 मिनट) कॉन्फ़िगरेशन मान के लिए गहरी नींद मोड में है।

चरण 1: सामग्री और उपकरण

अब सामग्री और स्रोतों की सूची का पूरा बिल है।

1. 3 डी प्रिंटेड पार्ट्स।
2. Arduino प्रो मिनी 3.3V 8mHz
3. 4x6cm में से 1 डबल साइड प्रोटोटाइप पीसीबी यूनिवर्सल प्रिंटेड सर्किट बोर्ड (आधे में कटौती करने के लिए)
4. 40पी पुरुष हेडर में से 1 (आकार में कटौती करने के लिए)।
5. ४०पी महिला हेडर में से १ (आकार में कटौती के लिए)।
6. 4 ऑफ 10K 1/4W रेसिस्टर्स।
7. तार बांधना।
8. सोल्डर और आयरन।
9. 20 बंद 4G x 6mm स्टेनलेस पैन हेड सेल्फ टैपिंग स्क्रू।
10. 4 जी x 6 मिमी स्टेनलेस काउंटरसंक सेल्फ टैपिंग स्क्रू से 4 दूर।
11. 3.7 वी लीपो बैटरी और धारक (2 पी डुपोंट कनेक्टर में समाप्त) से 1।
12. 1 ऑफ 2P पुरुष समकोण हैडर
13. एसपीडीटी स्विच बंद 1 3 पिन 2.54 मिमी पिच
14. मजबूत साइनोएक्रिलेट गोंद
15. ड्यूपॉन्ट कनेक्टर्स महिला 1P हैडर (नीले रंग से 1 बंद, हरे रंग से 1 बंद)।

चरण 2: सर्किट को असेंबल करना

सर्किट में वर्तमान में वोल्टेज डिवाइडर सर्किट (वोल्ट मीटर) नहीं है।

1. 4x6cm डबल साइड प्रोटोटाइप पीसीबी यूनिवर्सल प्रिंटेड सर्किट बोर्ड को लंबी धुरी पर आधा काटें।

2. 40P पुरुष हेडर को टुकड़ों में काटें:

   1. 2 ऑफ १२पी
   2. ३ बंद ३पी
   3. 2 पी से 6।

3. 40P महिला हेडर को टुकड़ों में काटें:

   1. 2 ऑफ १२पी
   2. 1 बंद ६पी
4. दिखाए गए अनुसार 12Pfemale हैडर से मिलाप 2।
5. 3P पुरुष (अतिरिक्त) हेडर से निकाले गए स्पेसर को साइनोएक्रिलेट ग्लू के साथ SPDT स्विच के नीचे चिपका दें
6. दूसरी तरफ तो सोल्डर ६ ऑफ २पी, २ ऑफ ३पीमेल हेडर और एसपीडीटी स्विच जैसा कि दिखाया गया है।
7. GND पिन हेडर (#2 ब्लैक) और A0 - A3 हेडर पिन (#5, #6, #7, #8) तक लेड के माध्यम से 10K रेसिस्टर्स (A, B, C, D ब्लैक) से मिलाप 4, फिर होल के माध्यम से (पीला) जैसा दिखाया गया है (3 तस्वीरें + 1 आरेख)।
8. LDR PINS सोल्डरिंग PINS #4, #6, #8, #10 से ट्रेस 3.3V और थ्रेड हालांकि होल टू फीमेल हेडर VCC पिन (हरा)।
9. पिन्स #1, #12, #15 में दिखाए गए (लाल) सोल्डरिंग के अनुसार महिला हेडर साइड पर 3.3V ट्रेस करें।
10. 3.3V छेद के माध्यम से सोल्डर ओवर साइड (लाल) रॉ हेडर पिन # 1।
11. पिन # 11 से छेद के माध्यम से सोल्डर महिला पिन को दूसरी तरफ दिखाए गए अनुसार ट्रेस ऑरेंज हुकअप।
12. #20 से #30 और #31 से #13 और #16 तक ट्रेस और सोल्डर ब्लू हुकअप वायर।
13. सोल्डर फीमेल हैडर पिन #11 से मेल हैडर पिन #11 होल के माध्यम से।
14. महिला 1P हैडर (1 ऑफ ब्लू, 1 ऑफ ग्रीन) के साथ 2 डुपॉन्ट कनेक्टर 30 मिमी लंबा तैयार करें। पट्टी और टिन दूसरे छोर।
15. #28 तक मिलाप नीला डुपोंट तार; सोल्डर ग्रीन ड्यूपॉन्ट वायर # 29 पर।
16. Arduino के शीर्ष पर 6P महिला हेडर को फिर सोल्डर को ठीक करें।
17. Arduino के शीर्ष पर 2P समकोण महिला हेडर int # 29 और # 30 फिर सोल्डर को ठीक करें।
18. Arduino के नीचे की तरफ 12P में से 2 और 3P पुरुष पिन से 1 को फिर मिलाप ठीक करें।
19. PCB 12P महिला हेडर में Arduino पुरुष 12P पिन डालें।

चरण 3: एमसीयू चमकाना

Arduino Pro Mini को 6P महिला हेडर का उपयोग करके FTDI232 USB से TTL कनवर्टर का उपयोग करके आसानी से फ्लैश किया जाता है। 2 बोर्डों के संरेखण के लिए ऊपर दी गई तस्वीर देखें।

सुनिश्चित करें कि आपके FTDI232 पर 3.3V सेटिंग चुनी गई है। नीचे दिए गए कोड का उपयोग करके यहां दिए गए निर्देशों का पालन करें (GIST के लिंक का उपयोग करें)।

लोपावर लाइब्रेरी (संलग्न और https://github.com/rocketscream/Low-Power) को स्थापित करने की आवश्यकता है।

एक बार Arduino Pro Mini + PCB को केसिंग में स्थापित करने के बाद भी इसे फ्लैश किया जा सकता है क्योंकि हेडर पिन उजागर होते हैं। हेडर को उजागर करने वाले पैनल फ्रेम से कंट्रोलर यूनिट को बस डिस्कनेक्ट करें।

I2C/EEPROM कॉन्फ़िगरेशन के साथ पैन सोलर ट्रैकर को झुकाएं और गतिविधियों के बीच स्लीप साइकल। जैसे-जैसे अवधि बढ़ती है नींद चक्र की अवधि की सटीकता कम होती जाती है, लेकिन इस उद्देश्य के लिए पर्याप्त है।

/*

* कोड से संशोधित

* माथियास लेरॉय द्वारा

*

* वी0.2 संशोधन

** I2C सेट प्राप्त करें

** EEPROM सेट प्राप्त करें

** सीरियल आउटपुट निकालें - प्रभावित I2C

** सक्षम / अक्षम ट्रैकिंग

** I2C के माध्यम से सर्वो को सीमा तक ले जाएं

** I2C के माध्यम से वर्तमान औसत तीव्रता पढ़ें

* वी०.३ संशोधन

** 2 मोड के लिए स्विच करें - ट्रैक (सं I2C) और कॉन्फ़िगर करें (I2C का उपयोग करता है)

** ट्रैक मोड में सोएं (8 सेकंड चंक्स के कारण बहुत कम सटीक)

** स्लीप/वेक पर सर्वो को अलग/अटैच करें (ट्रांजिस्टर का उपयोग अंततः किया जाता है)

** विन्यास योग्य प्रारंभिक स्थिति निकालें (अनावश्यक)

** कॉन्फ़िगर करने योग्य वेक सेकंड निकालें (अनावश्यक)

** कॉन्फ़िगर करने योग्य सक्षम/अक्षम हटाएं (अनावश्यक)

** कॉन्फ़िगर करने योग्य ट्रैकर को हटा दें (हार्डवेयर स्विच का उपयोग करें)

** वोल्टेज गेट्टर निकालें - अलग I2C घटक का उपयोग करेगा

** I2C का उपयोग नहीं करते समय सीरियल लॉगिंग जोड़ें

*/

#शामिल

#शामिल

#शामिल

#शामिल

#शामिल

#defineEEPROM_VERSION1

#defineI2C_MSG_IN_SIZE3

#definePIN_LDR_TL A0

#definePIN_LDR_TR A1

#definePIN_LDR_BR A3

#definePIN_LDR_BL A2

#definePIN_SERVO_V11

#definePIN_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

सर्वो _सर्वोएच;

सर्वो _सर्वोवी;

बाइट _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 = ९०;

int _angleV = ९०;

int _averageTop = 0;

int _averageRight = 0;

इंट _औसत बॉटम = 0;

int _averageLeft = 0;

बाइट _i2cResponse = 0;

बूल _inConfigMode = झूठा;

व्यर्थ व्यवस्था()

{

सीरियल.बेगिन (115200);

getFromEeprom ();

अगर (इनकॉन्फिगमोड ()) {

Serial.println ("कॉन्फ़िगर मोड");

सीरियल.प्रिंट ("I2C पता:");

Serial.println(_i2cVals[IDX_I2C_ADDR]);

Wire.begin(_i2cVals[IDX_I2C_ADDR]);

Wire.onReceive (प्राप्त करें);

Wire.onRequest(requestEvent);

}अन्यथा{

Serial.println ("ट्रैकिंग मोड");

देरी (5000);// बैटरी आदि को जोड़ने पर हाथ से बाहर निकलने का समय।

}

}

शून्य लूप ()

{

getLightValues ();

अगर (!_inConfigMode){

// टूडू: ट्रांजिस्टर स्विच चालू करें

_servoH.attach(PIN_SERVO_H);

_servoV.attach(PIN_SERVO_V);

के लिए (int i = 0; i <20; i++){

अगर (मैं! = 0) {

getLightValues ();

}

मूव सर्वोस ();

}

देरी (500);

_servoH. अलग ();

_servoV. अलग ();

// टूडू: ट्रांजिस्टर स्विच बंद करें

देरी (500);

स्लीपफोर ((_i2cVals [IDX_SLEEP_MINUTES] * 60) / 8);

}

}

//---------------------------------वर्तमान तरीका

बूलिनकॉन्फिगमोड () {

पिनमोड (पिन_सर्वो_एच, इनपुट);

_inConfigMode = digitalRead(PIN_SERVO_H) == 1;

वापसी _inConfigMode;

}

//-------------------------------------ईईपीरोम

voidgetFromEeprom () {

अगर(

EEPROM.read(IDX_SIGN_1) != 'एस' ||

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.अपडेट (IDX_SIGN_1, 'एस');

EEPROM.update(IDX_SIGN_2, 'T');

EEPROM.अपडेट (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 (स्ट्रिंग (i) + "=" + _i2cVals );

}

}

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

voidreceiveEvent (इंट काउंट) {

अगर (गिनती == I2C_MSG_IN_SIZE)

{

चार सीएमडी = वायर.रीड ();

बाइट इंडेक्स = वायर.रीड ();

बाइट मान = वायर.रीड ();

स्विच (सीएमडी) {

केस 'जी':

अगर (इंडेक्स< IDX_END_VALUES_GET){

_i2cResponse = _i2cVals [सूचकांक];

}

टूटना;

केस 'एस':

अगर (इंडेक्स< IDX_END_EEPROM_SET){

_i2cVals [सूचकांक] = मान;

EEPROM.update (सूचकांक, _i2cVals [अनुक्रमणिका]);

}

टूटना;

चूक जाना:

वापसी;

}

}

}

शून्य अनुरोधइवेंट ()

{

वायर.राइट (_i2cResponse);

}

//------------------------------------- एलडीआर

voidgetLightValues(){

int valueTopLeft = analogRead (PIN_LDR_TL);

int valueTopRight = analogRead (PIN_LDR_TR);

इंट वैल्यूबॉटमराइट = एनालॉगरेड (पिन_एलडीआर_बीआर);

इंट वैल्यूबॉटमलेफ्ट = एनालॉगरेड (पिन_एलडीआर_बीएल);

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

अगर ((_averageLeft-_averageRight)>_i2cVals[IDX_H_SENSITIVITY] && (_angleH-_i2cVals[IDX_H_STEP])>_i2cVals[IDX_H_ANGLE_MIN]) {

// बाएं जा रहे हैं

Serial.println ("मूवसर्वो लेफ्ट जा रहा है");

देरी (_slowingDelay);

के लिए (int i=0; i <_i2cVals[IDX_H_STEP]; i++){

_servoH.लिखें (_angleH--);

देरी (_servoLoopDelay);

}

}

अन्यिफ़ ((_averageRight-_averageLeft)>_i2cVals[IDX_H_SENSITIVITY] && (_angleH+_i2cVals[IDX_H_STEP])<_i2cVals[IDX_H_ANGLE_MAX]) {

// सही जा रहा है

Serial.println ("मूवसर्वो लेफ्ट जा रहा है");

देरी (_slowingDelay);

के लिए (int i=0; i <_i2cVals[IDX_H_STEP]; i++){

_servoH.लिखें (_angleH++);

देरी (_servoLoopDelay);

}

}

अन्यथा {

// कुछ नहीं कर रहे

Serial.println ("moveServos कुछ नहीं कर रहा है");

देरी (_slowingDelay);

}

अगर ((_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.लिखें (_angleV++);

देरी (_servoLoopDelay);

}

}

अन्य ((_औसत बॉटम-_औसत टॉप)>_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.लिखें (_angleV--);

देरी (_servoLoopDelay);

}

}

अन्यथा {

Serial.println ("moveServos कुछ नहीं कर रहा है");

देरी (_slowingDelay);

}

}

//---------------------------------नींद

voidasleepFor (अहस्ताक्षरित आठ सेकेंड सेगमेंट) {

Serial.println ("स्लीपफॉर");

के लिए (अहस्ताक्षरित नींद काउंटर = आठ सेकेंड सेगमेंट; स्लीप काउंटर> 0; स्लीप काउंटर--)

{

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 ऑफ 4G x 6mm स्टेनलेस काउंटरसंक सेल्फ टैपिंग स्क्रू के साथ चिपका दें।
3. सोलर ट्रैकर कंट्रोलर बॉक्स बेस में शून्य में 6P हैडर स्लॉटिंग के साथ Ardiuno Pro Mini + PCB डालें।
4. SOLAR TRACKER कंट्रोलर बॉक्स के ढक्कन को SOLAR TRACKER कंट्रोलर बॉक्स की दीवारों में डालें और 2 ऑफ 4G x 6mm स्टेनलेस काउंटरसंक सेल्फ टैपिंग स्क्रू के साथ चिपका दें।
5. 4G x 6mm स्टेनलेस काउंटरसंक सेल्फ टैपिंग स्क्रू के साथ पैनल फ्रेम के आधार के ऊपर असेंबली लगाएं।

चरण 5: रिग को नियंत्रक से जोड़ना

पिछले निर्देश से तैयार प्रासंगिक कनेक्शन, 2P LDR कनेक्शन से 4 और सर्वो से 3P कनेक्शन से 2 दूर हैं। रिचार्जिंग तैयार होने तक अस्थायी क्या है बैटरी है। एक 3.7V LiPo का उपयोग करें जो अभी के लिए 2P ड्यूपॉन्ट कनेक्शन में समाप्त हो जाता है।

1. ऊपर से LDR कनेक्शन (कोई ध्रुवता नहीं) डालें:

   1. ठीक तरह से ऊपर
   2. बाएं से बाएं
   3. नीचे दाएं
   4. तली छोड़ें

2. ऊपर से सर्वो कनेक्शन (बाईं ओर सिग्नल वायर के साथ) डालें:

   1. क्षैतिज
   2. खड़ा
3. परीक्षण के लिए तैयार होने तक प्रतीक्षा करें: 3.7V DC पावर लीड + ve को ऊपर, -ve से नीचे तक डालें।

चरण 6: नियंत्रक का परीक्षण

जैसा कि पहले कहा गया है, सॉफ्टवेयर को सोलर चार्जिंग वर्कफ़्लो के लिए अनुकूलित नहीं किया गया है। हालांकि इसे प्राकृतिक (सूर्य) और अप्राकृतिक प्रकाश स्रोतों का उपयोग करके परीक्षण और ट्वीक किया जा सकता है।

नियंत्रित वातावरण में ट्रैकिंग का परीक्षण करने के लिए स्लीप मिनट को कम मान पर सेट करना सुविधाजनक हो सकता है (अगला चरण देखें)।

चरण 7: कंसोल इनपुट का उपयोग करके I2C के माध्यम से कॉन्फ़िगर करना

यह एक दूसरे एमसीयू के माध्यम से नियंत्रक को कॉन्फ़िगर करने, कंसोल विंडो में सेटिंग्स दर्ज करने की व्याख्या करता है।

1. निम्न स्क्रिप्ट को D1M वाईफ़ाई ब्लॉक (या Wemos D1 Mini) पर अपलोड करें।
2. पीसी से यूएसबी डिस्कनेक्ट करें

3. पिन कनेक्शन:-ve (नियंत्रक) => GND (D1M)+ve (नियंत्रक) => 3V3 (D1M) SCL (नियंत्रक) => D1 (D1M)

   एसडीए (नियंत्रक) => D2 (D1M)

4. SPDT स्विच को CONFIG. में बदलें
5. यूएसबी को पीसी से कनेक्ट करें
6. Arduino IDE से सही COM पोर्ट के साथ एक कंसोल विंडो प्रारंभ करें
7. सुनिश्चित करें कि "न्यूलाइन" और "9600 बॉड" चयनित हैं
8. कमांड सेंड टेक्स्टबॉक्स में एंटर की के बाद एंटर की जाती है
9. कमांड कैरेक्टर बाइट बाइट प्रारूप में हैं
10. यदि दूसरा बाइट (तीसरा खंड) शामिल नहीं है, तो 0 (शून्य) स्क्रिप्ट द्वारा भेजा जाता है
11. सीरियल इनपुट का उपयोग करते हुए सावधान रहें; "एंटर" कुंजी को हिट करने से पहले आपने जो दर्ज किया है उसकी समीक्षा करें। यदि आप लॉक हो गए हैं (उदाहरण के लिए I2C पते को उस मान में बदलना जिसे आप भूल गए हैं) तो आपको नियंत्रक फर्मवेयर को फिर से फ्लैश करना होगा।

कमांड फर्स्ट कैरेक्टर में समर्थित बदलाव हैं:

• ई (सर्वो ट्रैकिंग सक्षम करें) कॉन्फ़िगरेशन के दौरान आंदोलन को रोकने के लिए उपयोगी है। यह इनपुट का उपयोग कर रहा है: ई 0
• डी (सर्वो ट्रैकिंग अक्षम करें) डिवाइस को रिबूट नहीं करने पर स्वचालित ट्रैकिंग शुरू करने के लिए उपयोगी है। यह इनपुट का उपयोग कर रहा है: डी 0
• G (कॉन्फ़िगरेशन मान प्राप्त करें) EEPROM और IN-MEMORY से मान पढ़ता है: यह इनपुट का उपयोग कर रहा है: G (सूचकांक मान्य बाइट मान 0 - 13 और 15 है)
• S (सेट EEPROM मान) EEPROM के लिए मान सेट करता है जो रिबूट के बाद उपलब्ध होते हैं। यह इनपुट का उपयोग कर रहा है: एस (सूचकांक मान्य बाइट मान 0 - 13 है, मान मान्य बाइट मान है और प्रति संपत्ति भिन्न होता है)

कोड इंडेक्स के लिए सत्य का बिंदु है लेकिन मान्य मूल्यों/टिप्पणियों के लिए एक गाइड के लिए निम्नलिखित का उपयोग किया जाता है:

• I2C पता 0 - नियंत्रक दास पता, नियंत्रक के साथ संवाद करने के लिए मास्टर को इसकी आवश्यकता होती है (डिफ़ॉल्ट 10)
• न्यूनतम लंबवत कोण 1 - कोण लंबवत सर्वो निचली सीमा (डिफ़ॉल्ट 10, श्रेणी 0 - 180)
• अधिकतम लंबवत कोण 2 - कोण लंबवत सर्वो ऊपरी सीमा (डिफ़ॉल्ट 170, श्रेणी 0 - 180)
• सेंसिटिविटी वर्टिकल एलडीआर 3 - वर्टिकल एलडीआर रीडिंग मार्जिन (डिफ़ॉल्ट 20, रेंज 0 - 1024)
• लंबवत कोण चरण 4 - प्रत्येक समायोजन पर कोण लंबवत सर्वो चरण (डिफ़ॉल्ट 5, श्रेणी 1 - 20)
• न्यूनतम क्षैतिज कोण 5 - कोण क्षैतिज सर्वो निचली सीमा (डिफ़ॉल्ट 10, श्रेणी 0 - 180)
• अधिकतम क्षैतिज कोण 6 - कोण क्षैतिज सर्वो ऊपरी सीमा (डिफ़ॉल्ट 170, श्रेणी 0 - 180)
• संवेदनशीलता क्षैतिज एलडीआर 7 - क्षैतिज एलडीआर रीडिंग मार्जिन (डिफ़ॉल्ट 20, श्रेणी 0 - 1024)
• क्षैतिज कोण चरण 8 - प्रत्येक समायोजन पर कोण क्षैतिज सर्वो चरण (डिफ़ॉल्ट 5, श्रेणी 1 - 20)
• स्लीप मिनट 9 - ट्रैकिंग के बीच अनुमानित नींद की अवधि (डिफ़ॉल्ट 20, श्रेणी 1 - 255)
• ऊर्ध्वाधर भोर कोण 10 - भविष्य का उपयोग - सूर्य के ढलने पर वापस जाने के लिए ऊर्ध्वाधर कोण
• HORIZONTAL DAWN ANGLE 11 - भविष्य का उपयोग - सूर्य के ढलने पर वापस जाने के लिए क्षैतिज कोण
• भोर की तीव्रता 12 - भविष्य का उपयोग - सभी एलडीआर का न्यूनतम औसत जो दैनिक सूर्य ट्रैकिंग की शुरुआत को ट्रिगर करता है
• शाम की तीव्रता 13 - भविष्य का उपयोग - सभी एलडीआर का न्यूनतम औसत जो दैनिक सूर्य ट्रैकिंग के अंत को ट्रिगर करता है
• EEPROM मूल्यों का अंत मार्कर 14 - मूल्य का उपयोग नहीं किया गया
• वर्तमान तीव्रता 15 - प्रकाश की तीव्रता का वर्तमान औसत प्रतिशत
• इन-मेमोरी वैल्यू का अंत मार्कर 16 - वैल्यू का उपयोग नहीं किया गया।

सीरियल इनपुट (कंसोल विंडो में कीबोर्ड इनपुट) को कैप्चर करता है और इसे चार, बाइट, बाइट प्रारूप में I2C स्लेव को अग्रेषित करता है।

#शामिल

#defineI2C_MSG_IN_SIZE2

#defineI2C_MSG_OUT_SIZE3

#defineI2C_SLAVE_ADDRESS10

बूलियन _newData = झूठा;

कॉन्स्ट बाइट _numChars = 32;

चार _receivedChars [_numChars]; // प्राप्त डेटा को संग्रहीत करने के लिए एक सरणी

व्यर्थ व्यवस्था() {

सीरियल.बेगिन (९६००);

वायर.बेगिन (डी 2, डी 1);

देरी (5000);

}

शून्य लूप () {

recvWithEndMarker ();

पार्ससेंड कमांड ();

}

voidrecvWithEndMarker () {

स्थिर बाइट एनडीएक्स = 0;

चार एंडमार्कर = '\ n';

चार आर सी;

जबकि (सीरियल.उपलब्ध ()>0 && _newData == असत्य) {

आरसी = सीरियल.रीड ();

अगर (आरसी! = एंडमार्कर) {

_receivedChars [ndx] = आरसी;

एनडीएक्स++;

अगर (एनडीएक्स>= _numChars) {

एनडीएक्स = _numChars - 1;

}

} अन्यथा {

_receivedChars[ndx] = '\0'; // स्ट्रिंग को समाप्त करें

एनडीएक्स = 0;

_newData = सच;

}

}

}

voidparseSendCommands() {

अगर (_newData == सच) {

कॉन्सचर डेलीम [2] = "";

चार * टोकन;

टोकन = स्ट्रोक (_receivedChars, डेलीम);

चार cmd = _receivedChars [0];

बाइट इंडेक्स = 0;

बाइट मान = 0;

इंट मैं = 0;

जबकि (टोकन! = NULL) {

// सीरियल.प्रिंट्लन (टोकन);

मैं++;

स्विच (i) {

मामला एक:

टोकन = स्ट्रोक (नल, डेलीम);

सूचकांक = एटोई (टोकन);

टूटना;

केस2:

टोकन = स्ट्रोक (नल, डेलीम);

अगर (टोकन! = न्यूल) {

मूल्य = atoi (टोकन);

}

टूटना;

चूक जाना:

टोकन = नल;

}

}

SendCmd (cmd, अनुक्रमणिका, मान);

_न्यूडाटा = झूठा;

}

}

voidsendCmd (चार cmd, बाइट अनुक्रमणिका, बाइट मान) {

सीरियल.प्रिंट्लन ("-----");

Serial.println ("कमांड भेजा जा रहा है:");

Serial.println ("\ t" + स्ट्रिंग (cmd) + "" + स्ट्रिंग (इंडेक्स) + "" + स्ट्रिंग (मान));

सीरियल.प्रिंट्लन ("-----");

Wire.beginTransmission (I2C_SLAVE_ADDRESS); // डिवाइस पर संचारित करें

वायर.राइट (सेमीडी); // एक चार भेजता है

वायर.राइट (इंडेक्स); // एक बाइट भेजता है

वायर.राइट (मान); // एक बाइट भेजता है

वायर.एंडट्रांसमिशन ();

बाइट प्रतिक्रिया = 0;

बूल हैडरेस्पॉन्स = झूठा;

अगर (सीएमडी == 'जी') {

Wire.requestFrom (I2C_SLAVE_ADDRESS, 1);

जबकि (वायर.उपलब्ध ()) // दास अनुरोध से कम भेज सकता है

{

हैडरिस्पॉन्स = सच;

प्रतिक्रिया = वायर.रीड ();

}

अगर (हैड रेस्पॉन्स == सच) {

Serial.println ("प्रतिक्रिया प्राप्त करना:");

Serial.println (प्रतिक्रिया);

}अन्यथा{

Serial.println ("कोई प्रतिक्रिया नहीं, पता / कनेक्शन जांचें");

}

}

}

देखें rawd1m_serial_input_i2c_char_byte_byte_v0.1.ino GitHub द्वारा ❤ के साथ होस्ट किया गया

चरण 8: अगले चरण

सॉफ़्टवेयर/हार्डवेयर में परिवर्तनों की जाँच करने के लिए समय-समय पर जाँच करें।

सॉफ़्टवेयर/हार्डवेयर को अपनी आवश्यकताओं के अनुसार संशोधित करें।

किसी भी अनुरोध/अनुकूलन पर टिप्पणी करें।