गिलहरी पहिया गति काउंटर

/ *
पहिया गति की गिनती के लिए स्केच
और 8-अंकीय स्क्रीन पर मान प्रदर्शित करना
प्लस उत्पादन वर्तमान तापमान और आर्द्रता
रिहाई
* /

/ DHT11 डिजिटल सेंसर के लिए ************** *****************
# डेफ़िन dht_dpin A2

बाइट bGlobalErr;

बाइट dht_dat [5];
/ DHT11 डिजिटल सेंसर के लिए ************** **********

/ ******* डिजिटल मोड के लिए चर ******************

// एक 8-खंड डिजिटल मॉड्यूल के लिए पुस्तकालय
#include "TM1638.h"
// डेटा पिन 5, घड़ी पिन 4 और स्ट्रोब पिन 6 मॉड्यूल में पिन को परिभाषित करें
TM1638 मॉड्यूल (5, 4, 6);
#define Red TM1638_COLOR_RED
#define ग्रीन TM1638_COLOR_GREEN
#define Red_green TM1638_COLOR_GREEN + TM1638_COLOR_RED

/ ************ मॉड्यूल के लिए चर का अंत ****************

/ हॉल के सेंसर के लिए ********* चर ********************

// पहिया परिधि मीटर में (निर्दिष्ट करने के लिए)
स्थिर नाव One_round = 0.91;

// हॉल सेंसर को जोड़ने के लिए पोर्ट को परिभाषित करें
# डेफिन हॉल_पोर्ट 2
#define Max_led_light_speed 8
// 10 सेकंड का अंतराल, यदि अधिक पहिया को केवल रोक के रूप में पहचाना जाता है,
// यदि कम है, तो माना जाता है कि यह ठंडा है
#define Wait_interval 10000
// अंतराल जिसके बाद स्क्रीन बंद हो जाती है
# डेफिन Do_sleeping_interval 60000
// सेंसर मोड में सामान्य मोड में रोकें
# डेफिन Delay_in_work 5
// स्लीप पोल में ठहराव
#define Delay_in_sleep 50

// व्हील स्पीड काउंटर
अहस्ताक्षरित लंबा Round_counter = 0;
// यहां हम पिछली बार की गणना गति गणना के लिए करते हैं
अहस्ताक्षरित लंबे समय तक Prev_time = 0;
// यहां हम पिछले समय को निरंतर निगरानी के लिए संग्रहीत करते हैं
अहस्ताक्षरित लंबा Prev_time_mon = 0;
// यहाँ शून्य को चालू करने और स्क्रीन को बंद करने आदि के लिए डेटा की निगरानी है।
अहस्ताक्षरित लंबे समय तक_स्पैन_मन = 0;
// पिछला सेंसर मूल्य
बाइट प्रीवैल्यू = 1;
// वर्तमान पहिया गति सेमी / सी
डबल Curr_speed = 0;
// अधिकतम पहिया गति एम / एस
डबल मैक्स_स्पीड = 0;
/ / बटन प्रेस की गणना करने के लिए मीटर में कुल लाभ
डबल Total_run = 0;
// औसत की गणना करने के लिए सभी हलकों की गति को यहां रखें
डबल All_speeds = 0;
// कितने दिन हो गए
double Day_passed = 0;
// सिस्टम स्टेट स्टोर करने के लिए चर
// 0- ऊर्जा की बचत और स्टैंडबाय मोड में सिस्टम - पहिया लंबे समय तक शांत नहीं हुआ है - स्क्रीन बंद है
// 1- पहिया बस क्रुइटस्ट्ससा को रोक दिया
// 2- क्रुइटस्ट्सा व्हील
बाइट Sys_status = 0;

/ *************** हॉल के लिए चर का अंत ******************

शून्य सेटअप () {

सीरियल.बेगिन (9600);
InitDHT (); // आरंभीकरण DHT11 सेंसर
Serial.println ("भागो!");

// डिस्प्ले चालू करें, उस पर 0 प्रदर्शित करें
mod.setDisplayToString ("0.", 0, 7);
देरी (1000);

}

शून्य लूप () {

अगर (Sys_status == 0)
{
// यदि स्लीप मोड, तो कम बार हम सेंसर से पूछताछ करते हैं
देरी (Delay_in_sleep);
}
अन्यथा
{
// यदि ऑपरेटिंग मोड, हम अक्सर सेंसर से पूछताछ करते हैं
देरी (Delay_in_work);
}
/ ************** बटन की शुरुआत *************************** ******* /

// बटन सुनें
बाइट कीज़ = मॉड्यूल.गेटबटन ();

// यदि बटन दबाया गया है और समय समाप्ति से अधिक समय है, तो प्रदर्शन चालू करें
अगर (चाबियाँ! = 0 && Sys_status == 0)
{
मॉड्यूल.सेटअपडिसप्ले (सच, 7);
}

स्विच (कुंजी) {
// अगर सबसे बाईं ओर दबाया गया
मामला 0b00000001:

// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (लाल, 0);
मॉड्यूल .clearDisplay ();
// किलोमीटर में कुल लाभ प्रदर्शित करें
Total_run = Round_counter * (डबल) One_round / 1000.00;

DoubleToDisp (Total_run);
//module.setDisplayToDecNumber(Total_run, 1, false);
देरी (1000);
// यदि स्थिति शून्य है तो स्क्रीन बंद कर दें
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}

तोड़;

// अगर दूसरा बायाँ दबाया जाता है
मामला 0b00000010:
// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
mod.setLED (लाल, 1);
मॉड्यूल .clearDisplay ();
// अधिकतम गति प्रदर्शित करें
DoubleToDisp (Max_speed);
//module.setDisplayToDecNumber(Max_speed, 1, false);
देरी (1000);
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}
तोड़;

// अगर 3 बायां दबाया जाता है
मामला 0b00000100:
// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (लाल, 2);
मॉड्यूल .clearDisplay ();
// हमें शुरू हुए कितने दिन बीत चुके हैं
Day_passed = millis () / 86400000.00;
// अगर पूरा दिन बीत गया
अगर (Day_passed> 1)
{

// किलोमीटर में कुल लाभ पर विचार करें
Total_run = Round_counter * (डबल) One_round / 1000.00;
// दैनिक औसत रन प्रिंट करें
DoubleToDisp (Total_run / Day_passed);
देरी (1000);
मॉड्यूल .clearDisplay ();
}
और // अगर पूरा दिन अभी तक नहीं गुजरा
{
mod.setDisplayToString ("0", 0);
}
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}

तोड़;

// अगर 4 बा को दबाया जाता है
मामला 0b00001000:
// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
mod.setLED (लाल, 3);
मॉड्यूल .clearDisplay ();
// प्रति लैप औसत गति को गिनें और प्रदर्शित करें :)
DoubleToDisp (All_speeds / Round_counter);

देरी (1000);
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}
तोड़;

// यदि 5 वीं बाईं ओर दबाया जाता है
मामला 0b00010000:
// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
मॉड्यूल.सेटेड (लाल, 4);
मॉड्यूल .clearDisplay ();
// हमें शुरू हुए कितने दिन बीत चुके हैं
Day_passed = millis () / 86400000.00;
DoubleToDisp (Day_passed);

देरी (1000);
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}
तोड़;

// अगर छठा दबाया गया
मामला 0b00100000:
// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
मॉड्यूल.सेटेड (लाल, 4);
मॉड्यूल .clearDisplay ();
// हलकों की संख्या प्रिंट करें
मॉड्यूल .setDisplayToDecNumber (Round_counter, 0, false);

देरी (1000);
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}
तोड़;

// अगर 1 अधिकार दबाया जाता है
मामला 0b10000000:
// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (लाल, 7);
मॉड्यूल .clearDisplay ();
// वर्तमान आर्द्रता प्रदर्शित करें
ReadDHT (); // सेंसर पढ़ें
// अगर कोई त्रुटि नहीं है
अगर (bGlobalErr == 0)
{
बाइट आर्द्रता = dht_dat [0];
मॉड्यूल.सेटडिसप्लेटीओडेकनंबर (आर्द्रता, 0, गलत);
// DoubleToDisp (आर्द्रता);
}
देरी (1000);
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}
तोड़;

// यदि दूसरा अधिकार दबाया जाता है
मामला 0b01000000:
// उपयुक्त डायोड के साथ ब्लिंक करें, बाकी को बुझा दें
मॉड्यूल .setLEDs (0);
मॉड्यूल.सेटेड (लाल, 6);
मॉड्यूल .clearDisplay ();
// वर्तमान तापमान को प्रदर्शित करता है
ReadDHT (); // सेंसर पढ़ें
// अगर कोई त्रुटि नहीं है
अगर (bGlobalErr == 0)
{
बाइट तापमान = dht_dat [2];
मॉड्यूल.सेटडाइप्लेटीओडेकनंबर (तापमान, 0, गलत);
}
देरी (1000);
अगर (Sys_status == 0)
{
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}
तोड़;
}
// बटन का अंत
/ **************** बटनों का अंत *************************** ******* /

/ ***************** यहाँ जानकारी पढ़ने का पूरा तर्क है *************************

// read data - हॉल सेंसर को 3 डिजिटल पोर्ट से कनेक्ट करें
int SensValue = digitalRead (Hall_port);

// यदि सेंसर की स्थिति बदल गई है
अगर (SensValue! = PrevValue)
{
प्रीवैल्यू = सेंसरवैल्यू;
// यदि सेंसर 0 देता है यानी। चुंबक यहाँ है
अगर (SensValue)
{
Sys_status = 2;

// प्रदर्शन को चालू करें यदि विराम स्लिप अंतराल से अधिक लंबा था और यह पहले ही बंद हो गया है
अगर (time_span_mon> Do_sleeping_interval)
{
मॉड्यूल.सेटअपडिसप्ले (सच, 7);
}
// एक काउंटर जोड़ें
राउंड_काउंटर ++;

// मिलीसेकंड में वर्तमान समय ले लो
अहस्ताक्षरित लंबी time_now = millis ();

// वर्तमान और पिछले के बीच एमएस में समय अंतर पर विचार करें
अहस्ताक्षरित लंबे time_span = time_now - Prev_time;
// वर्तमान पिछले करने के लिए लिखें
Prev_time = time_now;
// यदि ठहराव 10 सेकंड से कम है, तो हम पहचानते हैं कि क्रुटिटस्टा व्हील
अगर (time_span <Wait_interval)
{
अगर (Curr_speed> 10.00)
{
मॉड्यूल .clearDisplay ();
}

Curr_speed = One_round / time_span * 1000 * 3.6; // किलोमीटर प्रति घंटा हमें गति मिलती है
औसत की गणना करने के लिए All_speeds + = Curr_speed; //

// अधिकतम के लिए जाँच करें
अगर (Curr_speed> Max_speed)
Max_speed = Curr_speed;

बाइट led_speed = मानचित्र (Curr_speed, 0, Max_led_light_speed, 0, 7);
// आइस हाइलाइट पर कॉल करें
LED_speed_light (led_speed);

// डिबग
// Serial.print ("Round_counter =");
//Serial.println(Round_counter);
//Serial.print ("cur_speed (किमी / घंटा) =");
//Serial.println(Curr_speed, 4);

// वर्तमान गति प्रदर्शित करें
DoubleToDisp (Curr_speed);

}
// यदि ठहराव 10 सेकंड से अधिक है, तो हम मानते हैं कि पहिया इससे पहले खड़ा था
// और पिछली बार के डेटा को ध्यान में नहीं रखते हैं, लेकिन शुरू करें
// पहले अंतर को गिनें
अन्यथा
{
Prev_time = time_now;

// डिबग
//Serial.print ("time_span रीसेट");
}

}

}

और // यदि सेंसर की स्थिति नहीं बदली है
{
// वर्तमान समय ले लो
अहस्ताक्षरित लंबी time_now = millis ();

// वर्तमान और एमएस के बीच पिछली बार की निगरानी के बीच का अंतर जो हम मानते हैं
time_span_mon = time_now - Prev_time;

// यदि स्पर्श के बीच का अंतराल 10 सेकंड से अधिक है, तो हम मानते हैं कि पहिया
// बंद कर दिया गया और प्रिंट 0 (अंतराल स्पष्ट किया जाना चाहिए)
अगर (time_span_mon> Wait_interval && Sys_status! = 1)
{
Sys_status = 1;
Curr_speed = 0;
मॉड्यूल .clearDisplay ();
मॉड्यूल .setDisplayDigit (0, 7, सच);
मॉड्यूल .setLEDs (0);
}

// यदि ठहराव 60 सेकंड से अधिक है, तो स्क्रीन को बंद कर दें
// यदि स्पर्श के बीच का अंतराल 10 सेकंड से अधिक है, तो हम मानते हैं कि पहिया
// बंद कर दिया गया और प्रिंट 0 (अंतराल स्पष्ट किया जाना चाहिए)
if (time_span_mon> Do_sleeping_interval && Sys_status! = 0
{
Sys_status = 0;
मॉड्यूल.सेटअपडिस्प्ले (गलत, 0);
}

}

}
पहिया गति के आधार पर /// डायोड रोशनी
// फ़ंक्शन
शून्य Led_speed_light (बाइट led_speed)
{
विवश (led_speed, 0, 7);

स्विच (led_speed) {
मामला 0:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
देरी (100);
मॉड्यूल .सेटेड (0, 0);
तोड़;
केस 1:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
मॉड्यूल .सेटेड (हरा, 1);
देरी (100);
मॉड्यूल .सेटेड (0, 1);
तोड़;
मामला 2:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
मॉड्यूल .सेटेड (हरा, 1);
मॉड्यूल .सेटेड (हरा, 2);
देरी (100);
for (int i = 2; मैं> 0; मैं -) {
मॉड्यूल .सेटेड (0, i);
देरी (50);
}
तोड़;
केस 3:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
मॉड्यूल .सेटेड (हरा, 1);
मॉड्यूल .सेटेड (हरा, 2);
मॉड्यूल .सेटेड (हरा, 3);
देरी (100);
for (int i = 3; i> 0; i -) {
मॉड्यूल .सेटेड (0, i);
देरी (50);
}
तोड़;
मामला 4:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
मॉड्यूल .सेटेड (हरा, 1);
मॉड्यूल .सेटेड (हरा, 2);
मॉड्यूल .सेटेड (हरा, 3);
मॉड्यूल .सेटेड (हरा, 4);
देरी (100);
for (int i = 4; i> 0; i -) {
मॉड्यूल .सेटेड (0, i);
देरी (50);
}
तोड़;
केस 5:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
मॉड्यूल .सेटेड (हरा, 1);
मॉड्यूल .सेटेड (हरा, 2);
मॉड्यूल .सेटेड (हरा, 3);
मॉड्यूल .सेटेड (हरा, 4);
मॉड्यूल .सेटेड (लाल, 5);
देरी (100);
(int i = 5; i> 0; i -) {
मॉड्यूल .सेटेड (0, i);
देरी (50);
}
तोड़;
केस 6:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
मॉड्यूल .सेटेड (हरा, 1);
मॉड्यूल .सेटेड (हरा, 2);
मॉड्यूल .सेटेड (हरा, 3);
मॉड्यूल .सेटेड (हरा, 4);
मॉड्यूल .सेटेड (लाल, 5);
मॉड्यूल.सेटेड (लाल, 6);
देरी (100);
for (int i = 6; मैं> 0; मैं -) {
मॉड्यूल .सेटेड (0, i);
देरी (50);
}
तोड़;
मामला 7:
मॉड्यूल .setLEDs (0);
मॉड्यूल .सेटेड (हरा, 0);
मॉड्यूल .सेटेड (हरा, 1);
मॉड्यूल .सेटेड (हरा, 2);
मॉड्यूल .सेटेड (हरा, 3);
मॉड्यूल .सेटेड (हरा, 4);
मॉड्यूल .सेटेड (लाल, 5);
मॉड्यूल.सेटेड (लाल, 6);
मॉड्यूल .सेटेड (लाल, 7);
देरी (100);
for (int i = 7; मैं> 0; मैं -) {
मॉड्यूल .सेटेड (0, i);
देरी (50);
}

तोड़;
}

}

// फ़ंक्शन LKM1638 आंशिक मान (सटीकता - 2 वर्ण) प्रदर्शित करता है
शून्य DoubleToDisp (डबल संख्या)
{
double mult_num = (double) num * 100.00;
long int_mult_num = (long) mult_num;
स्ट्रिंग string_mult_num = स्ट्रिंग (int_mult_num);
int लंबाई = string_mult_num.length ();
char str [लंबाई + 1];

string_mult_num.toCharArray (str, लंबाई + 1);

// यदि संख्या 1 से कम थी, तो सही अंतर प्राप्त करने के लिए सामूहिक फार्म गैग
यदि (संख्या <1)
{
mod.setDisplayDigit (0, 5, सत्य);
mod.setDisplayDigit (str [0], 6, गलत);
mod.setDisplayDigit (str [1], 7, गलत);
}

और // यदि 1 से अधिक है तो आउटपुट
{
for (int i = 0; मैं <लंबाई; i ++)
{
अगर (i == लंबाई - 3) {
mod.setDisplayDigit (str [i], i + 8-length, true);
}
अन्यथा
{
mod.setDisplayDigit (str [i], i + 8-length, false);
}
}
}

}

/ DHT11 के लिए ****** सुविधाएँ *** /

शून्य InitDHT () {

पिनमोड (dht_dpin, OUTPUT);

digitalWrite (dht_dpin, HIGH);

}

शून्य ReadDHT () {

bGlobalErr = 0;

बाइट dht_in;

बाइट मैं;

digitalWrite (dht_dpin, LOW);

देरी (20);

digitalWrite (dht_dpin, HIGH);

देरीमाइक्रोसेकंड (40);

pinMode (dht_dpin, INPUT);

// देरीमाइक्रोसेकंड (40);

dht_in = digitalRead (dht_dpin);

अगर (dht_in) {

bGlobalErr = 1;

वापसी;

}

देरीमाइक्रोसेकंड (80);

dht_in = digitalRead (dht_dpin);

अगर (dht_in) {

bGlobalErr = 2;

वापसी;

}

देरीमाइक्रोसेकंड (80);

के लिए (i = 0; मैं <5; मैं ++)

dht_dat [i] = read_dht_dat ();

पिनमोड (dht_dpin, OUTPUT);

digitalWrite (dht_dpin, HIGH);

बाइट dht_check_sum =

dht_dat [0] + dht_dat [1] + dht_dat [2] + dht_dat [3];

अगर (dht_dat [4]! = dht_check_sum)

{
bGlobalErr = 3;
}

};

बाइट read_dht_dat () {

बाइट i = 0;

बाइट परिणाम = 0;

के लिए (i = 0; मैं <8; मैं ++) {

जबकि (digitalRead (dht_dpin) == कम);

देरीमाइक्रोसेकंड (30);

अगर (digitalRead (dht_dpin) == हाई)

परिणाम | = (1 << (7-i));

जबकि (digitalRead (dht_dpin) == High);

}

वापसी परिणाम;

}

DHT11 **** के लिए कार्यों का / ****** अंत