Ta strona używa ciasteczek (cookies), dzięki którym możliwe jest między innymi poprawne wyświetlanie elementów strony, zapamiętywanie sesji użytkowników. Dodatkowo na stronie znajduje się skrypt Google Analytics oraz PIWIK (statystyki oglądalności). Znajdują się również skrypty przycisków serwisów społecznościowych Facebook, Twitter i Google+ oraz YouTube, które również mogą zapisywać ciasteczka.

Podręczny termometr na DS1820

Na początku swojej przygody z elektroniką, nie specjalnie przywiązywałem wagę do takich "drobnostek" jak temperatura roztworu do wytrawiania płytek PCB. Nie było czasu na podgrzewanie i podtrzymywanie temperatury. Ręce tak świerzbiły że wszystko miało być szybko, bo już teraz ma być zmontowane. Myślę że podobnie ma wiele osób które odkryją jak wielką frajdą jest zbudowanie samodzielnie układu elektronicznego. Z czasem jednak jakość zaczyna zwyciężać nad szybkością. Bo jeszcze większą frajdą jest zaprezentowanie zbudowanego układu który nie dość że działa, to jest jeszcze estetycznie wykonany. Nie tylko z zewnątrz ale też i wewnątrz, od strony montażu.

Jednym z elementów mających wpływ na montaż jest jakość wykonania płytki PCB. Prawidłowo wytrawione ścieżki, pady, punkty lutownicze ułatwiają późniejszy montaż podzespołów elektronicznych. A bezproblemowy montaż ma bezpośredni wpływ na estetykę wykonania układu. Chcąc mieć poprawnie wytrawioną płytkę PCB, należy pilnować temperatury w której ten proces następuje. Zarówno niska temperatura jak i zbyt wysoka mają negatywny wpływ na ostateczną jakość wytrawianej płytki PCB. Oczywiście nie można zapomnieć o starannym przygotowaniu płytki do wytrawienia. Nic nie pomoże pilnowanie temperatury wytrawiania jeśli wzór ścieżek został niedbale przeniesiony na PCB. To jednak temat na inny artykuł.

Wracając do mierzenia temperatury. Potrzebny jest termometr który będzie można zanurzyć w roztworze środka do wytrawiania B237. Można takowy zakupić, ale można i taki samemu zrobić. Ja wybrałem drugą opcję. Zalet takiego rozwiązania jest kilka. Można dowolnie ustalić źródło zasilania, sposób prezentowania odczytu temperatury i dodatkowo podszlifować umiejętność projektowania układu. Konieczność napisania programu do obsługi termometru też nie pozostaje bez znaczenia.

Z racji że nie miałem stałego miejsca w mieszkaniu gdzie bym wytrawiał płytki, wiedziałem że muszę zadbać o możliwość zasilania układu z baterii. Akumulatory AA nie wchodziły w rachubę, bo po prostu nie miałem takowych w pakiecie o potrzebnym napięciu. Posiadałem natomiast kilka pakietów lipo z zabaw w ASG. Oczywiście opcja podłączenia do zasilacza również musiała być uwzględniona w projekcie.

Jako kolejny ważny element musiałem wybrać sposób prezentacji dokonanego pomiaru, wyświetlacz LCD czy może wyświetlacze diodowe siedmiosegmentowe. Zdecydowałem się na 7LED z racji mniejszego rozmiaru, ale też z jakości, jasności wyświetlania.

Następnie przyszedł czas na wybranie mikrokontrolera. Tutaj wybór musiał być dokonany pod kątem użytych wyświetlaczy. Skoro zdecydowałem że będą to wyświetlacze 7LED, to mikrokontroler musiał umożliwiać podłączenia trzech takich wyświetlaczy, oraz układu DS1820. Trzech, ponieważ chciałem móc wyświetlać temperaturę powyżej stu stopni Celsjusza. Oczywiście do określenia temperatury roztworu wystarczyłyby dwa wyświetlacze 7LED, ja jednak chciałem mieć termometr bardziej uniwersalny, bo kto wie do czego może się kiedyś przydać.

Ostatnią rzeczą przed rozpoczęciem projektowania układu i płytki PCB, było znalezienie obudowy. Tak, tak, obudowę należy wybrać zanim się rozpocznie projektowanie PCB. Bo może się okazać że godziny spędzone nad dopieszczaniem rozłożenia elementów na PCB pójdą na marne, ponieważ nie da się znaleźć obudowy o wielkości na której nam zależało lub też będzie musiała ona być o wiele większa niż nasza płytka PCB. Zatem najpierw szukamy obudowy, a najlepiej kilku o różnych rozmiarach aby mieć później większe możliwości manewru przy rozmieszczaniu elementów na PCB.

Gdy już ustaliłem czego będę potrzebował, jakie mam dostępne obudowy, zacząłem rysować schemat. Wykorzytałem do tego celu program Eagle. O wyborze zdecydowała prostota obsługi oraz dostęp do poradników p.Kardasia na YouTube, traktujących o tym programie. Dzięki nim o wiele łatwiej było rozwiązywać pojawiające się drobne problemy.

Z racji że były to też moje początki przejścia na metodę fotochemiczną, przy przygotowywaniu płytki do wytrawienia, zdecydowałem się na użycie mikrokontrolera w obudowie THT.

 

Generalnie obawiałem się problemów jakie mogą powstać podczas naświetlania, spowodowanych małymi odległościami pomiędzy padami mikrokontrolera w obudowie SMD. Druga sprawa to programowanie mikrokontrolera. Bałem się że może być z tym problem gdy będzie on już zamontowany w układzie.

 

Mając już gotowy układ elektroniczny, oczywiście zanim powstał gotowy układ to wszystko testowałem na stykówce, mogłem przejść do pisania programu. Nie ma w tym przypadku jakichś fajerwerków. Cały program został napisany w oparciu o przykłady jakie znajdują się w książce p.Mirosława Kardasia w tak zwanym Bluebooku. Plik main.c ogranicza się do kilku linii kodu:

/*
 * main.c
 *
 *  Created on: 16 paź 2013
 *      Author: Marcin Gibas
 *
 *      Termometr DS18B20
 *      ATtiny2313 wewnętrzny oscylator 8 MHz
 *      Jeden potrójny wyświetlacz 7LED (AT-05636BMR-B)
 *
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "7LED.h"
#include "common.h"
#include "1Wire/ds18x20.h"

int main(void)
{
	init_PWM();  		// funkcja inicjalizująca sprzętowy PWM
	LED_7_init();		// funkcja inicjalizująca wyświetlacze siedmiosegmentowe
	sei();				// włączenie globalnego pozwolenia na przerwania
	search_sensors();	// funkcja sprawdzająca czy jest podpięty czujnik temperatury

	DS18X20_start_meas(DS18X20_POWER_EXTERN, NULL);     // odczyt temperatury, wywołany w tym miejscu po to, aby można było podstawić
														// wynik odczytu do zmiennych które będą wykorzystywane w funkcji "dimmer"

	_delay_ms(1000);	// oczekiwanie około jednej sekundy w celu konwersji temperatury przez czujnik

	dimmer();			// funkcja rozjaśniająca wyświetlacze podczas startu urządzenia

	while(1)			// pętla główna programu w której następuje odczyt temperatury z czujnika i prezentacja wyniku na wyświetlaczach 7LED
	{
		DS18X20_start_meas(DS18X20_POWER_EXTERN, NULL);
		if (!TIMER1)
		{
			TIMER1 = 100;
			display_temp();
		}
	}
}

Program starałem się pisać zgodnie z zasadami poprawnego programowania, między innymi dlatego plik main.c ma tak mało linii kodu. Nie wiem czy mi się ta sztuka udała, ale ile potrafiłem w tamtym czasie w tym temacie, tyle zrobiłem. Reszta potrzebnych funkcji została zawarta w kolejnych plikach, których listingi poniżej. Brakuje tylko bibliotek do obsługi DS1820. Nie będę ich tutaj wklejał, bo są to biblioteki których autorem jest p.Peter Dannegger, i można je znaleźć w sieci. Co prawda p.Kardaś dokonał w nich kilku modyfikacji, ale nie zagłębiałem się jak głębokie są to modyfikacje. Jeżeli będzie taka potrzeba, to wrzucę je na serwer.

/*
 * common.h
 *
 *  Created on: 16 paź 2013
 *      Author: Marcin Gibas
 */
#ifndef COMMON_H_
#define COMMON_H_

extern uint8_t subzero, cel, cel_frac_bits;
extern uint8_t temp, temp1, temp2, temp3;

void error(void);
void display_temp(void);
void dimmer(void);
void init_PWM(void);


#endif /* COMMON_H_ */
/*
 * common.c
 *
 *  Created on: 16 paź 2013
 *      Author: Marcin Gibas
 */

#include <avr/io.h>
#include "7LED.h"
#include "common.h"
#include "1Wire/ds18x20.h"

uint8_t subzero, cel, cel_frac_bits;
uint8_t temp, temp1, temp2, temp3;

// funkcja inicjalizująca sprzętowy PWM w oparciu o 8-bit TIMER0
void init_PWM(void)
{
	TCCR0A |= (1<<WGM00 | 1<<WGM01);    // ustawienie bitów w tryb FastPWM
	TCCR0A |= (1<<COM0B1);					// ustawienie bitu COM0B1 (set OC0B at TOP)
	TCCR0B |= (1<<CS00);					// ustawienie bitu preskalera (bez preskalera)
	OCR0B = 0;									// wpisanie 0 na wyjście PWM

	DDRD |= (1<<PD5);   		// wyjście
	PORTD |= (1<<PD5);			// stan wysoki
}

// funkcja wyświetlająca znaki "minus" w przypadku braku lub błędu odczytu czujnika temperatury
void error(void)
{
	W1 = 20;
	W2 = 20;
	W3 = 20;
}

// funkcja odczytująca temperaturę i pokazująca ją na wyświetlaczach siedmiosegmentowych
void display_temp(void)
{
	if (DS18X20_OK == DS18X20_read_meas(gSensorIDs[0], &subzero, &cel, &cel_frac_bits))// sprawdzenie poprawności odczytu, jeżli jest prawidłowy
																								// wykonywane są dalsze bloki funkcji
	{
		temp = cel / 10; 			// obliczenie zmiennej "temp" która będzie zawierała jedności
		temp1 = cel % 10; 			// obliczenie reszty z dzielenia modulo
		if (temp != 0) 				// sprawdzenie czy zmienna "temp" jest różna od zera
		{
			W1 = temp; 				// jeśli tak oznacza to że temperatura jest powyżej 10 stopni C, wyświetlacz W1 wyświetla jedności
		}
		else
		{
			W1 = 22; 				// jeżli nie, temperatura poniżej 10 stopni C, wyświetlacz W1 jest wyłączony
		}
		W2 = temp1 + 10; 		// wyświetlacz W2 wyświetla drugą cyfrę temperatury uzyskaną z dzielenia madulo do której jest dodana liczba 10, w celu
								// uzyskania kropki dziesiętnej, wynika to z ustawień tablicy w której są przechowywane znaki dla wyświetlaczy
		W3 = cel_frac_bits; 	// wyświetlacz W3 pokazuje dziesiętne części stopnia
		if (temp >= 10)			// sprawdzenie czy zmienna "temp" jest większa lub równa 10 (temperatura powyżej 100 stopni Celcjusza)
		{
			temp2 = temp/10;	// jeżli tak, zmienna "temp" zostaje podzielona przez 10 żeby uzyskać jedności
			temp3 = temp%10;	// oraz zostaje wykonana operacja na tej zmiennej dzielenia z modulo w celu uzyskania drugiej cyfry pomiaru
			W1 = temp2;
			W2 = temp3;
			W3 = temp1;
		}
		if (subzero && temp != 0) 	// sprawdzenie czy temperatura jest minusowa i czy zmienna "temp" jest różna od zera
		{
			W1 = 20;				// jeżli oba warunki są spełnione, oznacza to że temperatura wynosi poniżej -10 stopni C
									// W1 wyświetla znak "minus"
			W2 = temp;				// W2 wyświetla jedności
			W3 = temp1;				// W3 wyświetla drugą cyfrę temperatury
		}
		if (subzero && temp == 0) 	// sprawdzenie czy temperatura jest minusowa i czy zmienna "temp" jest równa 0
		{
			W1 = 20; 				// jeśli tak, oznacza to że temperatura jest wyższa od -10 stopni C
									// W1 wyświetla znak "minus"
		}
	}
	else						// w przypadku błędu odczytu z czujnika następuje skok do funkcji "error"
	{
		error();
	}
}

//funkcja rozjaśniająca i ściemniająca wyświetlacze 
void dimmer(void)
{
	uint8_t i = 0;			// zmienna wykorzystywana podczas ikrementacji wyjścia PWM
	W1 = 23;
	W2 = 1;
	for(;;)					// pętla nieskończona w której następuje rozjaśnienie napisu "HI"
	{
		if (!TIMER1)
		{
			TIMER1 = 2;
			OCR0B = i;
			i ++;
			if(i == 255)	// jeśli nastąpi maksymalne rozjaśnienie wyświetlaczy
			{
				TCCR0A &= ~(1<<COM0B1);   // zostaje wyłączony bit w rejestrze TCCR0A, wyłączający PWM na wyjściu PD5
				break;					 		 // pętla zostaje przerwana i następuje przeskok do kolejnego bloku w funkcji
			}
		}
	}
	TCCR0A |= (1<<COM0B1);				// bit COM0B1 zostaje powtórnie włączony
	for(;;)									// pętla nieskończona w której następuje wygaszenie napisu "HI"
	{
		if (!TIMER1)
		{
			TIMER1 = 2;
			OCR0B = i;
			i--;
			if(i == 0)								// jeśli nastąpi maksymalne wygaszenie wyświetlaczy
			{
				TCCR0A &= ~(1<<COM0B1);		// zostaje wyłączony bit w rejestrze TCCR0A, wyłączający PWM na wyjściu PD5
				break;								// pętla zostaje przerwana i następuje przeskok do kolejnego bloku funkcji
			}
		}
	}
	TCCR0A |= (1<<COM0B1);				// bit COM0B1 zostaje włączony
	for(;;)									// pętla nieskończona w której zostają rozjaśnione wyświetlacze do maksimum podczas startu urządzenia,
	{
		if (!TIMER1)
		{
			TIMER1 = 2;
			display_temp();							// odczyt temperatury
			OCR0B = i;
			i ++;
			if (i == 255)							// jeśli wyświetlacze osiągną maksymalny stopień świecenia
			{
				TCCR0A &= ~(1<<COM0B1);		// zostaje wyłączony PWM na wyjściu PD5
				break;								// przerwanie pętli i opuszczenie funkcji
			}

		}
	}
}
/*
 * 7LED.h
 *
 *  Created on: 16 paź 2013
 *      Author: Marcin Gibas
 */

#ifndef _7LED_H_
#define _7LED_H_

#define KATODY_DDR DDRB						// definicja kierunku wejście/wyjście katod wyświetlacza
#define KATODY_PORT PORTB					// definicja portu katod wyświetlacza
#define SEG_A (1<<PB0)					// definicja pinu segmentu A
#define SEG_B (1<<PB7)					// definicja pinu segmentu B
#define SEG_C (1<<PB4)					// definicja pinu segmentu C
#define SEG_D (1<<PB2)					// definicja pinu segmentu D
#define SEG_E (1<<PB1)					// definicja pinu segmentu E
#define SEG_F (1<<PB6)					// definicja pinu segmentu F
#define SEG_G (1<<PB5)					// definicja pinu segmentu G
#define SEG_DP (1<<PB3)					// definicja pinu segmentu kropki

#define ANODY_DDR DDRD						// definicja kierunku wejście/wyjście anod wyświetlacza
#define ANODY_PORT PORTD					// definicja portu anod wyświetlacza
#define ANODA1 (1<<PD2)					// definicja pinu anody pierwszego wyświetlacza
#define ANODA2 (1<<PD1)					// definicja pinu anody drugiego wyświetlacza
#define ANODA3 (1<<PD0)					// definicja pinu anody trzeciego wyświetlacza

extern volatile uint8_t TIMER1;				// zmienna wykorzystywana jako timer programowym
extern volatile uint8_t W1, W2, W3; 		// zmienne określające pojedyńczy wyświetlacz 7LED


void LED_7_init(void);

#endif /* 7LED_H_ */
/*
 * 7LED.c
 *
 *  Created on: 16 paź 2013
 *      Author: Marcin Gibas
 */

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include "7LED.h"

volatile uint8_t TIMER1;				// zmienna wykorzystywana jako timer programowy
volatile uint8_t W1, W2, W3; 			// zmienne określające pojedyńczy wyświetlacz 7LED

// Tablica w której są ustawione bity do poszczególnych znaków wyświetlanych na wyświetlaczach przechowywana w pamięci FLASH

uint16_t const znaki[] PROGMEM = {
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F), 						// 0 - 0
~(SEG_B | SEG_C), 														// 1 - 1
~(SEG_A | SEG_B | SEG_G | SEG_E | SEG_D), 								// 2 - 2
~(SEG_A | SEG_B | SEG_G | SEG_C | SEG_D), 								// 3 - 3
~(SEG_F | SEG_G | SEG_B | SEG_C), 										// 4 - 4
~(SEG_A | SEG_F | SEG_G | SEG_C | SEG_D), 								// 5 - 5
~(SEG_A | SEG_F | SEG_E | SEG_D | SEG_C | SEG_G), 						// 6 - 6
~(SEG_A | SEG_B | SEG_C), 												// 7 - 7
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G), 				// 8 - 8
~(SEG_G | SEG_F | SEG_A | SEG_B | SEG_C | SEG_D), 						// 9 - 9
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F	| SEG_DP), 				// 0. - 10
~(SEG_B | SEG_C | SEG_DP), 												// 1. - 11
~(SEG_A | SEG_B | SEG_G | SEG_E | SEG_D | SEG_DP), 						// 2. - 12
~(SEG_A | SEG_B | SEG_G | SEG_C | SEG_D | SEG_DP), 						// 3. - 13
~(SEG_F | SEG_G | SEG_B | SEG_C | SEG_DP), 								// 4. - 14
~(SEG_A | SEG_F | SEG_G | SEG_C | SEG_D | SEG_DP), 						// 5. - 15
~(SEG_A | SEG_F | SEG_E | SEG_D | SEG_C | SEG_G | SEG_DP), 				// 6. - 16
~(SEG_A | SEG_B | SEG_C | SEG_DP), 										// 7. - 17
~(SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_DP), 		// 8. - 18
~(SEG_G | SEG_F | SEG_A | SEG_B | SEG_C | SEG_D | SEG_DP), 				// 9. - 19
~(SEG_G), 																// - - 20
~(SEG_DP), 																// . - 21
 (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_DP),	 	// wyświetlacz wyłączony - 22
~(SEG_B | SEG_C | SEG_E | SEG_F | SEG_G),								// litera H - 23
};

// Koniec tablicy

// funkcja w której następuje inicjalizacja portów pod które są podłączone wyświetlacze oraz Timera do multipleksowania
void LED_7_init(void)
{
	KATODY_DDR |= (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_DP);		// ustawienie kierunku - wyjście
	KATODY_PORT |= (SEG_A | SEG_B | SEG_C | SEG_D | SEG_E | SEG_F | SEG_G | SEG_DP);	// ustawienie jedynki na katody
	ANODY_DDR |= (ANODA1 | ANODA2 | ANODA3);											// ustawienie kierunku - wyjście
	ANODY_PORT &= ~(ANODA1 | ANODA2 | ANODA3);											// ustawienie zera na anody

	// Konfiguracja Timera1 do multipleksowania wyświetlaczy 7LED
	// Timer1 został użyty tylko dlatego że wynikało to z podłączenia wyświetlaczy do mikrokontrolera i użycia trybu PWM
	// do wygaszania wyświetlaczy

	TCCR1A |= (1<<WGM12);					// ustawienie Timera w tryb CTC
	TCCR1B |= (1<<CS10);					// ustawienie preskalera Timera1 na wartość 1
	OCR1A = 26666;								// obliczenie podziału: (taktowanie zegara/preskaler/częstotliowść odświeżania) (8000000/1/300 = OCR1A)
	TIMSK |= (1<<OCIE1A);					// zezwolenie na przerwanie Compare Match

	// Koniec konfiguracji Timera do multipleksowania

	// początkowe ustawienie wyświetlaczy na wyłączone
	W1 = 22;
	W2 = 22;
	W3 = 22;
}

// wektor przerwania
ISR(TIMER1_COMPA_vect)
{
	uint8_t ms;							// zmienna wykorzystywana w timerze programowym, inicjalizowana wartością około 3,3 ms (1000 / 300)

	static uint8_t licznik = 1;			// zmienna określająca licznik wykorzystywana przy multipleksowaniu, inicjalizowana wartością 1

	ms = TIMER1;
	if (ms)
	{
		TIMER1 = -- ms;
	}

	/* Odświeżanie wyświetlaczy z częstotliwością około 50Hz na każdy
	 * Licznik startuje od 4, ponieważ anody wyświetlaczy nie są połączone w sposób:
	 * ANODA1 == PIN1, lecz w tym przypadku ANODA1 == PIN3. Dlatego licznik musi na początku
	 * przyjąć wartość 4 co odpowiada pinowi PD2 do którego jest podłączony pierwszy wyświetlacz.
	 */
	ANODY_PORT = ~licznik;
	if (licznik == 4)
	{
		KATODY_PORT = pgm_read_byte ( &znaki[W1] );
	}
	else if (licznik == 2)
	{
		KATODY_PORT = pgm_read_byte ( &znaki[W2] );
	}
	else if (licznik == 1)
	{
		KATODY_PORT = pgm_read_byte ( &znaki[W3] );
	}
	licznik <<= 1;
	if (licznik > 4)
		licznik = 1;
}

Kod programu nie jest zapewne napisany super optymalnie, no ale jak to bywa na początku nauki programowania, optymalizacja jest ostatnią rzeczą na którą się zwraca uwagę. Ważne żeby działało. A działa wyśmienicie.

Jak wspominałem we wstępie, termometr znalazł zastosowanie w innym miejscu. Okazał się pomocny w mierzeniu temperatury na piecu w kotłowni. Teściowie mają kotłownię w piwnicy a w niej zwykły piec. Oznacza to że trzeba chodzić do piwnicy aby sprawdzać co się dzieje z temperaturą. Trochę to uciążliwe. Wpadłem więc na pomysł aby użyć tego termometru właśnie do pomiaru temperatury na piecu. Czujnik miał być zainstalowany na rurze w piwnicy rozprowadzającej wodę po grzejnikach, a wyświetlacz w mieszkaniu. Martwiła mnie długość przewodu na którym miał być zainstalowany DS1820. Obawiałem się że tak duża odległość może stwarzać problemy z poprawnym działaniem czujnika. Na szczęście, po wstępnych próbach, obawy te okazały się płonne.

Mogłem więc przystąpić do zbudowania kolejnego termometru. Nie poszedłem jednak na łatwiznę i nie zmontowałem układu identycznego jak ten którego używałem do pomiarów roztworu do wytrawiania. Uznałem że muszę zostawić sobie furtkę, która da mi możliwość przeprogramowania układu w razie jakichś kłopotów z odczytem temperatury. Wylutowywanie mikrokontrolera nie wchodziło w rachubę, był on pod wyświetlaczem 7LED. Jedyne sensowne rozwiązanie to wyprowadzenie pinów połączonych z liniami programowania mikrokontrolera. Musiałem więc przeprojektować płytkę i dodatkowo użyć mikrokontrolera w SMD, aby cały układ zmieścił się w starej obudowie. Na szczęście metodę fotochemiczną przygotowywania płytki PCB do trawienia miałem już opanowaną, dlatego bez obaw mogłem przystąpić do przeprojektowania układu. Efekty tych zmian można zobaczyć na zdjęciach poniżej.

   

Niestety nie pomyślałem o jednej ważnej funkcjonalności całego układu. Mianowicie o zmniejszeniu intensywności świecenia wyświetlacza gdy w pomieszczeniu w którym jest zamontowany zrobi się ciemno. Swojego termometru nie używałem w zupełnych ciemnościach. Dlatego umknęło mi to że te trzy kostki 7LED mogą tak mocno świecić. Ostatecznie okazało się że nie jest to wielki problem, ponieważ w nocy nikt do pieca nie biegał, a więc można było spokojnie termometr na noc wyłączać. Nie zmienia to jednak faktu że automatyczne ściemnianie byłoby fajnym, przydatnym bajerem. W następnych projektach w których używałem wyświetlaczy 7LED, była to pierwsza rzecz o której myślałem projektując układ.

Na koniec jeszcze dodam że termometr na piecu pracuje po dziś dzień.

Tags: AVR, DS1820

Drukuj E-mail

Komentarze   

#2 Marcin 2018-07-12 21:41
Tak, mam tą bibliotekę.
Cytować
#1 Bartek 2018-07-11 10:41
Czy ma Pan może jeszcze bibliotekę do obsługi ds18b20 użytą w tym projekcie
Cytować

Dodaj komentarz


Kod antyspamowy
Odśwież