🕹️ 👈🏻 👦 पेश है MSP430 और टॉयलेट ऑटोमेशन ⛹🏿 🐶 👩🏽‍🔧

मैं लंबे समय से DIY अनुभाग पढ़ रहा हूं, और मेरे हाथों ने माइक्रोकंट्रोलर पर कुछ करने के लिए खरोंच किया। और यादृच्छिक पर मैंने $ 4.30 के लिए टेक्सास इंस्ट्रूमेंट्स MSP430 लॉन्च पैड के बारे में पढ़ा। शुरू करने के लिए एकदम सही सेट।
एक प्रसिद्ध ब्रांड के एक स्वचालित एयर फ्रेशनर को प्रयोगों के लिए एक वस्तु के रूप में चुना गया था।

कार्य

मूल फ्रेशनर में सेट अंतराल पर एक स्प्रे फ़ंक्शन होता है, जो हमेशा सुविधाजनक नहीं होता है। चूंकि दिन के दौरान घर पर कोई नहीं होता है, और सिलेंडर बर्बाद हो जाता है। इसके अलावा, डेवलपर्स ने अन्य निर्माताओं से सिलेंडर के उपयोग के खिलाफ "सुरक्षा" बनाया, जो हालांकि, यह काफी सरल है, लेकिन इसके बिना इसे जीना आसान हो जाता है। इसके अलावा, "मैनुअल" छिड़काव के लिए, सिलेंडर को बाहर निकालना और इसे नियमित फ्रेशनर के रूप में उपयोग करना आवश्यक था।

आप क्या पाना चाहते थे

सबसे पहले, कार्य एल्गोरिथ्म को अधिक बुद्धिमान बनाने के लिए। अर्थात्, शौचालय का दौरा करने के बाद फ्रेशनर का काम करना। और दूसरी बात, मामले को खोले बिना "मैनुअल" ऑपरेशन के फ़ंक्शन को जोड़ें।

निर्णय

एल्गोरिथ्म

मैंने प्रकाश संवेदक के आधार पर एक स्प्रे के संचालन का स्वचालन बनाने का फैसला किया। यही है, जब 5 सेकंड के बाद प्रकाश बंद हो जाता है, तो स्प्रेयर को काम करना चाहिए। उसके बाद, 15 मिनट के लिए प्रकाश चालू / बंद करने का जवाब न दें। कमरे को "ताज़ा" न करने के लिए ताकि सांस लेने के लिए संभव न हो। ऑपरेटिंग मोड की परवाह किए बिना "मैनुअल" छिड़काव के लिए एक बटन भी जोड़ें।

"रोगी" की शव परीक्षा

कुछ भी नया जोड़ने से पहले, मैंने यह देखने का फैसला किया कि इस "चमत्कार कुल" के अंदर क्या था।

और इसके पार आने वाली पहली चीज एक गैर-मानक "त्रिकोणीय" सिर के साथ थी:

सौभाग्य से, माइक्रो स्क्रूड्राइवर के सेट में एक उपयुक्त पेचकश पाया गया था और प्रक्रिया वहां नहीं रुकी थी। अंदर, सब कुछ बहुत सरल निकला। वंश तंत्र जीभ से जुड़े गियर की एक जोड़ी के गियरबॉक्स के माध्यम से एक पारंपरिक इलेक्ट्रिक मोटर है, जो स्प्रे बोतल पर दबाता है। नियंत्रण बोर्ड दिलचस्पी का नहीं है, केवल अपने स्वयं के निर्माण के लिए एक टेम्पलेट के रूप में, लेकिन कनेक्टिंग पावर और ट्रिगर मोटर के लिए कनेक्टर्स के स्रोत के रूप में।

इलेक्ट्रॉनिक हिस्सा

जब यह स्पष्ट हो जाता है कि यह उपकरण क्या है, तो आप अपने स्वयं के नियंत्रण मॉड्यूल को डिजाइन करना शुरू कर सकते हैं। मस्तिष्क माइक्रोकंट्रोलर MSP430G2553 होगा। लॉन्चपैड किट में एक युवा मॉडल G2452 भी है और आप इसका उपयोग कर सकते हैं, लेकिन मैंने पुराने को चुना, क्योंकि इसमें एक हार्डवेयर UART है, जो डिबगिंग और कैलिब्रेशन के लिए सुविधाजनक है। उदाहरण के लिए, एक खाली सिलेंडर संकेतक। प्रारंभ में, यह ज्ञात नहीं है कि इसमें कितने स्प्रे होंगे, इसलिए, कार्यक्रम गैर-वाष्पशील मेमोरी में रिकॉर्ड के साथ एक काउंटर प्रदान करता है, इसके बाद UART के माध्यम से पढ़ना और भेजना होगा (इसके लिए आपको कंट्रोल मॉड्यूल से नियंत्रक को निकालना होगा और डीबग बोर्ड पर रखना होगा)। इस डेटा को प्राप्त करने और प्रोग्राम को अंतिम संस्करण में लाने के बाद, मैं नियंत्रक को एक युवा मॉडल के साथ बदलने की योजना बना रहा हूं।

नियंत्रण मॉड्यूल की योजना। मैं तुरंत ध्यान देना चाहता हूं कि यह मेरा पहला तैयार उपकरण है, इसलिए सर्किट और बोर्ड दोनों गुणवत्ता मानकों से बहुत दूर हैं:

यह योजना इंटरनेट से नियंत्रक और लेखों के लिए डेटशीट की सिफारिशों के आधार पर संकलित की गई थी। DIHALT के लिए विशेष धन्यवाद उनका शुरुआती इलेक्ट्रॉनिक्स ट्यूटोरियल मेरा शुरुआती बिंदु था।
घटक बहुत सरल हैं। डेटशीट से सिफारिशों के अनुसार कैपेसिटर सी 1 और सी 2 पर फिल्टर एडीसी की सटीकता को बढ़ाता है। Photoresistor LDR1 एक प्रकाश संवेदक है और प्रतिरोधक R3 पर वोल्टेज डिवाइडर के माध्यम से जुड़ा हुआ है। डीसेंट मोटर को BC337 ट्रांजिस्टर के माध्यम से नियंत्रित किया जाता है। मैनुअल रिलीज बटन S1 और दो-रंग के एल ई डी भी आरेख में जोड़े जाते हैं। मैंने दो रंगों वाली एलईडी का इस्तेमाल किया। यह सामान्य संचालन के एक संकेतक के रूप में एक बार हरे रंग की झपकी लेता है; जब बैटरी 2.5 वी से नीचे डिस्चार्ज होती है, तो यह लाल झपकी लेती है। वास्तविक समय घड़ी संकेत का स्रोत 32768 हर्ट्ज पर क्वार्ट्ज जेड 1 है, जो एक बोर्ड और नियंत्रकों के साथ पूरा होता है।

सॉफ्टवेयर भाग

मैंने C ++ में IAR एंबेडेड वर्कबेंच में कंट्रोलर के लिए प्रोग्राम लिखा। मैं यहां टिप्पणियों के साथ उसका कोड ला रहा हूं।

Spary.h सुरक्षा फ़ाइल कोड

हैडर फ़ाइल स्प्रे। एच

#ifndef __SPRAY_H_ #define __SPRAY_H_ #include <sstream> //  #define BUTTON BIT4; //    #define SPRAY_PORT BIT6;// P1.6 #define LED_GREEN BIT1; // P2.1 #define LED_RED BIT2; // P2.2 #define LIGHT_SENSOR INCH_5; // A5 #define DARK_VALUE 650; //    " ." #define LOWBATT_VALUE 520; //     . //  unsigned int SleepPeriod = 900; //     . 15 . (900) unsigned int SpayDelay = 5; //    5. unsigned int DarkValue = 650; //    " ." unsigned int LowBattValue = 520; //     . unsigned int BattInterval = 5; //    5. //  unsigned int ADCValue; //   unsigned int SprayCount; //    unsigned int TimerCount = 0; //    unsigned int BattTimer = 0; //     unsigned int RXByte; //       UART //  bool ADCDone = false; //    bool LightOn = false; //    ( ) bool SleepMode = false; //    (  15 ) bool IsCounting = false; //     ,  //      bool LowBatt = false; //     bool BlinkOn = false; //     bool Tick = false; //       bool IsADCOn = false; //     bool IsADCLight = true; //     (true -   // , false - ) bool ForceSpay = false; //       bool UARTReceived = false; //     UART //  void UARTSend(string str); //   UART void LightSensorOn(); //       void VCCSensorOn(); //       unsigned int ReadCountFromFlash(); //     void WriteCountToFlash(unsigned int); //     void Spray(); //   #endif

प्रोग्राम कोड

कार्यक्रम का पाठ। main.cpp:

 #include <msp430g2553.h> #include "spray.h" int main( void ) { //  WDT    WDTCTL = WDTPW + WDTHOLD; //    //------------------------- //  - P1DIR &= ~BUTTON; //     P1REN |= BUTTON; //     P1OUT &= ~BUTTON; //   - GND P1IES |= BUTTON; //     P1IFG &= ~BUTTON; //    P1IE |= BUTTON; //     P1DIR |= SPRAY_PORT; //     P1OUT &= ~SPRAY_PORT; //     //     P2DIR |= LED_GREEN P2DIR |= LED_RED; //    ( ) P2OUT |= LED_GREEN; P2OUT &= ~LED_RED; //  . //------------------------- //   DCOCTL = CALDCO_1MHZ; //     ~ 1 BCSCTL1 = CALBC1_1MHZ; //------------------------- //    TACTL = TASSEL_1 + MC_1; //    ACLK (), //     CCR0 CCR0 = 0x8000; // ..   32768,       //        CCTL0 = CCIS0 + OUTMOD0 + CCIE; //  ,     //     //------------------------- // UART.      FLASH P1SEL = BIT1 + BIT2; //    P1SEL2 = BIT1 + BIT2; // UART UCA0CTL1 |= UCSSEL_2; //   -   SMCLK ~ 1MHz UCA0BR0 = 0x68; //   9600 UCA0BR1 = 0; // 1000000 / 9600 = 104 = 0x68 UCA0MCTL = UCBRS0; UCA0CTL1 &= ~UCSWRST; //       IE2 = UCA0RXIE; //     UART //------------------------- // Flash FCTL2 = FWKEY + FSSEL1 + FN1; //       //    .   65535 -  //   SprayCount = ReadCountFromFlash(); if(SprayCount == 65535) { SprayCount = 0; //   WriteCountToFlash(SprayCount); //  0  Flash } //------------------------- __delay_cycles(2000); //    //------------------------- __bis_SR_register(GIE); //    P2OUT &= ~LED_GREEN; //   .  . UARTSend("Ready\r\n"); //   while(true) { if(Tick) //   . { Tick = false; //   BattTimer++; if(BattTimer >= BattInterval) //       { BattTimer = 0; //   VCCSensorOn(); //    } if(!SleepMode) //      { LightSensorOn(); //    if(IsCounting) //     { if(TimerCount >= SpayDelay) //    { Spray(); //   } } } else { //     if(TimerCount >= SleepPeriod) { TimerCount = 0; //   SleepMode = false; //     } } } if(ADCDone) //    { ADCDone = false; //    if(IsADCLight) //      { if(ADCValue < DarkValue) //  . { LightOn = true; //   " " IsCounting = false; //   (   ,  ) TimerCount = 0; //   } else //    { if(LightOn) //    { LightOn = false; //   IsCounting = true; //      TimerCount = 0; } } } else //    { if(ADCValue < LowBattValue) { LowBatt = true; //     } else { LowBatt = false; //  -   } } } if(ForceSpay) //  .  . { ForceSpay = false; Spray(); } if(UARTReceived) //   UART.   . { UARTReceived = false; ostringstream s; s << SprayCount << "\r\n"; UARTSend(s.str()); } } } //   UART void UARTSend(string str) { int len = str.length(); for(int i=0;i<len;i++) { while(!(IFG2&UCA0TXIFG)); UCA0TXBUF = str[i]; } } //       void LightSensorOn() { if(!IsADCOn) { IsADCOn = true; IsADCLight = true; ADC10CTL0 &= ~ENC; ADC10CTL0 = ADC10SHT_3 + ADC10ON + ADC10IE; ADC10CTL1 = ADC10SSEL_2 + LIGHT_SENSOR; ADC10CTL0 |= ENC + ADC10SC; } } //       void VCCSensorOn() { if(!IsADCOn) { IsADCOn = true; IsADCLight = false; ADC10CTL0 &= ~ENC; ADC10CTL0 = SREF_1 + ADC10SHT_3 + REFON + ADC10ON + REF2_5V + ADC10IE; ADC10CTL1 = ADC10SSEL_2 + INCH_11; __delay_cycles(128); ADC10CTL0 |= ENC + ADC10SC; } } //     unsigned int ReadCountFromFlash() { __bic_SR_register(GIE); //    int *Flash_ptr; Flash_ptr = (int *) 0x1040; //   *Flash_ptr = 0; //   unsigned int value = *Flash_ptr; //   __bis_SR_register(GIE); //   return value; //   } //     void WriteCountToFlash(unsigned int value) { __bic_SR_register(GIE); //   int *Flash_ptr; Flash_ptr = (int *) 0x1040; //   FCTL1 = FWKEY + ERASE; //     FCTL3 = FWKEY; *Flash_ptr = 0; //   FCTL1 = FWKEY + WRT; *Flash_ptr++ = value; //    Flash FCTL1 = FWKEY; FCTL3 = FWKEY + LOCK; //     __bis_SR_register(GIE); //   } //   void Spray() { __bic_SR_register(GIE); //   P1OUT |= SPRAY_PORT; //   __delay_cycles(500000); //  ~ 0.5  (  1) P1OUT &= ~SPRAY_PORT; //   //         LightOn=false; SleepMode=true; IsCounting=false; TimerCount=0; SprayCount++; WriteCountToFlash(SprayCount); __bis_SR_register(GIE); //    } //--------------------------- //   //   #pragma vector=ADC10_VECTOR __interrupt void ADC_Handler() { ADCValue = ADC10MEM; //      ADCDone = true; //     IsADCOn = false; } //     #pragma vector=PORT1_VECTOR __interrupt void Button_Handler() { P1IE &= ~BUTTON; //      P1IFG &= ~BUTTON; //   ForceSpay = true; //     //     __delay_cycles(300000); P1IE |= BUTTON; //   } //     1  . #pragma vector=TIMER0_A0_VECTOR __interrupt void Timer_Handler() { //     if(!BlinkOn) //    { //         //      - ,   if(LowBatt) { P2OUT |= LED_RED; } else { P2OUT |= LED_GREEN; } BlinkOn = true; } else //    { P2OUT &= ~LED_RED; P2OUT &= ~LED_GREEN; BlinkOn = false; } TimerCount++; //     Tick=true; //   } //     UART #pragma vector=USCIAB0RX_VECTOR __interrupt void UART_Handler() { RXByte = UCA0RXBUF; UARTReceived = true; }

इस रूप में कार्यक्रम में सिलेंडर के अंत को इंगित करने के लिए एक ब्लॉक नहीं होता है, क्योंकि लिखने के समय यह ज्ञात नहीं है कि यह कितने स्प्रे से चलेगा।

सभा

बोर्ड पर प्रोग्राम को संकलित और डिबग करने के बाद, मॉड्यूल को ब्रेडबोर्ड पर परीक्षण के लिए संकलित किया गया था:

यहां लॉन्चपैड डीबग बोर्ड केवल क्वार्ट्ज के लिए एक धारक है, क्योंकि यह इतना छोटा है कि इसे लेआउट पर रखना असंभव है।

जब मुझे विश्वास हो गया कि सब कुछ विफलताओं के बिना काम करता है और एल्गोरिथ्म के अनुसार, मैंने नियंत्रण मॉड्यूल के लिए एक बोर्ड का निर्माण शुरू किया, जिसे मूल निवासी के स्थान पर आवास में रखा जा सकता है।

नियंत्रण मॉड्यूल के लिए बोर्ड लेआउट (स्प्रिंट-लेआउट में बनाया गया):

तब बोर्ड बनाया गया था। ड्राइंग को LUT विधि ( DIHALT के लिए फिर से धन्यवाद) द्वारा लागू किया जाता है, फिर बोर्ड को फेरिक क्लोराइड और टिनड में खोदा जाता है।

अगला, घटकों को मिलाप किया जाता है। माइक्रोकंट्रोलर को सॉकेट में रखा गया है ताकि इसे हटाने और काउंटर के मूल्य को पढ़ने में आसान हो, साथ ही कार्यक्रम को अंतिम रूप देने पर इसे दूसरे में बदल दें।

और फिर परीक्षण के बाद डिवाइस को पहले से ही एक नए नियंत्रण मॉड्यूल के साथ इकट्ठा किया जाता है।

निष्कर्ष

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

और एक बार फिर मैं इस बात पर जोर देता हूं कि इससे पहले मुझे प्रोग्रामिंग में माइक्रोकंट्रोलर या इलेक्ट्रॉनिक्स के साथ अनुभव का लगभग कोई अनुभव नहीं था। इसलिए, सबसे अधिक संभावना है कि मैंने गलती की, सॉफ्टवेयर और हार्डवेयर दोनों में, जिसके लिए मैं आपसे सख्ती से न्याय नहीं करने के लिए कहता हूं।
आपका ध्यान देने के लिए धन्यवाद।

पेश है MSP430 और टॉयलेट ऑटोमेशन