Kursy • Poradniki • Inspirujące DIY • Forum

Premiera: Raspberry Pi
Debug Probe

Historia tranzystora w skrócie.
Wynalezienie czy odkrycie?

3 podstawowe rodzaje
akumulatorów, które warto znać

Co ciekawego w DIY?
10 projektów naszych czytelników #33

Piezoelektryki – czym
są materiały piezoelektryczne?

Tranzystory

Poznaj w praktyce

Raspberry Pi

Od podstaw

Kursy Artykuły

DIY Forum

Kurs STM32 – #11 – I2C w praktyce, pamięć eeprom

Archiwum Elvis

Wcześniej poznaliśmy dwa interfejsy szeregowe: UART i SPI. Pierwszy wymagał tylko dwóch linii, ale był dość powolny. Drugi działał bardzo szybko wykorzystując więcej wyprowadzeń.

Teraz zajmiemy się I²C, który kwalifikuje się gdzieś pomiędzy wcześniejszymi interfejsami.

Poprzednia część

Nawigacja kursu Nawigacja

Następna część

Kurs STM32 – #1 – Zaczynamy! Spis Treści Kurs STM32 – #2 – Podstawowe informacje o STM32 Kurs STM32 – #3 – Płytka Nucleo, konfiguracja środowiska Kurs STM32 – #4 – Sterowanie portami GPIO w praktyce Kurs STM32 – #5 – Komunikacja z komputerem, UART Kurs STM32 – #6 – Pomiar napięcia, przetwornik ADC Kurs STM32 – #7 – Liczniki (timery) w praktyce, PWM Kurs STM32 – #8 – DMA, czyli bezpośredni dostęp do pamięci Kurs STM32 – #9 – SPI w praktyce, ekspander I/O Kurs STM32 – #10 – SPI w praktyce, wyświetlacz graficzny Kurs STM32 – #11 – I2C w praktyce, pamięć eeprom Kurs STM32 – #12 – I2C w praktyce, akcelerometr Kurs STM32 – #13 – Podsumowanie, QUIZ Polecana kontynuacja: Kurs STM32 F4 (HAL i CUBE)

Uwaga! Ten kurs został zarchiwizowany. Sprawdź najnowszy kurs STM32 »

Na początku wykorzystamy I²C (czytaj: i kwadrat ce) do komunikacji z pamięcią EEPROM, a później z akcelerometrem. Przykład z pamięcią EEPROM jest bardzo ważny.

Osoby przyzwyczajone do programowania układów AVR częśto zapominają, że STMy nie są wyposażone w wewnętrzną pamięć EEPROM!

Główny bohater odcinka - pamięć EEPROM.

I²C - Najważniejsze informacje

Interfejs I²C podobnie do SPI działa w sposób synchroniczny. Oznacza to, że sygnał zegarowy jest przesyłany między układami, co odróżnia go od UART-a, który musiał polegać na zegarach wbudowanych w komunikujące się układy.

Projektanci interfejsu postanowili ograniczyć liczbę niezbędnych linii, ale jednocześnie umożliwić podłączanie wielu układów do wspólnego interfejsu. Wymagania na pierwszy rzut oka mogą się wydawać sprzeczne. Jednak ostatecznie założony cel został osiągnięty (niestety kosztem większej komplikacji protokołu).

W kursie opiszemy I2C najprościej jak się da, bez wnikania w szczegóły. Osoby zainteresowane wykorzystaniem I2C w swoich projektach powinny potraktować ten artykuł raczej jako wstęp, a nie wyczerpujące kompendium wiedzy.

Tak samo jak w przypadku SPI układy komunikujące się przez I²C dzielą się na 2 kategorie: układów nadrzędnych (ang. master) oraz podrzędnych (ang. slave). Do jednego interfejsu może być jednocześnie podłączonych kilka układów nadrzędnych, my skupimy się na prostej wersji z jednym układem master, którym będzie nasz mikrokontroler.

Gotowe zestawy do kursów Forbota

Komplet elementów Gwarancja pomocy Wysyłka w 24h

Zestaw ponad 120 elementów do przeprowadzenia wszystkich ćwiczeń z kursu można nabyć u naszych dystrybutorów! Dostępne są wersje z płytką Nucleo lub bez niej!

Zamów w Botland.com.pl »

Masz już zestaw? Zarejestruj go wykorzystując dołączony do niego kod. Szczegóły »

Podłączenie magistrali I²C

Schemat podłączenia układów do I²C wygląda następująco:

Magistrala I2C.

Jak widać wykorzystywane są dwie linie komunikacyjne (Vdd, to zasilanie):

SDA - dwukierunkowa linia danych
SCL - linia zegarowa sterowana przez układ nadrzędny

W przypadku SPI do przesyłania danych wykorzystywane były dwie linie danych MOSI i MISO. Dzięki temu jednocześnie można było wysyłać i odbierać informacje. Taki tryb działania nazywany jest full-duplex. I²C posiada tylko jedną linię danych, więc w danej chwili można na niej tylko wysyłać lub odbierać dane.

Jest to tryb half-duplex - więcej o nim można przeczytać na Wikipedii.

Najczęściej wyjścia mikrokontrolera są używane w tzw. trybie przeciwsobnym. Jeśli na wyjściu jest logiczne 0, odpowiednie wyprowadzenie jest zwierane do masy, logiczna 1 natomiast to połączenie z zasilaniem (3.3V).

W takiej sytuacji połączenie wyjść dwóch układów może łatwo prowadzić do zwarcia. Jeśli jeden układ będzie próbował wystawić logiczne 0, a drugi 1, nastąpi zwarcie między masą i zasilaniem. Aby tego uniknąć konieczna jest synchronizacja dostępu do interfejsu i zapobieganie jednoczesnym zapisom do wspólnej linii. W przypadku SPI do takiej synchronizacji były wykorzystywane linie CS - tylko jeden układ slave mógł w danym momencie sterować linią MISO.

Ponieważ I²C nie wykorzystuje sygnałów CS, konieczne było znalezienie innej metody współdzielenia linii. Wykorzystano w tym celu wyjście typu otwarty kolektor (open drain). Oznacza to, że gdy mikrokontroler wystawia na pinie logiczne 0, linia jest zwierana do masy. Natomiast logiczna 1 zamiast zwierać wyście do zasilania, pozostawia linię niepodłączoną - dokładnie tak samo, jak podczas pracy linii jako wejścia.

Niepodłączona linia to nic dobrego, konieczne jest więc zastosowanie zewnętrznych rezystorów podciągających!

Sposób działania linii magistrali I²C

Jeśli którykolwiek z układów podłączonych do danej linii interfejsu wystawi logiczne 0, cała linia jest zwierana do masy. Natomiast kiedy wszystkie układy wystawiają wartość 1, linia za pomocą rezystora jest łączona z zasilaniem i pojawia się na niej napięcie 3.3 V.

W przypadku I²C trzeba pamiętać o zewnętrznych rezystorach podciągających.
Bez nich układ nie będzie działać.

Kolejne etapy komunikacji przez I²C

Komunikacja przez I²C wygląda następująco:

Układ nadrzędny rozpoczyna komunikację poprzez wystawienie sygnału START - jest to specjalna kombinacja przebiegów na liniach SDA i SCL informująca o początku transmisji.
Następnie wysyła adres układu z którym chce się komunikować oraz bit informujący o kierunku transmisji (nadawanie albo odbiór). Układ podrzędny odpowiada wysyłając bit potwierdzenia ACK.
Po wybraniu układu, następuje właściwa transmisja:
1. jeśli zostało wybrane nadawanie, master wysyła kolejne bajty, a slave potwierdza odebranie każdego bitem ACK
2. w przypadku odbioru, slave wysyła kolejne bajty, a master odbiera i potwierdza za pomocą ACK
Na koniec master wysyła sygnał STOP informujący o zakończeniu transmisji

Są jeszcze dwie rzeczy, które zostały pominięte w powyższym opisie - jeśli master chce zacząć kolejną transmisję natychmiast po poprzedniej, może pominąć końcowe STOP i od razu wysłać kolejne START.

Druga sprawa to potwierdzenia - pisałem o ACK, ale istnieje jeszcze negatywne potwierdzenie NACK. Najczęściej informuje ono o końcu danych, przykładowo master odczytując dane powinien potwierdzać odbiór za pomocą ACK, poza ostatnim bajtem, kiedy powinien odesłać NACK tak, aby slave wiedział, że nie musi już więcej danych wysyłać.

Gdy wiemy już jak działa ten nowy (w naszym kursie) interfejs możemy przejść do praktyki. Teraz zajmiemy się pamięcią eeprom, a w kolejnym odcinku przyjdzie pora na akcelerometr cyfrowy.

Pamięć EEPROM

Jako pierwszy przykład wykorzystamy komunikację z pamięcią EEPROM, układem typu 24AA01. Jak zawsze należy zacząć od przeczytania dokumentacji. Jest to relatywnie mała pamięć nieulotna o pojemności 128B. Może się to wydawać niewiele w dobie dysków o pojemności TB, jednak taka pamięć jest zaskakująco użyteczna.

Nawet tak mała pojemność wystarczy do przechowywania np. numeru seryjnego urządzenia, daty produkcji, czy hasła dostępu.

Oczywiście w mikrokontrolerze znajdziemy dużo więcej pamięci nieulotnej typu Flash, którą moglibyśmy wykorzystać do przechowywania danych. Jednak pamięć Flash ma dość ograniczoną liczbę cykli zapisu. W przypadku STM32F103 producent deklaruje 10000 cykli zapisu, więc jeśli chcielibyśmy w tej pamięci przechowywać dane, które często zmieniamy, moglibyśmy szybko przekroczyć ten limit. Dla porównania - nasza pamięć EEPROM wytrzyma aż 1000000 cykli zapisu. Poza tym łatwiej ją wymienić niż cały mikrokonotroler.

Przyjrzyjmy się wyprowadzeniom układu 24AA01:

Opis wyprowadzeń pamięci eeprom.

Linie Vss i Vcc to odpowiednio masa i zasilanie. SCL i SDA to linie naszego interfejsu I2C. WP oznacza Write Protect i musi być połączona z masą, jeśli chcemy mieć możliwość zapisu do pamięci EEPROM. Są jeszcze trzy wyprowadzenia adresowe A0, A1, A2 - nie są one używane w układzie 24AA01 i mogą pozostać niepodłączone.

Podłączenie układu

Układ powinniśmy podłączyć zgodnie z poniższym rysunkiem.

Do komunikacji z pamięcią EEPROM wykorzystamy interfejs I2C1. Jego linie SCL i SDA są dostępne na pinach PB6 i PB7.

Należy pamiętać o konieczności podpięcia rezystorów podciągających (3.3kΩ).

Zapis do pamięci

Schemat komunikacji z układem 24AA01 znajdziemy we wspomnianej wcześniej dokumentacji. Poniżej umieściłem najważniejszy dla nas datagram:

Sposób zapisu do pamięci EEPROM przez I2C.

Jak widzimy, jest to typowa komunikacja za pomocą I2C. Najpierw wysyłamy sygnał START. Po nim adres urządzenia wraz z bitem kierunku transmisji. Przy nadawaniu (zapisie) jest to zero, a przy odbiorze (odczycie) jedynka.

Podczas zapisywania danych powinniśmy odwołać się do adresu 0xA0, a odczytywać z 0xA1.

Układ pamięci odpowiada przesyłając potwierdzenie ACK. Następnie wysyłamy adres komórki pamięci, do której chcemy zapisywać. Pamiętamy przy tym, że dostępnych jest (aż) 128 adresów. Pamięć ponownie potwierdza odbiór danych za pomocą ACK.

Następnie wysyłamy jedną lub więcej wartości, każda jest potwierdzana za pomocą ACK. Na koniec wysyłamy STOP, aby zakończyć transmisję i umożliwić pamięci rzeczywisty zapis danych.

Zapis do pamięci jest stosunkowo powolny, dodatkowo przesyłając więcej niż jeden bajt należy brać pod uwagę wielkość licznika oraz adresowanie stron. Więcej informacji znajdziemy w dokumentacji układu.

STM32 i EEPROM - zapis danych w praktyce

Wiemy już jak ma wyglądać transmisja, teraz możemy przejść do jej implementacji na naszym mikrokontrolerze. Jak zwykle zaczynamy od podłączenia odpowiedniego sygnału zegarowego:

RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

1	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

Konfigurujemy piny PB6 i PB7 do pracy z interfejsem I2C. Tryb którego użyjemy to open-drain:

GPIO_StructInit(&gpio);
gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA
gpio.GPIO_Mode = GPIO_Mode_AF_OD;
gpio.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &gpio);

GPIO_StructInit(&gpio);

gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA

gpio.GPIO_Mode = GPIO_Mode_AF_OD;

gpio.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOB, &gpio);

Kolejny krok to zadeklarowanie zmiennej konfigurującej i2c oraz inicjalizacja modułu. Jest to dość proste, ponieważ w większości wykorzystamy domyślne opcje:

I2C_InitTypeDef i2c;	

I2C_StructInit(&i2c);
i2c.I2C_Mode = I2C_Mode_I2C;
i2c.I2C_ClockSpeed = 100000;
I2C_Init(I2C1, &i2c);
I2C_Cmd(I2C1, ENABLE);

I2C_InitTypeDef i2c;

I2C_StructInit(&i2c);

i2c.I2C_Mode = I2C_Mode_I2C;

i2c.I2C_ClockSpeed = 100000;

I2C_Init(I2C1, &i2c);

I2C_Cmd(I2C1, ENABLE);

Wybrana prędkość, to 100kHz. Maksymalna dla naszego układu wynosi 400kHz, jednak wtedy dość długie przewody łączące mogłyby spowodować problemy z komunikacją.

Aby rozpocząć transmisję, wysyłamy sygnał START i czekamy, aż I²C wykona nasze polecenie:

I2C_GenerateSTART(I2C1, ENABLE);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

1 2	I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

Zaprezentowane procedury są bardzo uproszczone. Nie obsługują błędów, więc w przypadku braku odpowiedzi, program może się zawiesić. Należy o tym pamiętać pisząc kod dla bardziej zaawansowanych aplikacji.

Następnie wysyłamy adres (identyfikator) układu i czekamy na odpowiedź:

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

1 2	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

Teraz możemy przesłać adres komórki pamięci, do której będziemy chcieli zapisywać dane. Przykładowo zapiszmy je pod adresem zerowym:

I2C_SendData(I2C1, 0x00);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

1 2	I2C_SendData(I2C1, 0x00); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

Dalej wysyłam jedną lub więcej wartość. Adres zapisywanej komórki pamięci będzie automatycznie zwiększany, więc do komórki o adresie 0x00 zapiszmy 0xCA, a do 0x01 wartość 0xFE:

I2C_SendData(I2C1, 0xca);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
I2C_SendData(I2C1, 0xfe);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

I2C_SendData(I2C1, 0xca);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

I2C_SendData(I2C1, 0xfe);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

Ponieważ w naszym przykładzie nic więcej nie robimy, możemy zakończyć komunikację wysyłając sygnał STOP:

I2C_GenerateSTOP(I2C1, ENABLE);

1	I2C_GenerateSTOP(I2C1, ENABLE);

Pełny kod powyższego przykładu zamieszczony jest poniżej:

#include "stm32f10x.h"
			
int main(void)
{
	GPIO_InitTypeDef gpio;
	I2C_InitTypeDef i2c;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

	GPIO_StructInit(&gpio);
	gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA
	gpio.GPIO_Mode = GPIO_Mode_AF_OD;
	gpio.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &gpio);

	I2C_StructInit(&i2c);
	i2c.I2C_Mode = I2C_Mode_I2C;
	i2c.I2C_ClockSpeed = 100000;
	I2C_Init(I2C1, &i2c);
	I2C_Cmd(I2C1, ENABLE);

	I2C_GenerateSTART(I2C1, ENABLE);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

	I2C_SendData(I2C1, 0x00);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

	I2C_SendData(I2C1, 0xca);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
	I2C_SendData(I2C1, 0xfe);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
	I2C_GenerateSTOP(I2C1, ENABLE);

	while (1)
		;
}

#include "stm32f10x.h"

int main(void)

{

GPIO_InitTypeDef gpio;

I2C_InitTypeDef i2c;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

GPIO_StructInit(&gpio);

gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA

gpio.GPIO_Mode = GPIO_Mode_AF_OD;

gpio.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOB, &gpio);

I2C_StructInit(&i2c);

i2c.I2C_Mode = I2C_Mode_I2C;

i2c.I2C_ClockSpeed = 100000;

I2C_Init(I2C1, &i2c);

I2C_Cmd(I2C1, ENABLE);

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

I2C_SendData(I2C1, 0x00);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

I2C_SendData(I2C1, 0xca);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

I2C_SendData(I2C1, 0xfe);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

I2C_GenerateSTOP(I2C1, ENABLE);

while (1)

;

}

Program niestety nie da widocznych efektów. Aby sprawdzić jego działanie musimy nauczyć się odczytywać dane.

STM32 i EEPROM - odczyt danych w praktyce

W poprzednim przykładzie zapisaliśmy przykładowe dane 0xCA oraz 0xFE do pamięci. Teraz spróbujemy je odczytać i sprawdzimy, czy wartości się zgadzają. Ponownie, przebieg odczytu jest opisany w dokumentacji układu pamięci. Odpowiedni diagram widzimy poniżej:

Sposób odczytu do pamięci EEPROM przez I2C.

Najpierw musimy ustalić adres, spod którego wczytamy dane. Wymaga to przesłania danych z mastera do slave-a, więc musimy najpierw wykonać zapis. Wysyłamy więc START, następnie adres układu oraz adres komórki pamięci, którą chcemy odczytać.

Poprzednio omówiliśmy już potrzebne instrukcje:

I2C_GenerateSTART(I2C1, ENABLE);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

I2C_SendData(I2C1, 0x00);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

I2C_SendData(I2C1, 0x00);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

Teraz układ 24AA01 w wewnętrznym rejestrze zapamięta wartość 0x00 jako adres, spod którego będziemy mogli odczytywać dane. Ponieważ chcemy zmienić kierunek komunikacji musimy zacząć od początku, czyli wysłania sygnału START:

I2C_GenerateSTART(I2C1, ENABLE);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

1 2	I2C_GenerateSTART(I2C1, ENABLE); while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

Następnie przesyłamy identyfikator układu pamięci, ale z ustawionym bitem odczytu. Nie musimy ręcznie modyfikować adresu, funkcja I2C_Send7bitAddress() zajmie się tym za nas, jeśli podamy kierunek transmisji I2C_Direction_Receiver:

I2C_AcknowledgeConfig(I2C1, ENABLE);
I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);
while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

I2C_AcknowledgeConfig(I2C1, ENABLE);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

Dodatkowo włączyliśmy odsyłanie potwierdzeń ACK do układu slave. Więc będzie on przysyłał kolejne bajty, aż wyślemy STOP lub wyłączymy potwierdzenia.

Wczytujemy pierwszy odebrany bajt:

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
uint8_t data1 = I2C_ReceiveData(I2C1);

1 2	while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS); uint8_t data1 = I2C_ReceiveData(I2C1);

Podobnie moglibyśmy wczytywać kolejne, poza ostatnim, ponieważ po nim nie powinniśmy odsyłać potwierdzenia - jak widzimy przed STOP powinniśmy zamiast ACK odpowiedzieć NACK.

Piszemy więc odpowiedni kod:

I2C_AcknowledgeConfig(I2C1, DISABLE);
I2C_GenerateSTOP(I2C1, ENABLE);
while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
uint8_t data2 = I2C_ReceiveData(I2C1);

I2C_AcknowledgeConfig(I2C1, DISABLE);

I2C_GenerateSTOP(I2C1, ENABLE);

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);

uint8_t data2 = I2C_ReceiveData(I2C1);

Całość wygląda następująco:

#include "stm32f10x.h"

int main(void)
{
	GPIO_InitTypeDef gpio;
	I2C_InitTypeDef i2c;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

	GPIO_StructInit(&gpio);
	gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA
	gpio.GPIO_Mode = GPIO_Mode_AF_OD;
	gpio.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &gpio);

	I2C_StructInit(&i2c);
	i2c.I2C_Mode = I2C_Mode_I2C;
	i2c.I2C_Ack = I2C_Ack_Enable;
	i2c.I2C_ClockSpeed = 100000;
	I2C_Init(I2C1, &i2c);
	I2C_Cmd(I2C1, ENABLE);

	I2C_GenerateSTART(I2C1, ENABLE);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

	I2C_SendData(I2C1, 0x00);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

	I2C_GenerateSTART(I2C1, ENABLE);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

	I2C_AcknowledgeConfig(I2C1, ENABLE);
	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

    while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    uint8_t data1 = I2C_ReceiveData(I2C1);

	I2C_AcknowledgeConfig(I2C1, DISABLE);
    I2C_GenerateSTOP(I2C1, ENABLE);
    while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    uint8_t data2 = I2C_ReceiveData(I2C1);

	while (1)
		;
}

#include "stm32f10x.h"

int main(void)

{

GPIO_InitTypeDef gpio;

I2C_InitTypeDef i2c;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

GPIO_StructInit(&gpio);

gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA

gpio.GPIO_Mode = GPIO_Mode_AF_OD;

gpio.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOB, &gpio);

I2C_StructInit(&i2c);

i2c.I2C_Mode = I2C_Mode_I2C;

i2c.I2C_Ack = I2C_Ack_Enable;

i2c.I2C_ClockSpeed = 100000;

I2C_Init(I2C1, &i2c);

I2C_Cmd(I2C1, ENABLE);

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

I2C_SendData(I2C1, 0x00);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_AcknowledgeConfig(I2C1, ENABLE);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);

uint8_t data1 = I2C_ReceiveData(I2C1);

I2C_AcknowledgeConfig(I2C1, DISABLE);

I2C_GenerateSTOP(I2C1, ENABLE);

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);

uint8_t data2 = I2C_ReceiveData(I2C1);

while (1)

;

}

Jak sprawdzić, czy program działa? Najlepiej uruchomić go pod debuggerem i zobaczyć czy zawartość zmiennych data1 i data2 jest zgodna z oczekiwaniami. O ile poprzednio zapisaliśmy dane, a nasz układ jest poprawnie podłączony powinniśmy zobaczyć rezultat jak na obrazku:

Zapis i odczyt do pamięci EEPROM w praktyce.

Licznik uruchomień układu

Umiemy już zapisywać i odczytywać dane z pamięci EEPROM, czas napisać program, który wykorzysta naszą nową umiejętność. Napiszmy program, który będzie zliczał ile razy został uruchomiony. Informacje o liczbie uruchomień będziemy wysyłać za pomocą UART-a.

Poprzednio pisaliśmy program do komunikacji z EEPROM-em w głównej funkcji main, teraz przygotujmy odpowiednie funkcje pomocnicze.

Po pierwsze zarówno zapis, jak i odczyt zaczyna się tak samo - od ustawienia adresu pamięci, do którego chcemy mieć dostęp. Możemy więc wydzielić ten kod jako procedurę:

void eeprom_set_addr(uint32_t addr)
{
	I2C_GenerateSTART(I2C1, ENABLE);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

	I2C_SendData(I2C1, addr);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
}

void eeprom_set_addr(uint32_t addr)

{

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

I2C_SendData(I2C1, addr);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

}

Korzystając z niej, zapis do pamięci jest znacznie łatwiejszy:

void eeprom_write(uint32_t addr, const void* data, int size)
{
	int i;
	const uint8_t* buffer = (uint8_t*)data;

	eeprom_set_addr(addr);
	for (i = 0; i < size; i++) {
		I2C_SendData(I2C1, buffer[i]);
		while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
	}
	I2C_GenerateSTOP(I2C1, ENABLE);
}

void eeprom_write(uint32_t addr, const void* data, int size)

{

int i;

const uint8_t* buffer = (uint8_t*)data;

eeprom_set_addr(addr);

for (i = 0; i < size; i++) {

I2C_SendData(I2C1, buffer[i]);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

}

I2C_GenerateSTOP(I2C1, ENABLE);

}

Jak widzimy, procedura jest bardziej uniwersalna niż poprzednio, może zapisywać kilka bajtów na raz. Podobnie możemy napisać procedurę do odczytu danych:

void eeprom_read(uint32_t addr, void* data, int size)
{
	int i;
	uint8_t* buffer = (uint8_t*)data;

	eeprom_set_addr(addr);

	I2C_GenerateSTART(I2C1, ENABLE);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

	I2C_AcknowledgeConfig(I2C1, ENABLE);
	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

	for (i = 0; i < size - 1; i++) {
		while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    	buffer[i] = I2C_ReceiveData(I2C1);
    }
	I2C_AcknowledgeConfig(I2C1, DISABLE);
    I2C_GenerateSTOP(I2C1, ENABLE);
    while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    buffer[i] = I2C_ReceiveData(I2C1);
}

void eeprom_read(uint32_t addr, void* data, int size)

{

int i;

uint8_t* buffer = (uint8_t*)data;

eeprom_set_addr(addr);

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_AcknowledgeConfig(I2C1, ENABLE);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

for (i = 0; i < size - 1; i++) {

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);

buffer[i] = I2C_ReceiveData(I2C1);

}

I2C_AcknowledgeConfig(I2C1, DISABLE);

I2C_GenerateSTOP(I2C1, ENABLE);

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);

buffer[i] = I2C_ReceiveData(I2C1);

}

Jest ona nieco bardziej skomplikowana ze względu na inne traktowanie ostatniego odbieranego bajtu. Mając odpowiednie procedury, program główny jest już bardzo prosty:

eeprom_read(0x10, &counter, sizeof(counter));

counter++;
printf("Uruchomenie numer %ld\n", counter);

eeprom_write(0x10, &counter, sizeof(counter));

eeprom_read(0x10, &counter, sizeof(counter));

counter++;

printf("Uruchomenie numer %ld\n", counter);

eeprom_write(0x10, &counter, sizeof(counter));

Zamiast adresu 0x00 tym razem wykorzystywany jest adres 16, czyli 0x10. Dzięki temu nie skasujemy danych zapisanych wcześniej. Całość programu wygląda następująco:

#include <stdio.h>
#include "stm32f10x.h"

void send_char(char c)
{
	while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);
	USART_SendData(USART2, c);
}

int __io_putchar(int c)
{
	if (c=='\n')
		send_char('\r');
	send_char(c);
	return c;
}

void eeprom_set_addr(uint32_t addr)
{
	I2C_GenerateSTART(I2C1, ENABLE);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);
	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

	I2C_SendData(I2C1, addr);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
}

void eeprom_write(uint32_t addr, const void* data, int size)
{
	int i;
	const uint8_t* buffer = (uint8_t*)data;

	eeprom_set_addr(addr);
	for (i = 0; i < size; i++) {
		I2C_SendData(I2C1, buffer[i]);
		while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);
	}
	I2C_GenerateSTOP(I2C1, ENABLE);
}

void eeprom_read(uint32_t addr, void* data, int size)
{
	int i;
	uint8_t* buffer = (uint8_t*)data;

	eeprom_set_addr(addr);

	I2C_GenerateSTART(I2C1, ENABLE);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

	I2C_AcknowledgeConfig(I2C1, ENABLE);
	I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);
	while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

	for (i = 0; i < size - 1; i++) {
		while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    	buffer[i] = I2C_ReceiveData(I2C1);
    }
	I2C_AcknowledgeConfig(I2C1, DISABLE);
    I2C_GenerateSTOP(I2C1, ENABLE);
    while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);
    buffer[i] = I2C_ReceiveData(I2C1);
}


int main(void)
{
	GPIO_InitTypeDef gpio;
	I2C_InitTypeDef i2c;
	USART_InitTypeDef uart;

	uint32_t counter = 0;

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

	GPIO_StructInit(&gpio);
	gpio.GPIO_Pin = GPIO_Pin_2;
	gpio.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_Init(GPIOA, &gpio);

	gpio.GPIO_Pin = GPIO_Pin_3;
	gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_Init(GPIOA, &gpio);

	USART_StructInit(&uart);
	uart.USART_BaudRate = 115200;
	USART_Init(USART2, &uart);
	USART_Cmd(USART2, ENABLE);

	gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA
	gpio.GPIO_Mode = GPIO_Mode_AF_OD;
	gpio.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &gpio);

	I2C_StructInit(&i2c);
	i2c.I2C_Mode = I2C_Mode_I2C;
	i2c.I2C_ClockSpeed = 100000;
	I2C_Init(I2C1, &i2c);
	I2C_Cmd(I2C1, ENABLE);

	eeprom_read(0x10, &counter, sizeof(counter));

	counter++;
	printf("Uruchomenie numer %ld\n", counter);

	eeprom_write(0x10, &counter, sizeof(counter));

	for(;;);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

#include <stdio.h>

#include "stm32f10x.h"

void send_char(char c)

{

while (USART_GetFlagStatus(USART2, USART_FLAG_TXE) == RESET);

USART_SendData(USART2, c);

}

int __io_putchar(int c)

{

if (c=='\n')

send_char('\r');

send_char(c);

return c;

}

void eeprom_set_addr(uint32_t addr)

{

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Transmitter);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) != SUCCESS);

I2C_SendData(I2C1, addr);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

}

void eeprom_write(uint32_t addr, const void* data, int size)

{

int i;

const uint8_t* buffer = (uint8_t*)data;

eeprom_set_addr(addr);

for (i = 0; i < size; i++) {

I2C_SendData(I2C1, buffer[i]);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING) != SUCCESS);

}

I2C_GenerateSTOP(I2C1, ENABLE);

}

void eeprom_read(uint32_t addr, void* data, int size)

{

int i;

uint8_t* buffer = (uint8_t*)data;

eeprom_set_addr(addr);

I2C_GenerateSTART(I2C1, ENABLE);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_MODE_SELECT) != SUCCESS);

I2C_AcknowledgeConfig(I2C1, ENABLE);

I2C_Send7bitAddress(I2C1, 0xa0, I2C_Direction_Receiver);

while (I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED) != SUCCESS);

for (i = 0; i < size - 1; i++) {

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);

buffer[i] = I2C_ReceiveData(I2C1);

}

I2C_AcknowledgeConfig(I2C1, DISABLE);

I2C_GenerateSTOP(I2C1, ENABLE);

while(I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_RECEIVED) != SUCCESS);

buffer[i] = I2C_ReceiveData(I2C1);

}

int main(void)

{

GPIO_InitTypeDef gpio;

I2C_InitTypeDef i2c;

USART_InitTypeDef uart;

uint32_t counter = 0;

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOB | RCC_APB2Periph_GPIOC | RCC_APB2Periph_GPIOD, ENABLE);

RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);

RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);

GPIO_StructInit(&gpio);

gpio.GPIO_Pin = GPIO_Pin_2;

gpio.GPIO_Mode = GPIO_Mode_AF_PP;

GPIO_Init(GPIOA, &gpio);

gpio.GPIO_Pin = GPIO_Pin_3;

gpio.GPIO_Mode = GPIO_Mode_IN_FLOATING;

GPIO_Init(GPIOA, &gpio);

USART_StructInit(&uart);

uart.USART_BaudRate = 115200;

USART_Init(USART2, &uart);

USART_Cmd(USART2, ENABLE);

gpio.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7; // SCL, SDA

gpio.GPIO_Mode = GPIO_Mode_AF_OD;

gpio.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init(GPIOB, &gpio);

I2C_StructInit(&i2c);

i2c.I2C_Mode = I2C_Mode_I2C;

i2c.I2C_ClockSpeed = 100000;

I2C_Init(I2C1, &i2c);

I2C_Cmd(I2C1, ENABLE);

eeprom_read(0x10, &counter, sizeof(counter));

counter++;

printf("Uruchomenie numer %ld\n", counter);

eeprom_write(0x10, &counter, sizeof(counter));

for(;;);

}

Rezultat działania programu w praktyce widoczny jest poniżej:

STM32 i EEPROM w praktyce - licznik uruchomienia programu.

Podsumowanie

Komunikacja za pomocą I²C jest nieco bardziej skomplikowana niż za pomocą SPI, czy UART, jednak interfejs ten ma wiele zalet. Za pomocą raptem dwóch linii można połączyć wiele urządzeń i komunikować się z nimi z zadowalającą prędkością.

Komunikacja może w pierwszej chwili wydawać się skomplikowana, ale raz napisane procedury mogą być równie łatwo używane w przykładowym programie, jak i w przypadku innych rozwiązań.

Nawigacja kursu

Poprzednia część

Następna część

Pokaż/ukryj wszystkie części

Uwaga! Ten kurs został zarchiwizowany. Sprawdź najnowszy kurs STM32 »

Autor kursu: Piotr (Elvis) Bugalski
Redakcja: Damian (Treker) Szymański

Artykuł był ciekawy?

Dołącz do 20 tysięcy osób, które otrzymują powiadomienia o nowych artykułach! Zapisz się, a otrzymasz PDF-y ze ściągami (m.in. na temat mocy, tranzystorów, diod i schematów) oraz listę inspirujących DIY na bazie Arduino i Raspberry Pi.