Libra- władczyni czasu, przestrzeni i pogody

Prolog

Cześć!

W końcu postanowiłem opisać swój kolejny projekt zegarka. Tym razem postanowiłem pójść na całość i zbudować coś mega praktycznego. Urządzenie, które funkcjonalnością położy na łopatki wiele zegarków dostępnych komercyjnie, a przy tym będzie równie wyjątkowe, co poprzednie. Jesteście ciekawi? No, to zaczynamy 🙂

Tak wiem, możecie odnieść wrażenie, że buduję wyłącznie zegarki, chociaż nie jest to prawda 🙂 Dla ciekawych poprzednich projektów:

Rozdział pierwszy: założenia projektowe

Postawiłem sobie kilka celów:

1- niewielkie rozmiary- mówimy tutaj przecież o zegarku na rękę. Nie może być zbyt mały, ponieważ powinien się wyróżniać. Ale nie chciałbym też, żeby grubością lub średnicą znacząco przewyższał męski zegarek.

2- musi się czymś wyróżniać- stawiam na funkcjonalność. Wyświetlanie godziny to oczywiście podstawowa cecha, ale dlaczego nie dorzucić kilku bajerów? Komponenty SMD są malutkie, a każdy wie, że rysując płytkę w programie EDA mamy ogromne możliwości miniaturyzacji obwodu. Jeżeli ktoś z Was chciałby spróbować swoich sił, zapraszam oczywiście na kurs projektowania PCB.

3- powinien mieć estetyczny, a jednocześnie ekstrawagancki wygląd.

4- jego obsługa powinna być relatywnie prosta.

5- czas pracy baterii – powinien być optymalny, a ładowanie możliwie najbardziej ułatwione.

Idąc za powyższymi, postanowiłem zaprojektować zegarek o średnicy 44mm, pod pasek NATO szerokości 24mm. w ten sposób wpisuję się dość zgrabnie w wymiary przeciętnego męskiego zegarka na rękę. Jeżeli chodzi o funkcjonalność- zdecydowałem się użyć czujnika Bosch sensortec który pozwala mierzyć ciśnienie atmosferyczne, temperaturę oraz wilgotność powietrza. Pomiar ciśnienia umożliwi też zaimplementowanie funkcjonalności wysokościomierza. Później pojawił się jeszcze pomysł dorzucenia magnetometru- dzięki temu mogę też doprogramować kompas cyfrowy. Jeżeli chodzi o wygląd zegarka- zdecydowałem o budowie zegarka w formie kanapki- Płytka PCB umieszczona pomiędzy dwiema maskownicami z aluminium, wyciętymi na ploterze CNC, całość skręcona 4 śrubami 2mm.

Rozdział drugi: wyświetlacz

Bezsprzeczny lider do tego projektu- e-ink. To technologia wytwarzania wyświetlaczy, które pracują na czysto mechanicznej zasadzie. Mamy mikroskopijne kulki z cieczą, wewnątrz której zawieszone są drobinki pigmentu białego oraz czarnego, naładowane przeciwnie. Pod wpływem przyłożonego napięcia, drobinki mogą się przemieszczać wewnątrz kulki na górę, lub na dół. W zależności od tego, które z nich są na górze- takiej barwy jest pixel. Warto też wspomnieć, że na jeden pixel przypada od kilku do kilkunastu takich kulek z pigmentem.

Najciekawsza zaleta wyświetlacza to pobieranie energii jedynie w czasie wypalania obrazu na matrycy – oznacza to, że nawet całkowicie odpięty wyświetlacz będzie pokazywał ostatnio wypalony obraz. Pozwala to na ciągłe wyświetlanie godziny, bez potrzeby wybudzania zegarka, jak to ma miejsce w smartwatchach– bez drenażu baterii.

Poza powyższą, wyświetlacz taki charakteryzuje się perfekcyjną widocznością w pełnym słońcu. Wizualnie przypomina powierzchnię kartki papieru- dlatego jest też powszechnie używany w czytnikach ebook.

Mamy również kilka wad- jest monochromatyczny, czyli potrafi wyświetlać tylko jeden kolor, a także odświeża się relatywnie powoli w stosunku do innych wyświetlaczy. W zegarku jednak nie ma to wielkiego znaczenia. Tym, co będzie na pewno trochę uwierać jest brak podświetlenia, ale rekompensuje to kontrast. Jak się okazało w praktyce – wystarczy odrobina światła, żeby odczytać godzinę.

Ekran taki może wypalać obraz na dwa sposoby:

Pierwszy z nich to odświeżenie szybkie- zmieniany jest jedyne wskazany fragment matrycy, jednorazowo. Trwa to ok 200ms, ale we wskazanym miejscu pozostają słabo widocznie „cienie” poprzedniego obrazu- nazywamy to „ghostingiem”. Nie wszystkie ekrany e-ink mają tą funkcjonalność!

Drugi to odświeżenie pełne- zmieniana jest zawartość całej matrycy, a proces jest powtarzany wielokrotnie aby usunąć wszelkie pozostałe cienie. Trwa to jednak znacznie dłużej, bo ok 5 sekund.

Zdecydowałem się na użycie matrycy firmy waveshare 1,44 cala w wersji jednokolorowej- tylko ona bowiem daje nam możliwość szybkiego odświeżenia ekranu. Moduł jest sprzedawany w wersji z podstawką oraz surowej.

Podstawka zawiera elementy niezbędne do uruchomienia wyświetlacza np. z platformą typu Nucleo, czy Arduino. Znajduje się na niej konwerter poziomów logicznych oraz przetwornica Step-up, która pompuje napięcie aż 50V wymagane do wypalenia matrycy.

W projekcie postanowiłem użyć wersji surowej, ze względu na spore rozmiary podstawki- komponenty wymagane do poprawnej pracy wyświetlacza zaimplementowałem w płytce zegarka. Z konwertera postanowiłem zrezygnować- wyświetlacz działa na tym samym poziomie logicznym, co wybrany przeze mnie mikrokontroler.

Rozdział trzeci: mikrokontroler

Zdecydowałem, ze sercem zegarka zostanie MCU od ST Microelectronics. Nowa seria G znakomicie się do tego nadaje. Dlaczego? Po pierwsze jest energooszczędna- bazuje na tych samych rdzeniach co seria Low Power. Po drugie została stworzona ze względu na uwagi hobbystów- posiada tylko dwa piny zasilania.

Dokładny model układu to STM32G070KBT – posiada on energooszczędny rdzeń ARM Cortex M0+, 128kB pamięci flash- jest to ważne, ponieważ mamy do obsługi wyświetlacz graficzny. Jego biblioteka sporo waży, a program jest dość złożony. Do tego maksymalne taktowanie 64MHz, i 36kB pamięci RAM.

Obsługa interfejsu SPI, poprzez który będę się komunikował z wyświetlaczem, jest właściwie standardem dla STMów.

Obudowa z 32 pinami wystarczy do obsługi peryferiów, oraz zapewni zapas dla ewentualnego rozwoju projektu.

Nie bez znaczenia jest też obsługa wolnego kwarcu zegarkowego- 32,768kHz. Ten kwarc będzie stabilizował układ RTC- zegara czasu rzeczywistego.

Rdzeń zaś skonfigurowałem do pracy z maksymalną częstotliwością 64MHz, na wewnętrznym rezonatorze.

Na zrzucie powyżej widać piny interfejsu SPI do komunikacji z wyświetlaczem (SPI1_SCK, SPI_CS, SPI1_MOSI)- odbywa się ona w trybie transmit only master- nie odbieramy danych od wyświetlacza, a zajętość sygnalizuje on poprzez wejście BUSY. SPI działa z prędkością 4MBit/s – maksymalną obsługiwaną przez wyswietlacz.

Na górze po lewej mam wyprowadzenia interfejsu I²C- on z kolei posłuży do obsługi czujników opisanych w kolejnym rozdziale.

Poza tym widoczne są też wejścia przycisków (START, SET, RESET) a także wejście przetwornika ADC do pomiaru napięcia akumulatora.

Rozdział czwarty: czujniki

Ponieważ zegarek oprócz wskazywania godziny ma pokazywać również aktualne warunki atmosferyczne, zdecydowałem się na użycie porządnego czujnika Bosch sensortec, model BME280. Jest to czujnik który potrafi komunikować się poprzez I²C lub SPI, mierzy ciśnienie atmosferyczne, temperaturę oraz wilgotność powietrza. Jest przy tym bardzo dokładny, jego przeznaczeniem są między innymi drony lub smartwatche czy telefony. A to wszystko zamknięte w zgrabnej obudowie LGA8, o wymiarach zaledwie 2x3mm. Oczywiście czujnik ten również postanowiłem użyć w wersji surowej, a niezbędne do jego pracy elementy pasywne umieścić na płytce zegarka.

Kolejnym potrzebnym czujnikiem jest magnetometr. Tutaj zdecydowałem się na użycie czegoś taniego i prostego w obsłudze, ponieważ ma on służyć wyłącznie do wskazania kierunku. Nie będzie potrzebny precyzyjny pomiar pola magnetycznego, a tylko jego orientacja. QMC5883L wydał się najbardziej optymalna opcją. Jest to prosty 3-osiowy czujnik o regulowanym zakresie: można ustawić 2 lub 8 Gaussów (jednostka indukcji magnetycznej), komunikujący się również poprzez interfejs I²C. W projekcie użyłem jedynie dwóch osi, równoległych do płaszczyzny czujnika. Jego obudowa to LGA16 o wymiarach 3x3mm.

Rozdział piąty: Schemat- jak to działa?

Powyżej widoczny jest kompletny schemat zegarka.

Na niebiesko zaznaczyłem układ czujników. Jak widać, BME280 oraz QMC588L są podłączone do tej samej magistrali I²C., widoczne są także rezystory podciągające I²C do napięcia zasilania. Wynika to z założeń tego interfejsu- wszystkie piny I²C mają typ otwartego kolektora- oznacza to, że nie są w stanie same podciągnąć linii do napięcia zasilania.

Kolejny moduł, zaznaczony na czerwono to przetwornica step-up o której wspominałem przy rozdziale dotyczącym wyświetlacza e-ink. Ta część schematu została przeze mnie przerysowana z noty katalogowej wyświetlacza. Widoczna jest cewka oraz tranzystor przełączający. Bramka tranzystora jest sterowana przez kontroler wyświetlacza, znajdujący się w płytce matrycy, pinem GDR.

Fioletowym kolorem zaznaczyłem 24-pinowe złącze wyświetlacza. Widoczne są piny odpowiedzialne za komunikację, masa kondensatorów filtrujących a także wejście zasilania z przetwornicy opisanej wyżej(PREVGL, PREVGH). Ten fragment schematu również rysowałem bazując na nocie katalogowej.

Mały fragment oznaczony granatową barwą to prosty dzielnik napięcia, służący do pomiaru stanu akumulatora. Nie możemy podłączyć go bezpośrednio, ponieważ napięcie naładowanego ogniwa (4.2V) spaliłoby mikrokontroler. Zastosowane rezystory mają wartość aż 100kOhm każdy- zdecydowałem się na takie, ponieważ ten dzielnik będzie stale rozładowywał akumulator, a chciałbym żeby ten proces postępował jak najwolniej. Spróbujcie policzyć, jaki prąd z akumulatora będzie pobierał dzielnik. Odpowiedź na końcu artykułu 🙂

Kondensator służy oczywiście filtracji wyjścia z dzielnika.

Pomarańczowym kolorem oznaczyłem układ ładowarki ogniwa litowo-jonowego. Na schemacie widoczne jest złącze microUSB, diody sygnalizujące ładowanie oraz jego zakończenie, a także układ scalony liniowej ładowarki. Rezystor R11 służy do regulacji prądu ładowania ogniwa. 15kOhm zapewnia prąd na poziomie 80mA i został dobrany wg wzoru podanego w nocie katalogowej układu TP4056.

Zielony to zasilacz zegarka. Został oparty na stabilizatorze liniowym typu Ultra Low-Dropout. Zapewnia on spadek poniżej 80mV pomiędzy wejściem a wyjściem, a to pozwala na pracę w pełnym zakresie napięć akumulatora. Widoczne są także kondensatory filtrujące zasilanie.

Bez zaznaczenia pozostawiłem MCU i elementy bezpośrednio z nim związane. Widać tutaj rezystor podciągający pin RESET zapewniający stabilną pracę (R1), kwarc zegarkowy (Y1), a także przyciski do obsługi zegarka, wraz z filtrami.

Rozdział szósty: PCB – nadajemy realne kszałty teorii

Jak zapewne zauważyliście, wybrane przeze mnie czujniki są zamknięte w maleńkich obudowach- ma to bardzo duże znaczenie, ponieważ tylko używając takich jesteśmy w stanie zbudować naprawdę malutkie urządzenie.

Większość elementów zamontowanych na płytce jest zamknięta w obudowach SMD. Wyjątkiem jest jedynie kwarc zegarkowy.

Płytkę narysowałem w programie KiCAD:

PCB zaprojektowałem tak, żebym miał możliwość jej ręcznego wytrawienia w warunkach warsztatowych, i taki prototyp oczywiście powstał. Złącze USB umieściłem z lewej strony zegarka (projekt jest widoczny od spodu), natomiast z prawej strony przyciski do jego obsługi, działające podobnie jak w klasycznych kwarcowych chronografach.

Po przetestowaniu, poprawkach i kilku przeróbkach, zamówiłem poprawioną płytkę

I po zmontowaniu i kąpieli w izopropanolu:

Powyższe płytki nie miały jeszcze magnetometru, został dołożony w ostatnim etapie projektu. Oto render płytki finalnej, oznaczonej numerem 0.5.5

Lista wybranych poprawek wprowadzonych pomiędzy prototypem, a wersją finalną:

1. brak otworów na pasek zegarka- te będą umieszone na podstawie
2. nieco wyższy footprint złącza wyświetlacza- jest teraz kompatybilny z większością dostepnych złączy typu PFC 24.
3. otwory na kwarc zamiast padów SMD- ułożenie kwarcu wymaga trochę siły i przy wcześniejszych wersjach zdarzało mi się urwać pad.
4. Dołożenie footprintu magnetometru oraz elementów mu towarzyszących.
5. Dołożenie czwartego otworu mocującego, pomiędzy przyciskami.
6. Dołożenie prostokątnego otworu na taśmę wyświetlacza.

Rozdział siódmy: Podstawa i maskownica z indeksami

Wyświetlacz jest kwadratowy, a zegarek z założenia ma być okrągły. Pojawiła się więc potrzeba zbudowania zarówno podstawki, jak również maskownicy na którą trzeba w jakiś sposób nanieść indeksy.

Ekran ma rozdzielczość 200x200px i umieszczenie na nim wszystkich indeksów spowodowałoby obniżenie czytelności. Naniesienie indeksów na maskownicę powoduje, że zegarek wygląda znacznie lepiej, a ramka zostaje optycznie zmniejszona. Rysunek zrobiłem także w programie do projektowania PCB.

Co można tutaj znaleźć?

Przede wszystkim indeksy godzin- libra to w końcu zegarek. Pomiędzy nimi są również oznaczone minuty i piąte części sekundy.

Poza nimi od brzegu znajduje się skala tachometryczna- w projekcie przewidziałem również chronograf- wtedy ta skala pozwoli na pomiar na przykład średniej prędkości z jaką się poruszamy.

Przy wewnętrznej krawędzi naniosłem skalę barometru- ciśnienie będzie się odczytywało również analogowo.

Znalazła się też niewielka adnotacja o autorze, oraz wersja zegarka i opcjonalnie numer seryjny egzemplarza.

Maskownica została wycięta frezarką CNC z aluminiowej blachy o grubości 1mm, a indeksy nałożyłem termotrasferem- w dokładnie taki sam sposób jak przed trawieniem płytki PCB. Rozwiązanie okazało się nadzwyczaj trwałe, po 2-miesięcznym użytkowaniu zegarka na codzień nie pojawiły się żadne ubytki.

Oprócz maskownicy potrzebna była jeszcze podstawa- baza zegarka, przez którą będzie przewleczony pasek- chroniąca płytkę i akumulator przed uszkodzeniem. Ta również została wycięta z aluminium.

Rozdział ósmy: Mechanika

Mam już płytkę, obudowę i akumulator. Na każdej z płytek zostały umieszczone w tych samych miejscach otwory na śruby 2mm, co pozwala na złożenie części w całość i skręcenie razem z zakontrowaniem.

W pierwszej wersji niestety pojawił się spory błąd konstrukcyjny, który powodował nadmierne obciążenie wyświetlacza, co w efekcie spowodowało pęknięcie matrycy 🙁

Problem usunąłem w kolejnej wersji, nieco rozszerzając otwory montażowe, a wspomniane obciążenia mechaniczne przeniosłem w całości na nakrętki kontrujące.

Grubość złożonego w ten sposób zegarka wynosi 12mm – nie jest to wcale dużo, spróbujcie zmierzyć swój 🙂

Rozdział dziewiąty: Program i obsługa- ożywiam zegarek

Jak zauważyliście, soft nie był pisany na samym końcu, a w trakcie tworzenia zegarka.

Na szczęście producent wyświetlacza udostępnił bibliotekę do jego obsługi współpracującą z HALem, co bardzo znacząco skróciło proces pisania programu.

Libra jest zegarkiem wzorowanym na modelach wskazówkowych , zatem wszystko zaczęło się od narysowania kółka oraz kilku wskazówek, jeszcze z podstawką wyświetlacza. Wtedy płytka PCB jeszcze nie istniała.

Miała być wyposażona w chronograf, powszechnie nazywany stoperem- potrzebowałem zatem dodatkowych tarcz odmierzających czas.

Poniżej fragment kodu odpowiedzialny za pokazanie wskazówki godzinowej. Do wyświetlania wskazówek w przestrzeni kartezjańskiej znając kąt wychylenia musiałem użyć funkcji trygonometrycznych. Przy okazji dziękuję Hubertowi z Naszej ekipy za support 🙂

Paint_DrawLine(mainStartX, mainStartY,
			(cos(hourAngle) * hourPointerLength) + mainStartX,
			(sin(hourAngle) * hourPointerLength) + mainStartY, colorSecond,
			DOT_PIXEL_3X3, LINE_STYLE_SOLID);
	//^ pointer

Wrzucę jeszcze fotkę interfejsu z tłem w kolorze czarnym. Pierwszą koncepcją było pokazanie odczytów z czujnika jako tekstu. Dodałem też wskaźnik poziomu baterii oraz indeksy wewnętrzne.

Wyjątkowo kłopotliwy okazał się w oprogramowaniu czujnik BME280. Wymaga bowiem odczytu danych kalibracyjnych. Nie dysponowałem biblioteką, więc oprogramowałem go ręcznie

Poniżej funkcja inicjalizująca czujniki wraz z odczytem tych danych:

void sensingInit() {

	uint8_t dig_T[6];
	uint8_t dig_P[18];
	uint8_t dig_H_1;
	uint8_t dig_H_2_6[7];

	//								REDING CALIBRATION DATA

	HAL_I2C_Mem_Read(&hi2c1, BME280_ADDR, BME280_DIG_T1, 1, dig_T, 6,
			i2cTimeout);
	dig_T1 = ((uint16_t) dig_T[0] | (uint16_t) dig_T[1] << 8);
	dig_T2 = ((int16_t) dig_T[2] | (int16_t) dig_T[3] << 8);
	dig_T3 = ((int16_t) dig_T[4] | (int16_t) dig_T[4] << 8);

	HAL_I2C_Mem_Read(&hi2c1, BME280_ADDR, BME280_DIG_P1, 1, dig_P, 18,
			i2cTimeout);
	dig_P1 = ((uint16_t) dig_P[0] | (uint16_t) dig_P[1] << 8);
	dig_P2 = ((int16_t) dig_P[2] | (int16_t) dig_P[3] << 8);
	dig_P3 = ((int16_t) dig_P[4] | (int16_t) dig_P[5] << 8);
	dig_P4 = ((int16_t) dig_P[6] | (int16_t) dig_P[7] << 8);
	dig_P5 = ((int16_t) dig_P[8] | (int16_t) dig_P[9] << 8);
	dig_P6 = ((int16_t) dig_P[10] | (int16_t) dig_P[11] << 8);
	dig_P7 = ((int16_t) dig_P[12] | (int16_t) dig_P[13] << 8);
	dig_P8 = ((int16_t) dig_P[14] | (int16_t) dig_P[15] << 8);
	dig_P9 = ((int16_t) dig_P[16] | (int16_t) dig_P[17] << 8);

	HAL_I2C_Mem_Read(&hi2c1, BME280_ADDR, BME280_DIG_H1, 1, &dig_H_1, 1,
			i2cTimeout);
	dig_H1 = ((unsigned char) dig_H_1);

	HAL_I2C_Mem_Read(&hi2c1, BME280_ADDR, BME280_DIG_H2, 1, dig_H_2_6, 7,
			i2cTimeout);
	dig_H2 = ((int16_t) dig_H_2_6[0] | (int16_t) dig_H_2_6[1] << 8);
	dig_H3 = ((unsigned char) dig_H_2_6[2]);

	dig_H4 =
			(((int16_t) dig_H_2_6[3]) << 4 | (((int16_t) dig_H_2_6[4]) & 0x0f));
	dig_H5 = (((int16_t) dig_H_2_6[4]) >> 4 | ((int16_t) dig_H_2_6[5]) << 4);
	dig_H6 = ((unsigned char) dig_H_2_6[6]);

	HAL_I2C_Mem_Write(&hi2c1, QMC5883L_ADDR, QMC5883L_RESET, 1,
			ctrlMagnetometerReset, 1, i2cTimeout);

}

W załączonym kodzie widać, jak wiele potrzebuje czujnik BME w porównaniu do magnetometru (tylko 43 linijka 🙂 )

Libra posiada także wysokościomierz, który wyjściową daną potrafi podać Nam ze zmierzonego ciśnienia, względem ciśnienia referencyjnego. Jeżeli chcemy zmierzyć aktualną wyskość nad poziomem morza, musimy wprowadzić ciśnienie z takiego poziomu. Wysokość pozwala nam obliczyć wzór barometryczny, który jest zawarty w komentarzu:

//PRESSURE

	HAL_I2C_Mem_Read(&hi2c1, BME280_ADDR, BME280_PRESS_MSB, 1, &pressureMSB, 1,
			i2cTimeout);
	HAL_I2C_Mem_Read(&hi2c1, BME280_ADDR, BME280_PRESS_LSB, 1, &pressureLSB, 1,
			i2cTimeout);
	HAL_I2C_Mem_Read(&hi2c1, BME280_ADDR, BME280_PRESS_XLSB, 1, &pressureXLSB,
			1, i2cTimeout);

	pressureADC = ((((int32_t) pressureMSB << 12) | ((int32_t) pressureLSB << 4)
			| ((int32_t) pressureXLSB >> 4)));

	pressureValue = BME280_compensate_P_int64(pressureADC) / 256;

	/*
	 * barometrical formula:
	 *
	 * p = p0 exp ( -(uhg/RT )
	 * h= -(RT/gu)*ln(p/p0)
	 *
	 * p- pressure[Pa]
	 * p0- reference pressure[Pa]
	 * u- molar mass of air[kg/mol]
	 * h- altitude[m]
	 * g- Earth acceleration[m/s^2]
	 * R- gas constant[J/(mol*K)]
	 * T- air temperature[K]
	 *
	 */

	altitudeValue = -((8.314 * ((float) temperatureValue + 273.15))
			/ (10 * 0.0289))
			* log((float) pressureValue / ((float) pressureReference * 100));

	pressureValue = pressureValue / 100;

Swoją drogą altimetr to ciekawa rzecz. Dowiedziałem się na przykład, że 8 piętro na którym mieszkam znajduje się 30 metrów nad poziomem gruntu.

Odczyt temperatury. Po wstępnych testach okazało się, że pomimo odizolowania płytki PCB od mojej skóry, wynik pomiaru temperatury okazywał się zawyżony (tylko gdy zegarek znajdował się na nadgarstku). Musiałem więc wprowadzić do menu możliwość ustawienia korekty temperatury.

Jeżeli już przy ustawieniach jesteśmy, to doprogramowałem także możliwość zmiany layoutu- jest wybór spośród 3 dostępnych, a także odwrócenia kolorów wyświetlacza. Do ustawień można wejść przyciskając środkowy klawisz. Dolnym przyciskiem przełączamy się pomiędzy pozycjami, górnym dodajemy wartość. Jest również możliwość cofnięcia jeżeli przestrzelimy- trzymamy przycisk +, dociskamy środkowy i trzymając go puszczamy +. Teraz, trzymając przycisk ustawień, plusem cofamy wartość.

Ciśnienie atmosferyczne pokazuje malutka wskazówka ślizgająca się po obwodzie, blisko maskownicy. Na zdjęciach wyżej jest widoczna na poziomie 1003hPa. Wilgotność natomiast jest obrazowana w słupku z prawej strony, obok datownika.

Warto też wspomnieć, że chronograf libry potrafi odmierzać czas do kilku godzin, z dokładnością do 1/10 części sekundy.

Rozdział dziesiąty: akumulator, lifetime i tryby oszczędzania energii

Dobrze by było, żeby zegarek był w stanie wytrzymać chociaż kilka dni.

Pętla główna programu jest napisana w taki sposób, że zegarek po każdym jej przejściu jest usypiany, chyba że trzymamy dolny przycisk (RESET) – w takiej sytuacji ekran odświeża się cały czas, cyklicznie (przydatne przy bardziej precyzyjnym pomiarze czasu). W przeciwym wypadku mikrokontroler przechodzi w tryb STOP- rdzeń przestaje pracować, natomiast podtrzymywana zostaje pamięć RAM oraz praca kwarcu zegarkowego. W takim stanie MCU pobiera z akumulatora kilka mikroamperów prądu. Do tego dochodzi nam ok 60uA pobieranego ze stabilizatora (pamiętajmy, że jest to stabilizator LDO, to i tak niezły wynik 🙂 ), wyświetlacz w stanie uśpienia około 20uA, oraz… no właśnie, pytałem, czy potraficie policzyć prąd pobierany przez dzielnik napięcia omawiany w schemacie. Udało się?

Maksymalny prąd to oczywiście średnio:

3,7V/200000 Ohm = 0,0000182A =~ 0,02mA =~ 20uA.

W sumie w stanie uśpienia z akumulatora pobierany jest prąd 100uA, czyli 0,1 mA. Bardzo malutko.

Jeżeli zegarek nie przechodzi w tryb uśpienia, bo np. weszliśmy do ustawień lub trzymamy przycisk reset- pobór prądu to ok 10mA a więc 100x więcej!

W normalnym trybie rdzeń zostaje wybudzony co 26 sekund, aby odświeżyć godzinę, odczyty z czujników oraz wypalić ekran.

Akumulator jest elementem który ma decydujący wpływ na grubość zegarka. A jednocześnie powinien mieć jak największą pojemność. Zdecydowałem się na użycie ogniwa AKYGA o pojemności 85mAh, który ma zaledwie 2mm grubości.

Z takim akumulatorem zegarek żyje na jednym ładowaniu 11 dni.

Ładowanie trwa około 2 godzin.

Epilog

Libra to wyjątkowy zegarek, który wyróżnia się na tle innych. Nie można go po prostu kupić, trzeba na niego zasłużyć swoimi umiejętnościami i cierpliwością, składając go własnoręcznie. Jego funkcjonalność i wygląd czynią go praktycznym i wyjątkowym, ale trzeba pamiętać też o wadach. Otwarta obudowa nie lubi bezpośredniego działania wody, a mało gładki charakter może powodować zaczepianie się o ubranie np. przy zakładaniu kurtki. Sami zdecydujcie, czy warto 🙂

Już niedługo KIT będzie dostępny na Rezystore 🙂

Ramzes