niedziela, 5 lutego 2017

[IV] STM32F4 - Projekt - HC-SR04, DS18B20, USART, RTC

Ten post chciałbym poświęcić na projekt realizujący pomiar odległości czujnikiem HC-SR04, wyposażony w dwa czujniki temperatury DS18B20, które pozwolą na dostosowanie wyników pomiarów do warunków zewnętrznych, komunikację poprzez USART z komputerem.

Dodatkowe funkcje jakie chciałbym wprowadzić to pomiar wielkości pomieszczenia czy pudła, wraz z mierzeniem jej zawartości.

Elementy oraz podłączenie:


  • HC-SR04 domyślnie PD0;
  • DS18B20 domyślnie PB8. Można go dowolnie modyfikować ponieważ procedura obsługi transmisji OneWire została oparta o funkcje opóźniające.
  • Konwerter USART USB - RX PC10; TX PC11;
  • Wyświetlacz Nokia5110 DC - GPIOC_14 | CE - GPIOC_13 | RST - GPIOC_15 | DIN - GPIOC_3 | CLK - GPIOB_10 ;

Programowanie:


Do projektu należy skonfigurować takie elementy jak:

Czujnik odległości HC-SR04, który działa na dwóch timerach generujących odpowiednie czasy oraz zliczający czas wystąpienia stanu wysokiego na pinie Echo. Jest on następnie zamieniany na czas, który zostaje przeliczony na odległość układu od przeszkody.



Czujniki temperatury DS18B20, połączonych w jednej linii. Dane z nich są następnie uśredniane i ich wartość jest pobierana do obliczenia odległości.

Poprzez USART dane będą wysyłane do komputera. Głównie w celu debugowania, ale także z informacjami zebranymi z czujników.

Wyświetlacz Nokia, na którym będą prezentowane wyniki działania programu tzn, aktualny czas, odległość od przeszkody oraz temperatura.

HC-SR04 opis:


W tej części chciałbym trochę opisać czujnik HC-SR04. Podstawowe parametry:

  • Napięcie zasilania 5V (z 3.3V nie działa). Zgodnie z dokumentacją tylko 5V akceptuje. Do STMa najlepiej podłączyć przez rezystor, 500Ohm do 1kOhm spokojnie powinno wystarczyć.
  • Pobór prądu wynosi 15mA;
  • Zakres od 2 do 200cm. Daje rade do 230cm z przyzwoitą dokładnością i nie skomplikowanych celów pomiarowych. Większy zakres oferuje np US-015 bądź HC-SR04 od SparkFun (taki czerwony).
  • Częstotliwość pracy wynosi 40kHz
  • Kąt pracy pomiędzy 15 a 30 st.

Ja korzystam z czujnika zawierającego dwa piny przeznaczone do sterowania. Na jednym z nich generowany jest impuls 10us, drugi natomiast odczytuje odpowiedź. Występują też układy posiadające tylko jeden pin sterujący. Zasada działa jest taka sama. Takie same sygnały należy podać w celu inicjalizacji oraz odczytu.

Należy także mieć na uwadze, że mogą występować sytuacje w których dana przeszkoda nie zostanie poprawnie zinterpretowana. Może się to zdarzyć gdy odległość od przeszkody przekracza maksymalny dopuszczalny zakres pomiarowy. W takim przypadku, jeśli jest to niewielkie przekroczenie to powinna wystąpić tylko pogorszenie dokładności. Druga sytuacja dotyczy za małego kąta pomiarowego. Fala ultradźwiękowa trafi na przeszkodę natomiast nie zostanie zarejestrowana fala powrotna, która po odbiciu nie wróci do odbiornika. Ostatnim problemem jest wielkość obiektu mierzonego. Ten z kolei jeśli będzie za mały to czujnik nie zarejestruje jego obecności. Im dalej znajduje się on od przeszkody tym większe prawdopodobieństwo wystąpienia takiej sytuacji.

Dokładność HC-SR04:


Czujnik HC-SR04 posiada pewną rozbieżność, która w zależności od jego zastosowania może mieć, większy lub mniejszy wpływ na jego skuteczność działania. W celu jej maksymalnej poprawy zastosowałem uśrednianie dziesięciu wyników pomiarów, które wyeliminują występujące duże niedokładności. Następnie wyeliminowałem wyniki, znacząco odbiegające od pozostałych. Każdy z wyników zanim przejdzie do uśredniania zostaje obliczony poprzez zmodyfikowany wzór obliczania odległości, który pobiera wcześniej obliczoną prędkość dźwięku w powietrzu. Te wartości wahają się w następujący sposób:
  • -40 st. C - 306.5 m/s
  • -30 st. C - 312.9 m/s
  • -20 st. C - 319.3 m/s
  • -10 st. C - 325.6 m/s
  • 0 st. C - 331.8 m/s
  • 10 st. C - 337.8 m/s
  • 15 st. C - 340.3 m/s
  • 20 st. C - 343.8 m/s
  • 30 st. C - 349.6 m/s
  • 40 st. C - 355.3 m/s
Pozostałe parametry takie jak ciśnienie czy wilgotność nie wpływają znaczącą na tą wartość. Wartość tą oblicza się na podstawie wzoru:

v = 331.5*sqrt(1+(temperatura[st. C]/273,15) [m/s]

Taki wzór można stosować na dwa sposoby. Pierwszy z nich jest obliczanie każdorazowo tej prędkości dla zmierzonej temperatury. Drugi sposób dotyczy wykonania obliczeń wcześniej i przygotowania tablicy zawierającej wartości już obliczone. Jest on dosyć kłopotliwy jeśli zależy nam na dużej dokładności dla szerokiego zakresu temperatur. Ponieważ wtedy rozmiar tablicy byłby dosyć znaczący.

Program:


Poniżej przejdę przez ważniejsze funkcje dla każdego z modułów. Cały program będzie do pobrania pod linkiem na dole strony.

HC-SR04


Jak już wspomniałem wcześniej czujnik HC-SR04 został oprogramowany z użyciem dwóch timerów. 

W pierwszej kolejności należy zainicjalizować porty GPIO. Takie funkcje można wywołać jako funkcje wspólną razem z inicjalizacją timera oraz przerwań. Dzięki czemu te podstawowe elemen ty można zdefiniować jako prywatne:

  1. // Echo Pin HC-SR04 (PA0)
  2. #define  HCSR04_ECHO_PORT     GPIOA
  3. #define  HCSR04_ECHO_CLK      RCC_AHB1Periph_GPIOA
  4. #define  HCSR04_ECHO_PIN      GPIO_Pin_0
  5. #define  HCSR04_ECHO_SOURCE   GPIO_PinSource0
  7. // Trigger Pin (PD3)
  8. #define  HCSR04_TRIGGER_PORT  GPIOD
  9. #define  HCSR04_TRIGGER_CLK   RCC_AHB1Periph_GPIOD
  10. #define  HCSR04_TRIGGER_PIN   GPIO_Pin_3
  12. static void Priv_HCSR04_GPIO_Init(void)
  13. {
  14.   GPIO_InitTypeDef GPIO_InitStructure;
  16.   //Pin - Trigger
  17.   RCC_AHB1PeriphClockCmd(HCSR04_TRIGGER_CLK, ENABLE);
  18.   RCC_AHB1PeriphClockCmd(HCSR04_ECHO_CLK, ENABLE);
  20.   GPIO_InitStructure.GPIO_Pin = HCSR04_TRIGGER_PIN;
  21.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  22.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  23.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  24.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  25.   GPIO_Init(HCSR04_TRIGGER_PORT, &GPIO_InitStructure);
  27.   //Ustawienie pinu na low
  28.   HCSR04_TRIGGER_PORT->BSRRH = HCSR04_TRIGGER_PIN;
  30.   //Echo - Pin
  32.   GPIO_InitStructure.GPIO_Pin = HCSR04_ECHO_PIN;
  33.   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  34.   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  35.   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  36.   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  37.   GPIO_Init(HCSR04_ECHO_PORT, &GPIO_InitStructure);
  39.   GPIO_PinAFConfig(HCSR04_ECHO_PORT, HCSR04_ECHO_SOURCE, GPIO_AF_TIM2);
  40. }

Funkcja pozwalająca na włączenie wykorzystywanych timerów:

  1. static void Priv_HCSR04_Init_TIM2_TIM7(void)
  2. {
  3.   TIM_ICInitTypeDef  TIM_ICInitStructure;
  4.   TIM_TimeBaseInitTypeDef  TIM_TimeBaseStructure;
  6.   //==========================
  7.   // Timer-7 wlaczenie, odpowiada za opoznienie
  8.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM7, ENABLE);  
  9.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
  11.   TIM_Cmd(TIM7, DISABLE);
  13.   // Ustawienie timera
  14.   TIM_TimeBaseStructure.TIM_Period=9;       //10us
  15.   TIM_TimeBaseStructure.TIM_Prescaler=83;   //1Mhz
  16.   TIM_TimeBaseStructure.TIM_ClockDivision=TIM_CKD_DIV1;
  17.   TIM_TimeBaseStructure.TIM_CounterMode=TIM_CounterMode_Up;
  18.   TIM_TimeBaseInit(TIM7, &TIM_TimeBaseStructure);
  20.   TIM_ARRPreloadConfig(TIM7, ENABLE);
  22.   // Timer -2 ustawienie trybu input capture
  23.   TIM_PrescalerConfig(TIM2, 83, TIM_PSCReloadMode_Immediate);
  25.   TIM_ICInitStructure.TIM_Channel = TIM_Channel_1;
  26.   TIM_ICInitStructure.TIM_ICPolarity = TIM_ICPolarity_Falling;
  27.   TIM_ICInitStructure.TIM_ICSelection = TIM_ICSelection_DirectTI;
  28.   TIM_ICInitStructure.TIM_ICPrescaler = TIM_ICPSC_DIV1;
  29.   TIM_ICInitStructure.TIM_ICFilter = 0x0;                  
  30.   TIM_PWMIConfig(TIM2, &TIM_ICInitStructure);
  32.   TIM_SelectInputTrigger(TIM2, TIM_TS_TI1FP1);          //TIM_Internal_Trigger_Selection
  33.                                                         //Triger input
  35.   // Tryb slave_mode reset
  36.   TIM_SelectSlaveMode(TIM2, TIM_SlaveMode_Reset);
  37.   TIM_SelectMasterSlaveMode(TIM2,TIM_MasterSlaveMode_Enable);
  38. }

Dodatkowo do układu należy jeszcze włączyć przerwania dla timerów 2 oraz 7. Wykonuje się to poprzez następującą funkcję:

  1. static void Priv_HCSR04_InitNVIC(void)
  2. {
  3.   NVIC_InitTypeDef NVIC_InitStructure;
  5.   //Przerwanie wewnetrzne od timera 2
  6.   NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
  7.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  8.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
  9.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  10.   NVIC_Init(&NVIC_InitStructure);
  12.   TIM_ITConfig(TIM2, TIM_IT_CC1, ENABLE);
  14.   //Przerwanie wewnetrzne od timera 7
  15.   NVIC_InitStructure.NVIC_IRQChannel = TIM7_IRQn;
  16.   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  17.   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  18.   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  19.   NVIC_Init(&NVIC_InitStructure);
  21.   TIM_ITConfig(TIM7,TIM_IT_Update,ENABLE);
  22. }

Dane jakie są potrzebne dla układu są przetrzymywane w strukturze:

  1. typedef struct {
  2.   uint32_t time_tim2;
  3.   uint32_t time_tim7;
  4.   uint32_t delay_u_sec;
  5. }HCSR04_Ultra_t;

Przedstawione powyżej funkcje są prywatne zainicjalizowane jako static. Ma to za zadanie ograniczyć ich zasięg tylko do plików należących do układu HC-SR04. Ich wywołanie następuje poprzez jedną publiczną funkcję przedstawioną poniżej.

  1. static void Priv_SetData_Struct(void)
  2. {
  3.     HCSR04.time_tim2= 0;
  4.     HCSR04.time_tim7=0;
  5.     HCSR04.delay_u_sec=0;
  6. }
  8. //===============================================================
  9. //Inicjalizacja HCSR04
  10. void HCSR04_Init(void)
  11. {
  12.   Priv_SetData_Struct();
  13.   Priv_HCSR04_GPIO_Init();
  14.   Priv_HCSR04_Init_TIM2_TIM7();
  15.   Priv_HCSR04_InitNVIC();
  16. }

W pierwszej kolejności ustawieniu ulegają parametry dla struktury. Następnie następuje przejście przez wszystkie procedury inicjalizacji.

Sygnał włączający pomiar musi trwać 10us. Za jego generację odpowiada timer 7:

  1. static void Priv_HCSR04_Trigger(void)
  2. {
  3.   HCSR04.time_tim7=0;
  5.   //Pin Trigger ustawiony w stan high
  6.   HCSR04_TRIGGER_PORT->BSRRL = HCSR04_TRIGGER_PIN;
  8.   TIM_Cmd(TIM7, ENABLE);        //Wlaczenie timera
  9.   while(HCSR04.time_tim7<10);   //Odliczanie od 0 do 9, aktualizacja w
  10.                                 //obsludze przerwania
  12.   TIM_Cmd(TIM7, DISABLE);       //Wylaczenie timera
  14.   //Pin triggera ustawiony na low
  15.   HCSR04_TRIGGER_PORT->BSRRH = HCSR04_TRIGGER_PIN;
  16. }

Pojedynczy pomiar bez kompensacji temperaturowej wygląda następująco:

  1. float HCSR04_Distance_cm(void)
  2. {
  3.   float return_value=0.0;
  4.   uint32_t check_ok=0;
  6.   HCSR04.time_tim2=0;             //czyszczenie danych w strukturze
  7.   TIM_SetCounter(TIM2, 0);      //zerowanie licznika
  8.   TIM_Cmd(TIM2, ENABLE);        //Wlaczenie timer2
  10.   Priv_HCSR04_Trigger_Send();   //Wyslanie sygnalu Send
  12.   check_ok=0;
  13.   HCSR04.time_tim7=0;
  15.   TIM_Cmd(TIM7, ENABLE); //Wlaczenie timera
  17.   do
  18.   {
  19.         if(HCSR04.time_tim2!=0)               { check_ok=1; }     // pomiar zakonczony powodzeniem
  20.         if(HCSR04.time_tim7>=HCSR04_TIMEOUT)  { check_ok=2; }     // niepowodzenie pomiaru
  21.   }while(check_ok==0);
  23.   TIM_Cmd(TIM7, DISABLE);
  24.   TIM_Cmd(TIM2, DISABLE);
  26.   HCSR04.time_tim7=0;
  27.   TIM_Cmd(TIM7, ENABLE);
  29.   while(HCSR04.time_tim7<HCSR04_DELAY);
  30.   TIM_Cmd(TIM7, DISABLE);
  32.   if(check_ok==1)
  33.   {
  34.         //konwersja czasu na centymetry(w us) na centymetry
  35.         return_value=(float)(HCSR04.delay_us)*(float)(0.017);
  36.   }
  37.   //Blad pomiaru
  38.   else { return_value=-1.0; }
  40.   return return_value;
  41. }

Pojedynczy pomiar z kompensacją temperaturową z dwóch czujników temperatury:

  1. float HCSR04_Single_With_Temp_cm(float temp)
  2. {
  3.     float return_value = 0.0;
  4.     float c = 0.0;
  5.    
  6.     HCSR04_Distance_cm();
  7.    
  8.     c = 331.5 + (0.6 * temp);
  9.     c = c * 0.0001;
  10.    
  11.     return return_value += ((float)(HCSR04.delay_u_sec*0.5) * c);
  12. }

Wykonywanie kilku pomiarów wraz z ich uśrednieniem poprzez zastosowanie podstawowej metody czyli średniej arytmetycznej:

  1. typedef enum {
  2.     Use_Temp_Value_False = 0, //Nie korzysta z kompensacji temperatury
  3.     Use_Temp_Value_True = 1   //Wykorzystuje kompensacje temperaturowa
  4. }Use_Temp_Value_t;
  6. float HC_SR04_Distance_Few_Data(uint8_t sample_number, Use_Temp_Value_t use_temp_value)
  7. {
  8.     float return_value = 0.0;
  9.     uint8_t i = 0;
  11.     //Bez kompensacji temperaturowej
  12.     if(use_temp_value == Use_Temp_Value_False)
  13.     {
  14.         for(i=0;i<sample_number;i++)
  15.         {
  16.             return_value += HCSR04_Distance_cm();
  17.         }
  18.     }
  20.     //Z kompensacją temperaturową
  21.     if(use_temp_value == Use_Temp_Value_True)
  22.     {
  23.         for(i=0;i<sample_number;i++)
  24.         {
  25.             return_value += HCSR04_Distance_With_Temp_cm();
  26.         }
  27.     }
  29.     return_value = (return_value/(float)sample_number);
  31.     return return_value;
  32. }

Ta funkcja pozwala na wykonanie zadanej ilości pomiarów, oraz zdecydowanie czy do pomiaru ma być brana wartość temperatury od czujnika DS18B20. W tym przypadku zdecydowałem się wynik odległości przechowywać w zmiennej float. Jeśli prób pomiarowych będzie bardzo dużo, chociaż uważam, że jest to mało potrzebne bo nie polepszy to aż tak dokładności natomiast znacząco zwiększy czas pomiaru, to należałoby zastosować np dwie zmienne typu float, i z nich na końcu wyciągnąć średnią.

Na samym końcu przedstawię funkcje odpowiedzialne za obsługę przerwania. Działanie jest dosyć proste w TIM7 następuje sprawdzenie wygenerowanego przerwania, po czym flaga od przerwania jest czyszczona. Jedno wywołanie i przejście przez funkcję pozwoli na odliczenie około 10us, potrzebnych do wygenerowania odpowiedniego sygnału inicjalizującego.

  1. void TIM7_IRQHandler(void)
  2. {
  3.   if (TIM_GetITStatus(TIM7, TIM_IT_Update) != RESET)
  4.   {
  5.     //Czyszczenie flagi
  6.     TIM_ClearITPendingBit(TIM7, TIM_IT_Update);
  7.     HCSR04.time_tim7+=10;
  8.   }
  9. }

Timer 2 podstawowe działanie ma takie samo. Główna część obsługi przerwania pobiera dane z rejestrów CCR1 oraz CCR2, Rejestry te przechowują wartości jakie mają być porównywane z rejestrem CNT. W kolejnym kroku wartości te są od siebie odejmowane i przekazywane do wartości opóźnienia.

  1. void TIM2_IRQHandler(void)
  2. {
  3.   uint32_t start,stop;
  5.   if(TIM_GetITStatus(TIM2, TIM_IT_CC1) == SET)
  6.   {
  7.     //Usuniecie flagi przerwania
  8.     TIM_ClearITPendingBit(TIM2, TIM_IT_CC1);
  10.     //Odczyt wskazan
  11.     start=TIM_GetCapture1(TIM2);
  12.     stop=TIM_GetCapture2(TIM2);
  13.     HCSR04.delay_u_sec=start-stop;
  14.     HCSR04.time_tim2++;
  15.   }
  16. }

 Do pobrania danych z rejestrów CCR1 i 2 wykorzystuje funkcje zawarte w pliku stm32f4xx_tim.

DS18B20


Na samym początku opiszę trochę komunikację poprzez interfejs One Wire, po czym przejdę do krótkiego opisania komunikacji z czujnikiem DS18B20.

Zacznę od transmisji One Wire. Jest ona ściśle określona i zawiera poszczególne sekwencje działań jakie należy wykonać aby uzyskać komunikację z układem. Na początku wysyłana jest inicjalizacja, po czym przesyłana jest komenda ROM na końcu przesyłane są poszczególne funkcje. Wyjątek dla czujnika stanowią komendy Search ROM 0x0F oraz Alarm Search 0xEC. Dla nich po ich wysłaniu należy wrócić do inicjalizacji.

Polega ona na wysłaniu sygnału reset od mikrokontrolera po czym czujnik odsyła impuls zwany presence pulse. Dopiero po tej odpowiedzi można przejść do wysyłania komend ROM. DO wyboru są następujące działania:


  • Search ROM (0xF0) - powoduje identyfikację kodów ROM jakie są podłączone do linii. Kiedy jest podłączone tylko jeden układ podrzędny to tą komendę można pominąć.
  • Read ROM (0x33) - odczyt ROM z podrzędnego układu. Wykorzystywana tylko gdy podłączone jest na linii jedno urządzenie. 
  • Match ROM (0x55) - do zaadresowanie podrzędnego układu. Na tą komendę powinien odpowiedzieć jedynie układ o wysłanym kodzie ROM. 
  • Skip ROM (0xCC) - czyli pominięcie wysłania kodu ROM. Pozwala na równoczesne adresowanie urządzeń podłączonych na linii.
  • Alarm Search (0xEC) - na tą komendę odpowiadają układy na których została ustawiona flaga alarmu. Pozwala to na sprawdzenie czy wystąpił sygnał alarmu z czujników, Jak wspomniałem wcześniej po tej operacji 


Na samym początku zdefiniowanie funkcji opóźniających, odpowiedzialne za generowanie opóźnienia pomiędzy funkcjami.

  1. void Delay_Init(void)
  2. {
  3.     RCC_ClocksTypeDef RCC_Clocks;
  4.     RCC_GetClocksFreq(&RCC_Clocks); //Pobranie zegara systemowego
  5.     data_delay = RCC_Clocks.HCLK_Frequency / 5000000;   //1us Delay
  6. }
  8. void DelayMicros(uint32_t micros)
  9. {
  10.     micros = micros * data_delay - 10;
  11.     while (micros--);      
  12. }
  14. void DelayMillis(uint32_t millis)
  15. {
  16.     millis = 1000 * millis * data_delay - 10;
  17.     while (millis--);  
  18. }

  1. void OneWire_Init(OneWire_DS_t* OneWire_DS_St, GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
  2. {
  3.     GPIO_InitTypeDef GPIO_InitDef;
  5.     Delay_Init();
  6.    
  7.     RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);   //Wlaczenie zegara
  9.     GPIO_InitDef.GPIO_Pin = GPIO_Pin;                       //Wybranie pinów
  11.     GPIO_InitDef.GPIO_OType = GPIO_OType_PP;                //Wyjscie jako push-pull
  12.     GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT;                 //Ustawienie pinu jako wyjscie
  13.     GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_UP;                  //Bez rezystora podciagajacego
  14.     GPIO_InitDef.GPIO_Speed = GPIO_Speed_50MHz;             //Ustawienie czestotliwosci
  15.     GPIO_Init(GPIOx, &GPIO_InitDef);                        //Wlaczenie lini GPIOD
  17.     OneWire_DS_St->GPIOx = GPIOx;
  18.     OneWire_DS_St->GPIO_Pin = GPIO_Pin;
  19. }
  21. void OneWire_WriteBit(OneWire_DS_t* OneWireStruct, uint8_t bit)
  22. {
  23.     if (bit)
  24.     {
  25.         //Ustaw stan LOW
  26.         ONEWIRE_LOW(OneWireStruct);
  27.         ONEWIRE_OUTPUT(OneWireStruct);
  28.         DelayMicros(10);
  29.        
  30.         //Bit high
  31.         ONEWIRE_INPUT(OneWireStruct);
  32.        
  33.         DelayMicros(55);
  34.         ONEWIRE_INPUT(OneWireStruct);
  35.     }
  36.     else
  37.     {
  38.         //Ustaw linie na LOW
  39.         ONEWIRE_LOW(OneWireStruct);
  40.         ONEWIRE_OUTPUT(OneWireStruct);
  41.         DelayMicros(65);
  42.        
  43.         //Bit high
  44.         ONEWIRE_INPUT(OneWireStruct);
  45.        
  46.         //Odczekaj 5us i zwolnij linie
  47.         DelayMicros(5);
  48.         ONEWIRE_INPUT(OneWireStruct);
  49.     }
  50. }
  52. uint8_t OneWire_ReadBit(OneWire_DS_t* OneWireStruct)
  53. {
  54.     uint8_t bit = 0;
  55.    
  56.     //Linia na low
  57.     ONEWIRE_LOW(OneWireStruct);
  58.     ONEWIRE_OUTPUT(OneWireStruct);
  59.     DelayMicros(3);
  60.    
  61.     //Zwolnij linie
  62.     ONEWIRE_INPUT(OneWireStruct);
  63.     DelayMicros(10);
  64.    
  65.     //Odczytanie stanu linii
  66.     if ((((OneWireStruct->GPIOx)->IDR & (OneWireStruct->GPIO_Pin)) == 0 ? 0 : 1)) { bit = 1; }
  67.    
  68.     //Odczekaj 50us
  69.     DelayMicros(50);
  70.    
  71.     //Zwroc wartosc rejestru
  72.     return bit;
  73. }

Teraz przejdę do opisu komunikacji z czujnikiem DS18B20:

Dane od czujnika przechowywane są scratchpadzie, które zawierają 2 bajty rejestr przechowujący informacje dotyczącą temperatury dostarczoną z czujnika. Z niego uzyskuje się dostęp do jedno bajtowego rejestru porównań TH oraz TL. Dodatkowo pozwala na uzyskanie dostępu do rejestru konfiguracyjnego

W pierwszej kolejności wprowadzenie danych do rejestru konfiguracyjnego dotyczące dokładności czujnika. Do dyspozycji są 4 wartości, 9, 10, 11 lub 12 bitów. TH, TL oraz rejestr konfiguracyjny są typu EEPROM, wobec tego przechowują one dane w przypadku braku zasilania.

Adresowanie urządzenia odbywa się poprzez wykorzystywanie kodów 64-bit kod umieszczony w pamięci ROM. Osiem najmłodszych bitów układu to tzw. family code czyli 0x28. Kolejne 48 bitów zawierają unikalny numer urządzenia. Osiem najstarszych bitów przechowuje CRC, które zostały obliczone z pierwszych 56 bitów.

Wracając do rozdzielczości to każda z dostępnych wartości pozwala na uzyskanie przybliżenia z dokładnością wynoszącą 0,5 st. C, 0,25 st. C, 0,125 st.C, 0,0625 st. C. Im większa rozdzielczość tym czas konwersji zostaje wydłużony do maksymalnie 750ms przy 12 bitach. Jest ona domyślnie ustawiana po włączeniu urządzenia. Aby ustawić rozdzielczość trzeba się odnieść do bit 5 i 6 rejestru konfiguracyjnego.  Tam od 00 (9 bit) do 11(12 bit) można przechodzić po rozdzielczości.

Rozpoczęcie konwersji rozpoczyna się od wysłania wartości 0x44 do czujnika. Po konwersji układ przechodzi w stan bezczynności. Następnie mikrokontroler może wysłać zapytanie odnośnie stanu wykonywania operacji. Jeśli jeszcze konwersja trwa to w odpowiedzi zostaną uzyskane same zera. Jedynki natomiast będą oznaczać zakończenie transmisji.

Dane po konwersji są przechowywane na 16 bitach z rozszerzeniem obejmującym znak. W zależności od rozdzielczości zajęte są wszystkie bity początkowe dla 12 bitów. Dla pozostałych są powoli zwalniane np. dla 9 bitów bit 0, 1 i 2 zostają wolne. Bity od 15 do 11 pozwalają na określenie czy temperatura jest dodatnia czy ujemna.

Istnieje możliwość także zasilania pasożytniczego bezpośrednio z linii magistrali. Natomiast wtedy należy wprowadzać poprawki do kodu ponieważ pewne operacje trzeba wykonać inaczej.

Wracająć do scratchpada, to składa się on z 8 bytów. Bajt 0 oraz 1 przechowuje wynik pomiaru temperatury. Bajt 2 oraz 3 pozwala na uzyskanie dostępu do TH i TL przechowywanych w EEPROM. Bajt 4 pozwala na uzyskanie informacji odnośnie rejestrów konfiguracyjnych. Bajt 5, 6, 7 są zarezerwowane i niedostępne. Można je jedynie odczytać, powoduje to otrzymanie wartości 1. Bajt 8 zawiera CRC z bajtów od 0 do 7.

Wprowadzanie danych do scratchpada musi być poprzedzone komendą 0x4E. Dane muszą być wysłane od najmłodszego bitu od 2 bajtu. Aby odczytać poprawność danych odczytuje się dane za pomocą komendy 0xBE. Dane w odpowiedzi przesyłane są od pierwszego bitu bajtu 0. Aby dane przesłać ze scratchpada do pamięci EEPROM należy wykonać polecenie 0x48. Można je także pobrać ze scratchpada poleceniem 0xB8. Po ty można sprawdzić jej status, 0 jeśli procedura się wykonuje lub 1 jeśli została zakończona.

Poniżej przedstawiam zebrany zestaw komend wykorzystywanych przy komunikację z czujnikiem:


  • Convert T - 0x44 - pojedyncza konwersja temperatury. 
  • Write scratchpad - 0x4E - zapis trzech bajtów do układu (1: TH, 2: TL, 3: rejestr konfiguracyjny). Dane przesyłane od najmłodszego do najstarszego bajtu. Zapis musi nastąpić przed wystawieniem sygnału reset. 
  • Read scratchpad - 0xBE - odczytanie danych z pamięci scratchpada. Układ master zakończy odczyt sygnałem reset.
  • Copy scratchpad - 0x48 - skopiowanie danych do pamięci EEPROM. 
  • Recal E2 - 0xB8 - wywołuje alarm TH, TL oraz rejestry konfiguracyjne z pamięci EEPROM. 
  • Read power supply - 0xB4.


Teraz pokaże opis funkcji odpowiedzialnych za komunikację z czujnikiem:

Na samym początku sprawdzenie czy family code się zgadza:

  1. uint8_t DS18B20_Check_Family_Code(uint8_t *ROM)
  2. {
  3.     if (*ROM == DS18B20_FAMILY_CODE) {  return 1; }
  4.     return 0;
  5. }

Druga funckja odpowiada za zaadresowanie konkretnego czujnika:

  1. uint8_t DS18B20_Single_Sensor_Start(OneWire_DS_t* OneWire, uint8_t *ROM)
  2. {
  3.     if (!DS18B20_Check_Family_Code(ROM)) { return 0; }          //Sprawdzenie czy na linii podlaczone DS18B20
  4.    
  5.     OneWire_Reset(OneWire);                                     //Reset
  6.     OneWire_SelectWithPointer(OneWire, ROM);                    //Wybranie numeru ROM
  7.     OneWire_WriteByte(OneWire, DS18B20_CMD_CONVERTTEMP);        //Rozpoczecie konwersji temperatury
  8.    
  9.     return 1;
  10. }

Pozostałe funkcje będą opisane bezpośrednio w plikach od projektu.

NOKIA5110


Ten układ był juz przezemnie poruszany na forum dla tego mikrokontrolera wobec tego na szybko przedstawię tylko najważniejsze funkcje z których będę korzystał.

Funkcje włączające GPIO, SPI i sam wyświetlacz.

  1. void NOKIA_INIT(void)
  2. {
  3.   GPIO_ResetBits(LCD_RST_PORT, LCD_RST);
  5.   DelayMillis(2);
  7.   GPIO_SetBits(LCD_RST_PORT, LCD_RST);
  9.   NOKIA_CMD(0x21);
  10.   NOKIA_CMD(0xc8);
  11.   NOKIA_CMD(0x06);
  12.   NOKIA_CMD(0x13);
  13.   NOKIA_CMD(0x20);
  14.   NOKIA_CMD(0x0c);
  15.   NOKIA_CMD(0x40);
  16.   NOKIA_CMD(0x80);
  17. }
  19. void GPIO_NOKIA_INIT(void)
  20. {
  21.   GPIO_InitTypeDef GPIOInit;
  23.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  24.   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
  26.   GPIO_PinAFConfig(GPIOC, GPIO_PinSource3, GPIO_AF_SPI2);
  27.   GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_SPI2);
  29.   //Inicjalizacja pinów MOSI
  30.   GPIO_StructInit(&GPIOInit);
  31.   GPIOInit.GPIO_Pin = LCD_DIN;
  32.   GPIOInit.GPIO_Mode = GPIO_Mode_AF;
  33.   GPIOInit.GPIO_PuPd = GPIO_PuPd_NOPULL;
  34.   GPIOInit.GPIO_OType = GPIO_OType_PP;
  35.   GPIOInit.GPIO_Speed = GPIO_Speed_100MHz;
  36.   GPIO_Init(LCD_DIN_PORT, &GPIOInit);
  38.   //Inicjalizacja SCK
  39.   GPIO_StructInit(&GPIOInit);
  40.   GPIOInit.GPIO_Pin = LCD_CLK;
  41.   GPIOInit.GPIO_Mode = GPIO_Mode_AF;
  42.   GPIOInit.GPIO_PuPd = GPIO_PuPd_NOPULL;
  43.   GPIOInit.GPIO_OType = GPIO_OType_PP;
  44.   GPIOInit.GPIO_Speed = GPIO_Speed_100MHz;
  45.   GPIO_Init(LCD_CLK_LINE, &GPIOInit);
  48.   //Inicjalizacja MISO, niewykorzystywane
  49.   GPIOInit.GPIO_Pin = MISO_PIN;
  50.   GPIOInit.GPIO_Mode = GPIO_Mode_AF;
  51.   GPIOInit.GPIO_PuPd = GPIO_PuPd_NOPULL;
  52.   GPIOInit.GPIO_OType = GPIO_OType_PP;
  53.   GPIOInit.GPIO_Speed = GPIO_Speed_100MHz;
  54.   GPIO_Init(MISO_PORT, &GPIOInit);
  56.   //Wlaczenie pozostalych linii
  57.   GPIOInit.GPIO_Pin = LCD_DC|LCD_CE|LCD_RST;
  58.   GPIOInit.GPIO_Mode = GPIO_Mode_OUT;
  59.   GPIOInit.GPIO_PuPd = GPIO_PuPd_NOPULL;
  60.   GPIOInit.GPIO_OType = GPIO_OType_PP;
  61.   GPIOInit.GPIO_Speed = GPIO_Speed_50MHz;
  62.   GPIO_Init(LCD_DC_PORT, &GPIOInit);
  64.   GPIO_SetBits(LCD_CE_PORT, LCD_CE|LCD_RST);
  65. }
  67. //Inicjalizacja SPI
  68. void SPI_NOKIA_INIT(void)
  69. {
  70.   SPI_InitTypeDef SPIInit;
  72.   RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
  74.   SPI_StructInit(&SPIInit);
  75.   SPIInit.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
  76.   SPIInit.SPI_Mode = SPI_Mode_Master;
  77.   SPIInit.SPI_CPOL = SPI_CPOL_Low;
  78.   SPIInit.SPI_CPHA = SPI_CPHA_1Edge;
  79.   SPIInit.SPI_NSS = SPI_NSS_Soft;
  80.   SPIInit.SPI_DataSize = SPI_DataSize_8b;
  81.   SPIInit.SPI_FirstBit = SPI_FirstBit_MSB;
  82.   SPIInit.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
  83.   SPI_NOKIA->CR1 &= ~SPI_CR1_SPE;
  84.   SPI_Init(SPI_NOKIA, &SPIInit);
  85.   SPI_Cmd(SPI_NOKIA, ENABLE);
  86. }
  88. //Wyslanie komendy na wyswietlacz
  89. static uint8_t SPI_SEND_NOKIA(uint8_t byte)
  90. {
  91.   while (SPI_I2S_GetFlagStatus(SPI_NOKIA, SPI_I2S_FLAG_TXE) == RESET);
  92.   GPIO_ResetBits(LCD_CE_PORT, LCD_CE);
  93.   SPI_I2S_SendData(SPI_NOKIA, byte);
  95.   while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
  96.   GPIO_SetBits(LCD_CE_PORT, LCD_CE);
  97.   return SPI_I2S_ReceiveData(SPI_NOKIA);
  98. }
  100. //Funkcja pozwalajaca na przesylanie danych do ukladu
  101. static void NOKIA_CMD(uint8_t cmd)
  102. {
  103.   GPIO_ResetBits(LCD_CE_PORT, LCD_CE|LCD_DC);
  104.   SPI_SEND_NOKIA(cmd);
  105.   GPIO_SetBits(LCD_CE_PORT, LCD_CE);
  106. }
  108. void LCD_CLEAR(void)
  109. {
  110.   memset(lcd_buffer, 0, (84 * 48 / 8));
  111. }

Poniżej funkcja odpowiedzialna za wyświetlanie tekstu na wyświetlaczu. I to właściwie tylko z niej korzystam aby wyświetlić dane

  1. void LCD_DRAW(int row, int col, const char* text)
  2. {
  3.   //Deklaracja zmiennych
  4.   int i;
  5.   uint8_t* pbuf = &lcd_buffer[row * 84 + col];
  6.   const uint8_t* font = 0;
  8.   //Dopóki bedzie jakis tekst do wyswietlania oraz bedzie mozliwosc
  9.   //wpisania danych wtedy funkcja bedzie wykonywana
  10.   while ((*text) && (pbuf < &lcd_buffer[(84 * 48 / 8) - 6]))
  11.   {
  12.   //Wskaznik na wartosc, zostaje ona zwiekszona o 1
  13.   int ch = *text++;
  14.   //Deklaracja zmiennej w kodzie ASCII
  15.   //z wskaznikiem na jej adres.
  16.   //Liczenie od 0 odejmnowanie znaku spacji
  17.   font = &font_ASCII[ch - ' '][0];
  18.   //Przejscie w tablicy po poszczególnych
  19.   //wartosciach podanego znaku
  20.   for (i = 0; i < 5; i++)
  21.   {
  22.    *pbuf++ = *font++;
  23.   }
  24.    *pbuf++ = 0;
  25.   }
  27.   i=0;
  29.   //Ustawienie lini DC na wysoki
  30.   GPIO_SetBits(GPIOC, LCD_DC);
  31.   //Wybranie urzadzenia, niski na CE
  32.   GPIO_ResetBits(GPIOC, LCD_CE);
  34.   for (i = 0; i < (84 * 48 / 8); i++)
  35.   {
  36.       SPI_SEND_NOKIA(lcd_buffer[i]);
  37.   }
  38.   GPIO_SetBits(LCD_CE_PORT, LCD_CE);
  39. }

USART

Transmisja od USART'a jest właściwie standardowa. Poniżej potrzebne funkcje:

  1. void GPIO_Initialize(void)
  2. {
  3.      //konfigurowanie portow GPIO
  4.      GPIO_InitTypeDef  GPIO_In;
  5.      RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
  7.      //TX dla pinu PB6
  8.      GPIO_In.GPIO_Pin = GPIO_Pin_10;
  9.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
  10.      GPIO_In.GPIO_OType = GPIO_OType_PP;
  11.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
  12.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
  13.      GPIO_Init(GPIOC, &GPIO_In);
  15.      //RX dla pinu PB7
  16.      GPIO_In.GPIO_Pin = GPIO_Pin_11;
  17.      GPIO_In.GPIO_Mode = GPIO_Mode_AF;
  18.      GPIO_In.GPIO_PuPd = GPIO_PuPd_UP;
  19.      GPIO_In.GPIO_OType = GPIO_OType_PP;
  20.      GPIO_In.GPIO_Speed = GPIO_Speed_100MHz;
  21.      GPIO_Init(GPIOC, &GPIO_In);
  23.      //Wlaczenie transmisji na podanych pinach
  24.      GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_USART3);
  25.      GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_USART3);
  26. }
  28. void USART_Initialize(void)
  29. {
  30.      GPIO_Initialize();
  32.      USART_InitTypeDef USART_InitStructure;
  34.      RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
  36.      USART_InitStructure.USART_BaudRate = 115200;
  37.      USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  38.      USART_InitStructure.USART_StopBits = USART_StopBits_1;
  39.      USART_InitStructure.USART_Parity = USART_Parity_No;
  40.      USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  41.      USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  42.      USART_Init(USART3, &USART_InitStructure);
  44.      USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);
  46.      USART_Cmd(USART3, ENABLE);
  47. }
  49. void USART_puts(volatile char *c)
  50. {
  51.       while (*c != 0)
  52.       {
  53.           SendChar(*c);
  54.           c++;
  55.       }
  56. }
  58. void SendChar(char c)
  59. {
  60.       while (USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET);
  61.       USART_SendData(USART3, c);
  62. }

Obsługa przycisku:

Przycisk odpowiedzialny jest za włączenie pomiaru pojedynczego, ponowne włączenie inicjalizuje kolejny pomiar. Oba są brane do obliczenia powierzchni danego pudła czy np. pokoju. Po tym w przypadku pudła bądź innego pojemnika można obliczyć jaka jest wartość jego zapełnienia.

Ja wykorzystałem pin PA3 wraz z zewnętrznym przyciskiem. Nie wykorzystałem pinu PA0 z przyciskiem ponieważ do niego mam podłaczoną jedną z nóg od HCSR04. W przerwaniu zwiększana jest wartość flagi która następnie w pętli głównej w zależności od jej wartości wyświetla dane.

  1. void ButtonInit(void)
  2. {
  3.      EXTI_InitTypeDef EXTI_InitStruct;
  4.      NVIC_InitTypeDef NVIC_InitStruct;
  5.      GPIO_InitTypeDef GPIO_InitDef;
  7.      RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
  9.      RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  11.      GPIO_InitDef.GPIO_Pin = GPIO_Pin_3;
  12.      GPIO_InitDef.GPIO_OType = GPIO_OType_PP;
  13.      //Ustawienie jako wejście
  15.      GPIO_InitDef.GPIO_Mode = GPIO_Mode_IN;
  16.      GPIO_InitDef.GPIO_PuPd = GPIO_PuPd_NOPULL;
  17.      GPIO_InitDef.GPIO_Speed = GPIO_Speed_100MHz;
  18.      GPIO_Init(GPIOA, &GPIO_InitDef);
  20.      //Wybranie EXTI dla konkretnego pinu
  21.      SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource3);
  23.      EXTI_InitStruct.EXTI_Line = EXTI_Line3;
  24.      EXTI_InitStruct.EXTI_LineCmd = ENABLE;
  25.      EXTI_InitStruct.EXTI_Mode = EXTI_Mode_Interrupt;
  26.      EXTI_InitStruct.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
  27.      EXTI_Init(&EXTI_InitStruct);
  29.      NVIC_InitStruct.NVIC_IRQChannel = EXTI3_IRQn;
  30.      NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0x00;
  31.      NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0x00;
  32.      NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
  33.      NVIC_Init(&NVIC_InitStruct);
  34. }

Obsługa przerwania:

  1. void EXTI3_IRQHandler(void)
  2. {
  3.  if (EXTI_GetITStatus(EXTI_Line3) != RESET)
  4.  {
  5.      EXTI_ClearITPendingBit(EXTI_Line3);
  6.      
  7.         if (Button_flag == 0)
  8.         {
  9.             Wymiar_Dane.szerokosc1 = 0;
  10.             Wymiar_Dane.szerokosc2 = 0;
  11.             Wymiar_Dane.wysokosc = 0;
  12.             Wymiar_Dane.rozmiar = 0;
  13.             //Wykonanie pierwszego pomiaru
  14.             Wymiar_Dane.szerokosc1 = HC_SR04_Distance_Few_Data((float)10.0, 1, Srednia_temp);
  15.         }
  16.         else if(Button_flag == 1)
  17.         {
  18.             //Wykoanie drugiego pomiaru i wyswietlenie danych
  19.             Wymiar_Dane.szerokosc2 = HC_SR04_Distance_Few_Data((float)10.0, 1, Srednia_temp);
  20.         }
  21.         else if(Button_flag == 2)
  22.         {
  23.             //Wykoanie drugiego pomiaru i wyswietlenie danych
  24.             Wymiar_Dane.wysokosc = HC_SR04_Distance_Few_Data((float)10.0, 1, Srednia_temp);
  25.             Wymiar_Dane.rozmiar = Wymiar_Dane.szerokosc1 * Wymiar_Dane.szerokosc2 * Wymiar_Dane.wysokosc; //obliczona objetosc
  26.             sprintf(bufer, "Szero1: %f | Szero2: %f %\n\r", Wymiar_Dane.szerokosc1, Wymiar_Dane.szerokosc2);
  27.             USART_puts(bufer);
  28.             sprintf(bufer, "Wysokosc: %f | Rozmiar: %f %\n\r", Wymiar_Dane.wysokosc, Wymiar_Dane.rozmiar);
  29.             USART_puts(bufer);
  30.         }
  31.         else if(Button_flag == 3)
  32.         {
  33.             Wymiar_Dane.szerokosc1 = 0.0;
  34.             Wymiar_Dane.szerokosc2 = 0.0;
  35.             Wymiar_Dane.wysokosc = 0;
  36.         }
  38.      Button_flag++;
  39.      if(Button_flag == 4) { Button_flag = 0; }
  40.  }
  41. }

Dane dotyczące rozmiarów oraz zapełnienia przechowywane są w przygotowanej strukturze:

  1. typedef struct Wymiar{
  2.     float szerokosc1;
  3.     float szerokosc2;
  4.     float wysokosc;
  5.     float rozmiar;
  6.     float zapelnienie;
  7. }wymiar_t;
  9. wymiar_t Wymiar_Dane;

MAIN

W głównej części programu włączane są wszystkie potrzebne elementy, po nich sprawdzane są czujniki podłączone na linii onewire. W dalszej części następuje wykonanie pomiarów oraz wyświetlenie informacji.

  1. int main(void)
  2. {
  3.     float distance = 0.0;
  4.     float temps[SENSORS];
  6.     ErrorStatus check;
  7.     char buf[40];
  8.     uint8_t devices, i, count;
  9.     uint8_t device[SENSORS][8];
  10.     //---------------------------------------------------------------
  11.     SystemInit();
  12.     SYSTICK_ON(0);
  13.     //---------------------------------------------------------------
  14.     LedInit();
  15.     ButtonInit();
  16.     USART_Initialize();
  17.     USART_puts("LED USART INIT\n\r");
  18.     //---------------------------------------------------------------
  19.     OneWire_DS_t OneWire1_Sensors;
  20.     OneWire_Init(&OneWire1_Sensors, GPIOB, GPIO_Pin_8);
  21.     USART_puts("ONE_WIRE_INIT\n\r");
  22.     //---------------------------------------------------------------
  23.     HCSR04_Init();
  24.     USART_puts("HCSR04\n\r");
  25.     //---------------------------------------------------------------
  26.     count = 0;
  27.     devices = OneWire_First(&OneWire1_Sensors);
  28.     USART_puts("One wire init\n\r");
  29.     //---------------------------------------------------------------
  30.     GPIO_NOKIA_INIT();
  31.     SPI_NOKIA_INIT();
  32.     NOKIA_INIT();
  33.     LCD_CLEAR();
  34.     LCD_DRAW(1, 1, "Init Ok");
  35.     USART_puts("LCD INIT\n\r");
  36.     //---------------------------------------------------------------
  37.     while (devices)
  38.     {
  39.         count++;
  40.         OneWire_GetFullROM(&OneWire1_Sensors, device[count - 1]);
  41.         devices = OneWire_Next(&OneWire1_Sensors);
  42.     }
  44.     if (count > 0)
  45.     {
  46.         sprintf(buf, "Urzadzenia obecne na lini: %d\n", count);
  47.         USART_puts(buf);
  49.         for (i = 0; i < count; i++)
  50.         {
  51.             DS18B20_Set_Resolution(&OneWire1_Sensors, device[i], DS18B20_Resolution_12bits);
  52.         }
  54.     }
  55.         while (1)
  56.         {
  57.             //Rozpoczecie konwersji na wszystkich urzadzeniach podlaczonych na linii
  58.             DS18B20_Start_All_Sensors(&OneWire1_Sensors);
  60.             //Odczekanie na zakonczenie pobierania temperatury
  61.             while (!DS18B20_Check_Conversion_Complete(&OneWire1_Sensors));
  63.             //Odczytaj temperaturę z każdego urządzenia oddzielnie
  64.             for (i = 0; i < count; i++)
  65.             {
  66.                 // Read temperature from ROM address and store it to temps variable
  67.                 if (DS18B20_Read_Data(&OneWire1_Sensors, device[i], &temps[i]))
  68.                 {
  69.                     //Print temperature
  70.                     sprintf(buf, "Temp %d: %3.5f ", i, temps[i]);
  71.                     USART_puts(buf);
  72.                     sprintf(buf, "T %d:%3.5f", i, temps[i]);
  73.                     LCD_DRAW(i+2, 1, buf);
  74.                     Srednia_temp += temps[i];
  75.                 }
  76.                 else
  77.                 {
  78.                     //Blad odczytu
  79.                     USART_puts("Reading error;\n");
  80.                 }
  81.             }
  83.             //-------------------------------------------------------------------------
  84.             Srednia_temp = (Srednia_temp*0.5);              //Obliczenie sredniej temperatury
  85.             sprintf(buf, "Ts:%3.5f", Srednia_temp);         //Przygotowanie wartosci
  86.             LCD_DRAW(4, 1, buf);                            //Wypisanie bufora
  87.             //-------------------------------------------------------------------------
  88.             //Obliczenie średniej wartosci
  89.             distance = HC_SR04_Distance_Few_Data((float)10.0, 1, Srednia_temp);
  91.             sprintf(bufer, " Dis: %f\n\r", distance);
  92.             USART_puts(bufer);
  94.             sprintf(bufer, "Dis %.4f", distance);
  95.             LCD_DRAW(1, 1, bufer);
  97.             Srednia_temp = 0.0;
  99.             //---------------------------------------------------------------
  100.             //Ustawienie diod swiecacych
  101.             if(distance<10)
  102.             {
  103.                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
  104.                 GPIO_ResetBits(GPIOD, GPIO_Pin_13);
  105.                 GPIO_ResetBits(GPIOD, GPIO_Pin_14);
  106.                 GPIO_ResetBits(GPIOD, GPIO_Pin_15);
  107.             }
  108.             else if(distance>50)
  109.             {
  110.                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
  111.                 GPIO_SetBits(GPIOD, GPIO_Pin_13);
  112.                 GPIO_ResetBits(GPIOD, GPIO_Pin_14);
  113.                 GPIO_ResetBits(GPIOD, GPIO_Pin_15);
  114.             }
  115.             else if(distance>100)
  116.             {
  117.                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
  118.                 GPIO_SetBits(GPIOD, GPIO_Pin_13);
  119.                 GPIO_SetBits(GPIOD, GPIO_Pin_14);
  120.                 GPIO_ResetBits(GPIOD, GPIO_Pin_15);
  121.             }
  122.             else if(distance>150)
  123.             {
  124.                 GPIO_SetBits(GPIOD, GPIO_Pin_12);
  125.                 GPIO_SetBits(GPIOD, GPIO_Pin_13);
  126.                 GPIO_SetBits(GPIOD, GPIO_Pin_14);
  127.                 GPIO_SetBits(GPIOD, GPIO_Pin_15);
  128.             }
  129.             //--------------------------------------------------------------
  130.             if(Button_flag == 2)
  131.             {
  132.               Wymiar_Dane.zapelnienie = distance * Wymiar_Dane.szerokosc1 * Wymiar_Dane.szerokosc2;
  133.                 Wymiar_Dane.zapelnienie = ((Wymiar_Dane.zapelnienie)*100)/Wymiar_Dane.rozmiar;
  135.                 sprintf(bufer, "Zapelnienie: %f %%\n\r", Wymiar_Dane.zapelnienie);
  136.                 USART_puts(bufer);
  138.                 sprintf(bufer, "Zap: %.4f %%", Wymiar_Dane.zapelnienie);
  139.                 LCD_DRAW(5, 1, bufer);
  141.             }
  142.         }
  143. }

Pliki z projektem można znaleźć na dysku Google pod tym linkiem.
Autor: o
Etykiety: , , , ,