👩🏼‍🎓 📀 🌇 ई-इंक पर बेवकूफ मौसम बॉक्स 😃 ☠️ 🎍

डेढ़ साल पहले, मैंने केवल मौसम केंद्र के लिए, SSD1606 ड्राइवर पर आधारित ईबे के साथ ई-इंक स्क्रीन की एक जोड़ी खरीदी। और 4 महीने पहले, नए साल से पहले, वह दिखाई दिया।

मैं तुरंत कहूंगा कि इसमें कोई घड़ी नहीं है, क्योंकि घर पर हर जगह शाब्दिक रूप से घड़ियों हैं! लेकिन वह जानता है कि निम्नलिखित कैसे दिखाना है:

सेल्सियस में वर्तमान तापमान;
वर्तमान आर्द्रता प्रतिशत में;
एमएमएचजी में वर्तमान दबाव;
एक ग्राफ में पिछले 15 घंटों के लिए दबाव इतिहास;
बैटरी वोल्टेज।

वास्तव में यह सब है। आवश्यक न्यूनतम और अंतिम सादगी!

यहां तक कि ऐसा कोई जीयूआई भी नहीं है

कार्य सिद्धांत

नियंत्रक को एक बटन के स्पर्श में स्क्रीन पर प्रासंगिक जानकारी प्रदर्शित करनी चाहिए। अधिकांश समय नियंत्रक सोता है, जैसा कि डिस्प्ले करता है, जो गहरी नींद में है।

नियंत्रक समय-समय पर वॉचडॉग के साथ उठता है और दबाव परिवर्तनों के ग्राफ का निर्माण करने के लिए प्रत्येक 5 मिनट में एक दबाव माप लेता है।

यह अनुसूची के साथ बहुत दिलचस्प निकला, क्योंकि दबाव बहुत तेज़ी से और दृढ़ता से बदल सकता है (उत्तरी शहर में मौसम आमतौर पर अप्रत्याशित है), फिर कुछ बिंदु पर ग्राफ बंद हो सकता है। ऐसा करने के लिए, प्रत्येक घंटे में एक बार, माप के मध्य बिंदु को पुनर्गणित किया जाता है (दबाव ऊपर और नीचे दोनों जा सकता है)। हालाँकि, इसके कारण, पिछले मानों के बीच एक स्पष्ट अंतर ग्राफ के पढ़ने (CPDV पर एक उदाहरण) को सरल करता है।

लोहा

मुख्य मस्तिष्क ~~ATMega328P~~ माइक्रोकंट्रोलर है, ~~BME280~~ बैरोमीटर के पूरे मीटर के रूप में उपयोग किया जाता है, और स्क्रीन के लिए स्मार्ट-प्रोटेस्टिंग से SSD1606 पर आधारित दूसरे संशोधन का ई-इंक है, जो पहले ही वर्णित था।

यह लगभग वही स्क्रीन है जो कि वेव्ज़ एप्टर 2.7 "के रूप में है, केवल पुराने (डेटशीट उनके समान हैं)।

यह सब 120 mAh के ~~टॉय~~ हेलिकॉप्टर की बैटरी पर काम करता है। लगभग 20 mA के करंट के साथ चार्ज करने के लिए 47 kΩ रेसिस्टर के साथ TP4056 के आधार पर डीप डिस्चार्ज और ओवरचार्ज से सुरक्षा के साथ मॉड्यूल का उपयोग करके बैटरी को चार्ज किया जाता है।

बिजली अनुकूलन

एक ध्वनि और स्वस्थ नींद हमारी सब कुछ है! इसलिए, आपको अधिकतम सोने की ज़रूरत है!

चूंकि स्क्रीन के साथ काम करने के लिए कोई सॉफ्टवेयर नहीं था, केवल खगोलीय भाषा में टिप्पणियों के साथ कोड का एक मूल उदाहरण और डेटाशीट (स्क्रीन केवल डेढ़ साल पहले दिखाई दी थी), मुझे खुद को सबसे ज्यादा करना पड़ा, क्योंकि मुझे पहले से ही अलग-अलग स्क्रीन पर काम करने का अनुभव था।

डीपस्लीप मोड डेटाशीट में पाया गया था, इसमें स्क्रीन कुछ भी नहीं खाती है - 1.6mkA!

बैरोमीटर की मांग पर एक पैमाइश मोड है (उर्फ स्टैंडबाय), इसमें सेंसर ऊर्जा की एक न्यूनतम खपत करता है, जबकि परिवर्तनों के एक सरल संकेत के लिए पर्याप्त सटीकता प्रदान करता है (डेटशीट इंगित करता है कि यह सिर्फ मौसम स्टेशनों के लिए है)। इस मोड को शामिल करने से 6.2 μA की खपत हुई। मॉड्यूल पर आगे, एलडीओ नियामक LM6206N3 (या शायद XC6206, दोनों को 662k के रूप में प्रच्छन्न किया गया है) MCP1700 से मिलाया गया था।

इससे 2 μA अधिक लाभ हुआ।

चूंकि यह न्यूनतम बिजली की खपत को प्राप्त करने के लिए आवश्यक है, इसलिए LowPower लाइब्रेरी का उपयोग किया गया था। इसमें वॉचडॉग के साथ सुविधाजनक काम है, जिसके आधार पर एटमेगा का सपना बनता है। हालांकि, अपने आप में यह लगभग 4 μA खपत करता है। मैं टेक्सास इंस्ट्रूमेंट्स TPL5010 या इसी तरह के बाहरी टाइमर का उपयोग करके इस समस्या का समाधान देखता हूं।

इसके अलावा, बिजली की खपत को कम करने के लिए, एटम को अन्य FUSE बिट्स और एक बूटलोडर के साथ फ्लैश करना आवश्यक था, जिसे सफलतापूर्वक USBasp के साथ किया गया था, और बोर्डों में जोड़ा गया था।

निम्नलिखित पाठ:

## Arduino Pro or Pro Mini (1.8V, 1 MHz Int.) w/ ATmega328p
## internal osc div8, also now watchdog, no LED on boot
## bootloader size: 402 bytes
## http://homes-smart.ru/index.php/oborudovanie/arduino/avr-zagruzchik
## http://homes-smart.ru/fusecalc/?prog=avrstudio&part=ATmega328P
## http://www.engbedded.com/fusecalc
## -------------------------------------------------
pro.menu.cpu.1MHzIntatmega328=ATmega328 (1.8V, 1 MHz Int., BOD off)

pro.menu.cpu.1MHzIntatmega328.upload.maximum_size=32256
pro.menu.cpu.1MHzIntatmega328.upload.maximum_data_size=2048
pro.menu.cpu.1MHzIntatmega328.upload.speed=9600

pro.menu.cpu.1MHzIntatmega328.bootloader.low_fuses=0x62
pro.menu.cpu.1MHzIntatmega328.bootloader.high_fuses=0xD6
pro.menu.cpu.1MHzIntatmega328.bootloader.extended_fuses=0x07
pro.menu.cpu.1MHzIntatmega328.bootloader.file=atmega/a328p_1MHz_62_d6_5.hex

pro.menu.cpu.1MHzIntatmega328.build.mcu=atmega328p
pro.menu.cpu.1MHzIntatmega328.build.f_cpu=1000000L

ऑप्टबूट से संकलित किए गए बूटलोडर को "बूटलोडर्स / एटमेगा /" फ़ोल्डर में डालें:

a328p_1MHz_62_d6_5.hex

:107E0000F894112484B714BE81FFDDD082E0809302
:107E1000C00088E18093C10086E08093C2008CE0BE
:107E20008093C4008EE0B9D0CC24DD2488248394D0
:107E3000B5E0AB2EA1E19A2EF3E0BF2EA2D08134A3
:107E400061F49FD0082FAFD0023811F0013811F43F
:107E500084E001C083E08DD089C0823411F484E1D4
:107E600003C0853419F485E0A6D080C0853579F447
:107E700088D0E82EFF2485D0082F10E0102F00278F
:107E80000E291F29000F111F8ED068016FC0863583
:107E900021F484E090D080E0DECF843609F040C049
:107EA00070D06FD0082F6DD080E0C81680E7D8065C
:107EB00018F4F601B7BEE895C0E0D1E062D089932E
:107EC0000C17E1F7F0E0CF16F0E7DF0618F0F60147
:107ED000B7BEE89568D007B600FCFDCFA601A0E0CC
:107EE000B1E02C9130E011968C91119790E0982F91
:107EF0008827822B932B1296FA010C0187BEE895F6
:107F000011244E5F5F4FF1E0A038BF0751F7F60133
:107F1000A7BEE89507B600FCFDCF97BEE89526C042
:107F20008437B1F42ED02DD0F82E2BD03CD0F601D2
:107F3000EF2C8F010F5F1F4F84911BD0EA94F80143
:107F4000C1F70894C11CD11CFA94CF0CD11C0EC0EF
:107F5000853739F428D08EE10CD085E90AD08FE03E
:107F60007ACF813511F488E018D01DD080E101D09E
:107F700065CF982F8091C00085FFFCCF9093C600FD
:107F800008958091C00087FFFCCF8091C00084FDE0
:107F900001C0A8958091C6000895E0E6F0E098E160
:107FA000908380830895EDDF803219F088E0F5DF5B
:107FB000FFCF84E1DECF1F93182FE3DF1150E9F7E5
:107FC000F2DF1F91089580E0E8DFEE27FF27099494
:0400000300007E007B
:00000001FF

दरअसल, जैसा कि आप शायद अनुमान लगाते हैं, यह सब Arduino के आधार पर किया गया था, अर्थात् 8MHz 3.3V पर प्रो मिनी। इस बोर्ड से mic5203 LDO रेगुलेटर को टांका लगाया गया था (कम धाराओं पर भी ग्लूटोनस) और एलईडी प्रतिरोधक को शक्ति का संकेत देने के लिए टांका लगाया गया था।

नतीजतन, नींद मोड में 10 μAh की ऊर्जा खपत को प्राप्त करना संभव था, जो ऑपरेशन के लगभग 462.96 दिन देता है। इस संख्या से आप सुरक्षित रूप से एक तिहाई घटा सकते हैं, जिससे लगभग 10 महीने प्राप्त हो सकते हैं, जो अब तक वास्तविकता से मेल खाता है।

मैंने आयनस्टोर्स पर संस्करण का परीक्षण किया, 3 एमएएच की अंतिम क्षमता के साथ, यह 6 दिन (उच्च स्व-निर्वहन) तक नहीं रहता है। आयनिस्टर की समाई की गणना सूत्र C * V / 3.6 = X mAh के अनुसार की गई थी। मुझे लगता है कि सौर बैटरी और MSP430 वाला संस्करण आम तौर पर शाश्वत होगा।

वर्गीकृत:

#include <SPI.h>
#include <Wire.h>
#include <ssd1606.h>
#include <Adafruit_BME280.h>
//#include <BME280_2.h> // local optimisation
#include <LowPower.h>

#include <avr/sleep.h>
#include <avr/power.h>

#define TIME_X_POS 0
#define TIME_Y_POS 12

#define DATE_X_POS 2
#define DATE_Y_POS 9

#define WEECK_X_POS 65
#define WEECK_Y_POS 9

// ====================================== //
#define TEMP_X_POS 105
#define TEMP_Y_POS 15

#define PRESURE_X_POS 105
#define PRESURE_Y_POS 12

#define HUMIDITY_X_POS 105
#define HUMIDITY_Y_POS 9
// ====================================== //

#define BATT_X_POS 65
#define BATT_Y_POS 15

#define ONE_PASCAL 133.322

// ==== for presure history in graph ==== //
#define MAX_MESURES 171
#define BAR_GRAPH_X_POS 0
#define BAR_GRAPH_Y_POS 0
#define PRESURE_PRECISION_RANGE 4.0 // -/+ 4 mm
#define PRESURE_GRAPH_MIN 30 // vertical line graph for every N minutes
#define PRESURE_PRECISION_VAL 10 // max val 100
#define PRESURE_CONST_VALUE 700.0 // const val what unneed in graph calculations
#define PRESURE_ERROR -1000 // calibrated value
// ====================================== //

#define VCC_CALIBRATED_VAL 0.027085714285714 // == 3.792 V / 140 (real / mesured)
//#define VCC_CALIBRATED_VAL 0.024975369458128 // == 5.070 V / 203 (real / mesured)
#define VCC_MIN_VALUE 2.95 // min value to refresh screen
#define CALIBRATE_VCC 1 // need for battery mesure calibration

// 37 ~296 sec or 5 min * MAX_MESURES = 14,33(3) hours for full screen
#define SLEEP_SIZE 37

#ifdef BME280_ADDRESS
#undef BME280_ADDRESS
#define BME280_ADDRESS 0x76
#endif

#define ISR_PIN 3 // other mega328-based 2, 3
#define POWER_OFF_PIN 4 // also DONEPIN

#define E_CS 6 // CS ~ D6
#define E_DC 5 // D/C ~ D5
#define E_BSY 7 // BUSY ~ D7
#define E_RST 2 // RST ~ D2
#define E_BS 8 // BS ~ D8

/*
MOSI ~ D11
MISO ~ D12
CLK ~ D13
*/
EPD_SSD1606 Eink(E_CS, E_DC, E_BSY, E_RST);
Adafruit_BME280 bme;

volatile bool adcDone;
bool updateSreen = true;
bool normalWakeup = false;

float battVal =0;
uint8_t battValcV =0;

uint8_t timeToSleep = 0;

float presure =0;
float temperature =0;
float humidity =0;
float presure_mmHg =0;

unsigned long presureMin =0;
unsigned long presureMax =0;

uint8_t currentMesure = MAX_MESURES;
uint8_t presureValHistoryArr[MAX_MESURES] = {0};

typedef struct {
uint8_t *pData;
uint8_t pos;
uint8_t size;
unsigned long valMax;
unsigned long valMin;
} history_t;

प्रारंभ:

void setup()
{
saveExtraPower();
Eink.begin();

initBME();

// https://www.arduino.cc/en/Reference/attachInterrupt
pinMode(ISR_PIN, INPUT_PULLUP);
attachInterrupt(digitalPinToInterrupt(ISR_PIN), ISRwakeupPin, RISING);

//drawDefaultGUI();
drawDefaultScreen();

// tiiiiny fix....
checkBME280();
updatePresureHistory();
}

void saveExtraPower(void)
{
power_timer1_disable();
power_timer2_disable();

// Disable digital input buffers:
DIDR0 = 0x3F; // on ADC0-ADC5 pins
DIDR1 = (1 << AIN1D) | (1 << AIN0D); // on AIN1/0
}

void initBME(void)
{
bme.begin(BME280_ADDRESS); // I2C addr

LowPower.powerDown(SLEEP_250MS, ADC_OFF, BOD_OFF); // wait for chip to wake up.
while(bme.isReadingCalibration()) { // if chip is still reading calibration, delay
LowPower.powerDown(SLEEP_120MS, ADC_OFF, BOD_OFF);
}
bme.readCoefficients();

bme.setSampling(Adafruit_BME280::MODE_FORCED,
Adafruit_BME280::SAMPLING_X1, // temperature
Adafruit_BME280::SAMPLING_X1, // pressure
Adafruit_BME280::SAMPLING_X1, // humidity
Adafruit_BME280::FILTER_OFF);
}

मुख्य कोड:

void loop()
{
for(;;) { // i hate func jumps when it's unneed!
checkVCC();
if(normalWakeup) {
checkBME280();
updatePresureHistory();
} else {
normalWakeup = true;
}

updateEinkData();
enterSleep();
}
}

// func to exec in pin ISR
void ISRwakeupPin(void)
{
// Keep this as short as possible. Possibly avoid using function calls
normalWakeup = false;
updateSreen = true;
timeToSleep = 1;
}

ISR(ADC_vect)
{
adcDone = true;
}

void debounceFix(void)
{
normalWakeup = true;
updateSreen = false;
}

//https://github.com/jcw/jeelib/blob/master/examples/Ports/bandgap/bandgap.ino
uint8_t vccRead(void)
{
uint8_t count = 4;
set_sleep_mode(SLEEP_MODE_ADC);
ADMUX = bit(REFS0) | 14; // use VCC and internal bandgap
bitSet(ADCSRA, ADIE);
do {
adcDone = false;
while(!adcDone) sleep_mode();
} while (--count);
bitClear(ADCSRA, ADIE);
// convert ADC readings to fit in one byte, ie 20 mV steps:
// 1.0V = 0, 1.8V = 40, 3.3V = 115, 5.0V = 200, 6.0V = 250
return (55U * 1023U) / (ADC + 1) - 50;
}

unsigned long getHiPrecision(double number)
{
// what if presure will be more 800 or less 700? ...
number -= PRESURE_CONST_VALUE; // remove constant value
number *= PRESURE_PRECISION_VAL; // increase precision by PRESURE_PRECISION_VAL
return (unsigned long)number; // Extract the integer part of the number
}

void checkVCC(void)
{
// reconstruct human readable value
battValcV = vccRead();
battVal = battValcV * VCC_CALIBRATED_VAL;

if(battVal <= VCC_MIN_VALUE) { // not enought power to drive E-Ink or work propetly
detachInterrupt(digitalPinToInterrupt(ISR_PIN));
// to prevent full discharge: just sleep
bme.setSampling(Adafruit_BME280::MODE_SLEEP);
LowPower.powerDown(SLEEP_2S, ADC_OFF, BOD_OFF);
Eink.sleep(true);
LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);
}
}

void checkBME280(void)
{
bme.takeForcedMeasurement(); // wakeup, make new mesure and sleep
temperature = bme.readTemperature();
humidity = bme.readHumidity();
presure = bme.readPressure();
}

void updatePresureHistory(void)
{
// convert Pa to mmHg; 1 mmHg == 133.322 Pa
presure_mmHg = (presure + PRESURE_ERROR)/ONE_PASCAL;

// === calc presure history in graph === //
if((++currentMesure) >= (MAX_MESURES/3)) { // each 4,75 hours
currentMesure =0;
presureMin = getHiPrecision(presure_mmHg - PRESURE_PRECISION_RANGE);
presureMax = getHiPrecision(presure_mmHg + PRESURE_PRECISION_RANGE);
}

// 36 == 4 pixels in sector * 9 sectors
presureValHistoryArr[MAX_MESURES-1] = map(getHiPrecision(presure_mmHg), presureMin, presureMax, 0, 35);

for(uint8_t i=0; i < MAX_MESURES; i++) {
presureValHistoryArr[i] = presureValHistoryArr[i+1];
}
}

void updateEinkData(void)
{
if(updateSreen) {
updateSreen = false;
Eink.sleep(false);

// bar history
Eink.fillRect(BAR_GRAPH_X_POS, BAR_GRAPH_Y_POS, MAX_MESURES, 9, COLOR_WHITE);

for(uint8_t i=1; i <= (MAX_MESURES/PRESURE_GRAPH_MIN); i++) {
Eink.drawVLine(BAR_GRAPH_X_POS+i*PRESURE_GRAPH_MIN, BAR_GRAPH_Y_POS, 35, COLOR_DARKGREY);
}

for(uint8_t i=0; i <= MAX_MESURES; i++) {
Eink.drawPixel(i, BAR_GRAPH_Y_POS+presureValHistoryArr[i], COLOR_BLACK);
}

#if CALIBRATE_VCC
Eink.setCursor(BATT_X_POS, BATT_Y_POS);
Eink.print(battVal);

Eink.setCursor(BATT_X_POS, BATT_Y_POS-3);
Eink.print(battValcV);
#endif

Eink.setCursor(TEMP_X_POS, TEMP_Y_POS);
Eink.print(temperature);

Eink.setCursor(PRESURE_X_POS, PRESURE_Y_POS);
Eink.print(presure_mmHg);

Eink.setCursor(HUMIDITY_X_POS, HUMIDITY_Y_POS);
Eink.print(humidity);

updateEinkSreen();
Eink.sleep(true);
}
}

void updateEinkSreen(void)
{
Eink.display(); // update Eink RAM to screen
LowPower.idle(SLEEP_15MS, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF, SPI_OFF, USART0_OFF, TWI_OFF);

Eink.closeChargePump();
// as Eink display acts not like in DS, then just sleep for 2 seconds
LowPower.powerDown(SLEEP_2S, ADC_OFF, BOD_OFF);
}

void effectiveIdle(void)
{
LowPower.idle(SLEEP_30MS, ADC_OFF, TIMER2_OFF, TIMER1_OFF, TIMER0_OFF, SPI_OFF, USART0_OFF, TWI_OFF);
}

void drawDefaultScreen(void)
{
Eink.fillScreen(COLOR_WHITE);

Eink.printAt(TEMP_X_POS, TEMP_Y_POS, F("00.00 C"));
Eink.printAt(PRESURE_X_POS, PRESURE_Y_POS, F("000.00 mm"));
Eink.printAt(HUMIDITY_X_POS, HUMIDITY_Y_POS, F("00.00 %"));

#if CALIBRATE_VCC
Eink.printAt(BATT_X_POS, BATT_Y_POS, F("0.00V"));
// just show speed in some kart racing game in mushr... kingdom \(^_^ )/
Eink.printAt(BATT_X_POS, BATT_Y_POS-3, F("000cc"));
#endif
}

void drawDefaultGUI(void)
{
Eink.drawHLine(0, 60, 171, COLOR_BLACK); // split 2 areas

// draw window
Eink.drawRect(0, 0, 171, 71, COLOR_BLACK);

// frame for text
Eink.drawRect(BATT_X_POS, BATT_Y_POS, 102, 32, COLOR_BLACK);
}

void snooze(void)
{
do {
LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
} while(--timeToSleep);
}

void disablePower(void)
{
digitalWrite(POWER_OFF_PIN, HIGH);
delay(1);
digitalWrite(POWER_OFF_PIN, LOW);
LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);
}

void enterSleep(void)
{
// wakeup after ISR signal;
timeToSleep = SLEEP_SIZE;
debounceFix();
snooze();
}

आवास

चूंकि मेरे पास 3D प्रिंटर नहीं है, लेकिन मेरे पास 3D पेन MyRiwell RP800A है। यह पता चला कि प्लेनर और यहां तक कि संरचनाएं बनाना इतना आसान नहीं था। सब कुछ पीएलए प्लास्टिक के साथ खींचा गया था, जो उस समय था, इसलिए मामला बहु-रंगीन निकला, जो इसके अलावा एक निश्चित आकर्षण देता है (तब मैं लकड़ी के चिप्स के साथ प्लास्टिक के पेड़ के नीचे इसका रीमेक बनाऊंगा)।

पहले हिस्सों को सीधे कागज पर खींचा गया था, और फिर बंद हो गया। इससे प्लास्टिक पर निशान पड़ गए। इसके अलावा, विवरण टेढ़े थे और उन्हें किसी तरह सीधा करने की आवश्यकता थी!

समाधान साधारण सरल निकला - कांच पर ड्रा, और इसके तहत मामले के आवश्यक तत्वों के "चित्र" डालें।

और यहाँ क्या हुआ:

स्क्रीन रिफ्रेश बटन बस एक सफेद पृष्ठभूमि पर लाल होना चाहिए था!

पीछे की दीवार को सबसे सरल पैटर्न के साथ बनाया गया है, जिससे वेंटिलेशन छेद बना रहा है।

बटन को एक हैंडल के अंदर (पीले रंग में) एक क्षैतिज अकड़ पर तय किया गया था।

बटन खुद एक पुराने कंप्यूटर केस से लिया गया है (इसमें अच्छी आवाज है)।

अंदर, सब कुछ गर्म-पिघल चिपकने और प्लास्टिक के साथ तय किया जाता है, ताकि इसे अलग करना आसान न हो।

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

निष्कर्ष

4 महीने बीत गए, और पूरी तरह से चार्ज नहीं होने (4 वी तक) के बाद, बैटरी पर वोल्टेज केवल 3.58 वी तक नीचे चला गया, जो अगले चार्ज तक एक समान लंबे समय तक सेवा जीवन की गारंटी देता है।

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

रिपोजिटरी के लिंक:

→ स्क्रीन लाइब्रेरी
→ लोवरपावर के लिए लाइब्रेरी
→ BME280 के लिए पुस्तकालय

अपडेट किया गया:

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

मुझे क्लिक करें:

PS शाम को CPDV बनाया गया था, जिसके परिणामस्वरूप सेंट पीटर्सबर्ग में आज रात बहुत ज्यादा बर्फ गिरी थी।
पीपीएस ब्लू टेप को सर्वेक्षण में जोड़ने के लिए नहीं जाना गया।

ई-इंक पर बेवकूफ मौसम बॉक्स

कार्य सिद्धांत

लोहा

बिजली अनुकूलन

आवास

निष्कर्ष

More articles: