[26] Arduino - Cyfrowy czujnik ciśnienia MPL3115A2

Tym razem chciałbym opisać sposób obsługi cyfrowego czujnika z interfejsem I2C. Pozwala on na pomiar takich parametrów jak ciśnienie, wysokość nad poziomem morza oraz temperaturę.

MPL3115A2 - Opis

Parametry czujnika:

• Wartość napięcia zasilania od 1,95 do 3,6V;
• Wyprowadzenia pracują z napięciem od 1,6V do 3,6V;
• Komunikacja poprzez interfejs I2C;
• Barometr: zakres pracy od 50 do 110 kPa, dokładnosć +/- 0,05kPa, rozdzielczość 20 bitów;
• Termometr: zakres pomiarowy od -40 do 85 st. C, dokładność +/- 1 st. C dla 25 st. C, +/- 3 w pozostałym zakresie;
• Wysokość: dokładność do 30cm, rodzielczość 20 bitów;
• Wbudowana kolejka FIFO;

Rys. 1. Moduł Sparkfun z czujnkiem MPL3115A2

Płytka przedstawiona na rysunku zawiera czujnik MPL3115A2. Dodatkowo na płytce umieszczono dodatkowe kondensatory filtrujące oraz rezystory podciągające linie SDA oraz SCL do zasilania.

Rys. 2. Schemat płytki

Czujnik oraz wspomniana płytka prototypowa posiada następujące wyprowadzenia z układu:

• INT2 - wyzwalanie dla przerwań od układu;
• INT1 - wyzwalanie dla przerwań od układu;
• SDA - linia danych;
• SCL - linia zegarowa;
• VCC - zasilanie układu, akceptowane od 1,95 do 3,6V;
• GND - masa układu;

Podłączenie

Układ należy podłączyć do płytki Arduino w następujący sposób:

• INT2 - NC
• INT1 - NC
• SDA - SDA Arduino
• SCL - SCL Arduino
• VCC - 3.3V
• GND - GND

Jeśli wykorzystuje się Arduino Uno posiadające piny 5V wtedy należy zastosować konwerter poziomów logicznych. W przypadku montażu rezystorów, jak opisano na stronie producenta, nie udaje się skomunikować z czujnikiem. Konwerter można pominąć w przypadku obsługi układu na Arduino Pro mini. 

Biblioteka

Poniżej przedstawię opis biblioteki układu wraz z opisem poszczególnych rejestrów oraz głównych funkcji.

Biblioteka dla obsługi interfejsu I2C wykorzystuje wire.h, Główna część biblioteki MPL3115A2 zawiera sposób rozpoczęcia transmisji oraz pobrania danych.

Podstawowym elementem jest opis poszczególnych adresów rejestrów czujnika:

1. #define MPL3115A2_ADDRESS 0x60
3. #define STATUS     0x00
4. #define OUT_P_MSB  0x01
5. #define OUT_P_CSB  0x02
6. #define OUT_P_LSB  0x03
7. #define OUT_T_MSB  0x04
8. #define OUT_T_LSB  0x05
9. #define DR_STATUS  0x06
10. #define OUT_P_DELTA_MSB  0x07
11. #define OUT_P_DELTA_CSB  0x08
12. #define OUT_P_DELTA_LSB  0x09
13. #define OUT_T_DELTA_MSB  0x0A
14. #define OUT_T_DELTA_LSB  0x0B
15. #define WHO_AM_I   0x0C
16. #define F_STATUS   0x0D
17. #define F_DATA     0x0E
18. #define F_SETUP    0x0F
19. #define TIME_DLY   0x10
20. #define SYSMOD     0x11
21. #define INT_SOURCE 0x12
22. #define PT_DATA_CFG 0x13
23. #define BAR_IN_MSB 0x14
24. #define BAR_IN_LSB 0x15
25. #define P_TGT_MSB  0x16
26. #define P_TGT_LSB  0x17
27. #define T_TGT      0x18
28. #define P_WND_MSB  0x19
29. #define P_WND_LSB  0x1A
30. #define T_WND      0x1B
31. #define P_MIN_MSB  0x1C
32. #define P_MIN_CSB  0x1D
33. #define P_MIN_LSB  0x1E
34. #define T_MIN_MSB  0x1F
35. #define T_MIN_LSB  0x20
36. #define P_MAX_MSB  0x21
37. #define P_MAX_CSB  0x22
38. #define P_MAX_LSB  0x23
39. #define T_MAX_MSB  0x24
40. #define T_MAX_LSB  0x25
41. #define CTRL_REG1  0x26
42. #define CTRL_REG2  0x27
43. #define CTRL_REG3  0x28
44. #define CTRL_REG4  0x29
45. #define CTRL_REG5  0x2A
46. #define OFF_P      0x2B
47. #define OFF_T      0x2C
48. #define OFF_H      0x2D

Procedura rozpoczęcia transmisji jest inicjowana poprzez wywołanie funkcji z biblioteki Wire.h

1. bool MPL3115A2::begin(void)
2. {
3.   Wire.begin();
4. }

Następnie pojawiają się funkcje obsługujące odczytywanie wartości. W pierwszej kolejneści pojawia się opcja odczytania wysokości nad poziomem morza. Zdefiniowane są jej dwa warianty, zwracające wartość w metrach oraz stopach. Gdy wystąpi błąd odczytu to zwrócona zostanie wartość -1.

1. float MPL3115A2::readAltitude()
2. {
3.     //Ustawienie i wyzerowanie bitu OST, pozwalającemu na ponowny odczyt danych
4.     toggleOneShot();
6.     //Czekanie na bit PDR, informujący o pobraniu nowych danych
7.     int counter = 0;
8.     while( (IIC_Read(STATUS) & (1<<1)) == 0)
9.     {
10.         //Wywołanie errora po max 512ms
11.         if(++counter > 600) return(-999);
12.         delay(1);
13.     }
15.     //Odczytanie danych z rejestru
16.     Wire.beginTransmission(MPL3115A2_ADDRESS);
17.     //Adres danych do pobrania
18.     Wire.write(OUT_P_MSB);
19.     //Zakonczenie transmisji, przesłanie danych przez I2C z opcją ponownego startu
20.     Wire.endTransmission(false);
21.     //Ządanie 3 bitów
22.     Wire.requestFrom(MPL3115A2_ADDRESS, 3); // Request three bytes
24.     //Odczekanie na dostępność danych
25.     counter = 0;
26.     while(Wire.available() < 3)
27.     {
28.         if(counter++ > 100) return(-999); ==
29.         delay(1);
30.     }
31.    
32.     //Odczytanie danych
33.     byte msb, csb, lsb;
34.     msb = Wire.read();
35.     csb = Wire.read();
36.     lsb = Wire.read();
38.     //Dane sa 4 bitowe, nalezy przesunąc je o 4 bity i podzielic przez 16
39.     //poniewaz na 4 bitach mozna zapisac 16 wartosci
40.     float tempcsb = (lsb>>4)/16.0;
41.    
42.     //Obliczenie wysokosci
43.     float altitude = (float)( (msb << 8) | csb) + tempcsb;
45.     return(altitude);
46. }

Następna funkcja odczytuje wartość ciśnienia:

1. float MPL3115A2::readPressure()
2. {
3.     //Sprawdzenie czy bit PDR jest ustawiony, jak nie to wlaczenie
4.     //i wylaczenie bitu OST
5.     if(IIC_Read(STATUS) & (1<<2) == 0) toggleOneShot();
7.     //Odczekanie na bit PDR
8.     int counter = 0;
9.     while(IIC_Read(STATUS) & (1<<2) == 0)
10.     {
11.         if(++counter > 600) return(-999);
12.         delay(1);
13.     }
15.     // Odczytanie danych z rejestru
16.     Wire.beginTransmission(MPL3115A2_ADDRESS);
17.     Wire.write(OUT_P_MSB);  // Address of data to get
18.     Wire.endTransmission(false);
19.     Wire.requestFrom(MPL3115A2_ADDRESS, 3); // Request three bytes
21.     //Odczekanie na dane
22.     counter = 0;
23.     while(Wire.available() < 3)
24.     {
25.         if(counter++ > 100) return(-999);
26.         delay(1);
27.     }
29.     //Odczytanie danych
30.     byte msb, csb, lsb;
31.     msb = Wire.read();
32.     csb = Wire.read();
33.     lsb = Wire.read();
34.    
35.     //Wlaczenie i wylaczenie OST
36.     toggleOneShot();
38.     //Wartość cisnienia jako przesunięty w lewo 20 bitowy
39.     long pressure_whole = (long)msb<<16 | (long)csb<<8 | (long)lsb;
40.     pressure_whole >>= 6;
41.    
42.     //Bity 5/4 reprezentują część ulamkowa
43.     lsb &= 0b00110000;
44.     lsb >>= 4;
45.     float pressure_decimal = (float)lsb/4.0;
47.     float pressure = (float)pressure_whole + pressure_decimal;
49.     return(pressure);
50. }

Dalej funkja odczytująca temperaturę:

1. float MPL3115A2::readTemp()
2. {
3.     if(IIC_Read(STATUS) & (1<<1) == 0) toggleOneShot();
5.     int counter = 0;
6.     while( (IIC_Read(STATUS) & (1<<1)) == 0)
7.     {
8.         if(++counter > 600) return(-999);
9.         delay(1);
10.     }
12.     //Odczytanie danych dotyczacych temperatury
13.     Wire.beginTransmission(MPL3115A2_ADDRESS);
14.     Wire.write(OUT_T_MSB);  // Address of data to get
15.     Wire.endTransmission(false);
16.     //Rządanie dwóch bytow
17.     Wire.requestFrom(MPL3115A2_ADDRESS, 2);
19.     //Czekanie na dane
20.     counter = 0;
21.     while(Wire.available() < 2)
22.     {
23.         if(counter++ > 100) return(-999);
24.         delay(1);
25.     }
27.     byte msb, lsb;
28.     msb = Wire.read();
29.     lsb = Wire.read();
31.     toggleOneShot();
33.     word foo = 0;
34.     bool negSign = false;
36.     //Czekanie na przeslanie wszystkich danych
37.     if(msb > 0x7F)
38.     {
39.         foo = ~((msb << 8) + lsb) + 1;
40.         msb = foo >> 8;
41.         lsb = foo & 0x00F0;
42.         negSign = true;
43.     }
45.     float templsb = (lsb>>4)/16.0;
47.     float temperature = (float)(msb + templsb);
49.     if (negSign) temperature = 0 - temperature;
50.    
51.     return(temperature);
52. }

Pozostałe funkcje służą do ustawienia odpowiednich parametrów transmisji i do odpowiedniego zainicjowania transmisji.

1. //Ustawienie pomiaru ciśnienia
2. void MPL3115A2::setModeBarometer()
3. {
4.   //Odczytanie aktualnych ustawien z rejestru
5.   byte tempSetting = IIC_Read(CTRL_REG1);
6.   //Wyczyszczenie bitu ALT
7.   tempSetting &= ~(1<<7);
8.   //Wprowadzenie ustawien
9.   IIC_Write(CTRL_REG1, tempSetting);
10. }
12. //Ustawienie pomiaru wysokości
13. void MPL3115A2::setModeAltimeter()
14. {
15.   byte tempSetting = IIC_Read(CTRL_REG1);
16.   tempSetting |= (1<<7);
17.   IIC_Write(CTRL_REG1, tempSetting);
18. }
20. //Wprowadzenie czujnika w tryb StandBy
21. void MPL3115A2::setModeStandby()
22. {
23.   byte tempSetting = IIC_Read(CTRL_REG1);
24.   //Czyszczenie bitu SBYB
25.   tempSetting &= ~(1<<0);
26.   IIC_Write(CTRL_REG1, tempSetting);
27. }
29. //Wprowadzenie ukladu w tryb aktywny
30. void MPL3115A2::setModeActive()
31. {
32.   byte tempSetting = IIC_Read(CTRL_REG1);
33.   //Bit SBYB ustawiony na 1
34.   tempSetting |= (1<<0);
35.   IIC_Write(CTRL_REG1, tempSetting);
36. }
38. //Wywowywane z parametrem od 0 do 7. Ustawianie ilości probek od 1 do 128.
39. //Im większa liczba próbek tym większa doklodnosc oraz wiekszy czas pomiedzy
40. //kolejnymi próbkami danych
41. void MPL3115A2::setOversampleRate(byte sampleRate)
42. {
43.    
44.   if(sampleRate > 7) sampleRate = 7;
45.   //Ustawienie dla rejestry CTRL
46.   sampleRate <<= 3;
48.   //Odczytanie aktyalnych ustawien
49.   byte tempSetting = IIC_Read(CTRL_REG1);
50.   //Wyczyszczenie bitow OS
51.   tempSetting &= 0b11000111;
52.   //Zamaskowanie bitow
53.   tempSetting |= sampleRate;
54.   //Wprowadzenie danych
55.   IIC_Write(CTRL_REG1, tempSetting);
56. }
58. //Wlaczenie flag wystąpienia zdarzenia dla temperatur, i cisnienia
59. void MPL3115A2::enableEventFlags()
60. {
61.   IIC_Write(PT_DATA_CFG, 0x07);
62. }
65. //Czysci i ustawia bit OST, co powoduje ponowny odczyt danych,
66. void MPL3115A2::toggleOneShot(void)
67. {
68.   byte tempSetting = IIC_Read(CTRL_REG1);
69.   //Czyszczenie bitu OST
70.   tempSetting &= ~(1<<1);
71.   IIC_Write(CTRL_REG1, tempSetting);
73.   tempSetting = IIC_Read(CTRL_REG1);
74.   //ustawianie bitu OST
75.   tempSetting |= (1<<1);
76.   IIC_Write(CTRL_REG1, tempSetting);
77. }
78. 
    
79. // Odczytanie jednego byta danych
80. byte MPL3115A2::IIC_Read(byte regAddr)
81. {
82.   //Rozpoczęcie transmisji
83.   Wire.beginTransmission(MPL3115A2_ADDRESS);
84.   //Wprowadzenie adresu rejestru kontrolnego
85.   Wire.write(regAddr);
86.   Wire.endTransmission(false);
87.   //Zadanie danych
88.   Wire.requestFrom(MPL3115A2_ADDRESS, 1); // Request the data...
89.   return Wire.read();
90. }
92. //Wpisanie za pomocą interfejsu I2C
93. void MPL3115A2::IIC_Write(byte regAddr, byte value)
94. {
95.   Wire.beginTransmission(MPL3115A2_ADDRESS);
96.   Wire.write(regAddr);
97.   Wire.write(value);
98.   Wire.endTransmission(true);
99. }

Programowanie

Programowanie najlepiej rozpocząć od wgrania biblioteki, która znacząco ułatwi wykonanie całego projektu.

Poniżej pierwszy z programów. Będzie on w pętli odczytywał i wyświetlał dane poprzez port szeregowy. Jest to mała przeróbka jednego z programów jakie można znaleźć w przykładach.

1. #include <Wire.h>
2. #include "SparkFunMPL3115A2.h"
4. //Stworzenie obiektu funkcji
5. MPL3115A2 MPL311;
7. void setup()
8. {
9.   //Wlaczenie transmisji po interfejsie I2C
10.   Wire.begin();
11.   //Opcje transmisji po porcie szeregowym
12.   Serial.begin(9600);
14.   //Rozpoczęcie pracy z czujnikiem
15.   MPL311.begin(); // Get sensor online
17.   //Konfiguracja czujnikow
18.   MPL311.setModeAltimeter();
19.   MPL311.setModeBarometer();
21.   MPL311.setOversampleRate(3);
22.   MPL311.enableEventFlags();
23. }
25. void loop()
26. {
27.   float altitude = myPressure.readAltitude();
28.   Serial.print("Wysokosc npm(m):");
29.   Serial.print(altitude, 2);
31.   float pressure = myPressure.readPressure();
32.   Serial.print("Cisnienie(Pa):");
33.   Serial.print(pressure, 2);
35.   float temperature = myPressure.readTemp();
36.   Serial.print("Temperatura(c):");
37.   Serial.print(temperature, 2);
39.   delay(1000);
41.   Serial.println();
42. }

Oprócz opisanej powyżej biblioteki można jeszcze wykorzystać bibliotekę udostępnioną przez Adafruit. Poniżej zmodyfikowany przykład do obsługi czujnika:

1. #include <Wire.h>
2. #include <Adafruit_MPL3115A2.h>
4. Adafruit_MPL3115A2 MPL311 = Adafruit_MPL3115A2();
6. void setup()
7. {
8.   Serial.begin(9600);
9.   Serial.println("MPL3115A2!");
10. }
12. void loop()
13. {
14.   float altm, pascals, tempC;
16.   //Wlaczenie czujnika, sprawdzenie odpowiedzi
17.   if (!MPL311.begin())
18.   {
19.     Serial.println("Couldnt find sensor");
20.     return;
21.   }
23.   //Odebranie cisnienia
24.   pascals = MPL311.getPressure();
25.   Serial.print(pascals/3377);
26.   Serial.println(" - Cisnienie");
28.   altm = MPL311.getAltitude();
29.   Serial.print(altm);
30.   Serial.println(" - Wysokosc");
32.   tempC = MPL311.getTemperature();
33.   Serial.print(tempC);
34.   Serial.println(" - Temperatura");
36.   delay(1000);
37. }

Program będzie pobierał dane z czujnika, prezentował je na wyświetlaczu oraz zapisywał pobrane dane na kartę SD. Dane zostaną pobrane z czujnika, w między czasie wyświetlone na wyświetlaczu, po tych operacjach nastąpi zapis do pliku .txt.

1. #include <Wire.h>
2. #include <SparkFunMPL3115A2.h>
3. #include <SD.h>
4. #include <SPI.h>
6. #define PIN_CE    7
7. #define PIN_RESET 6
8. #define PIN_DC    5
9. #define PIN_DIN   4
10. #define PIN_CLK   3
12. #define LCD_C     LOW
13. #define LCD_D     HIGH
15. #define LCD_X     84
16. #define LCD_Y     48
18. char buff1[10];
19. char buff2[10];
20. char buff3[10];
21. const int CSPin = 10;
22. int czas=0;
24. static const byte ASCII[][5] =
25. {
26.  {0x00, 0x00, 0x00, 0x00, 0x00} // 20  
27. ,{0x00, 0x1c, 0x22, 0x41, 0x00} // 28 (
28. ,{0x00, 0x41, 0x22, 0x1c, 0x00} // 29 )
29. ,{0x3e, 0x51, 0x49, 0x45, 0x3e} // 30 0
30. ,{0x00, 0x42, 0x7f, 0x40, 0x00} // 31 1
31. ,{0x42, 0x61, 0x51, 0x49, 0x46} // 32 2
32. ,{0x21, 0x41, 0x45, 0x4b, 0x31} // 33 3
33. ,{0x18, 0x14, 0x12, 0x7f, 0x10} // 34 4
34. ,{0x27, 0x45, 0x45, 0x45, 0x39} // 35 5
35. ,{0x3c, 0x4a, 0x49, 0x49, 0x30} // 36 6
36. ,{0x01, 0x71, 0x09, 0x05, 0x03} // 37 7
37. ,{0x36, 0x49, 0x49, 0x49, 0x36} // 38 8
38. ,{0x06, 0x49, 0x49, 0x29, 0x1e} // 39 9
39. ,{0x7e, 0x11, 0x11, 0x11, 0x7e} // 41 A
40. ,{0x7f, 0x49, 0x49, 0x49, 0x36} // 42 B
41. ,{0x3e, 0x41, 0x41, 0x41, 0x22} // 43 C
42. ,{0x7f, 0x41, 0x41, 0x22, 0x1c} // 44 D
43. ,{0x7f, 0x49, 0x49, 0x49, 0x41} // 45 E
44. ,{0x7f, 0x09, 0x09, 0x09, 0x01} // 46 F
45. ,{0x3e, 0x41, 0x49, 0x49, 0x7a} // 47 G
46. ,{0x7f, 0x08, 0x08, 0x08, 0x7f} // 48 H
47. ,{0x00, 0x41, 0x7f, 0x41, 0x00} // 49 I
48. ,{0x20, 0x40, 0x41, 0x3f, 0x01} // 4a J
49. ,{0x7f, 0x08, 0x14, 0x22, 0x41} // 4b K
50. ,{0x7f, 0x40, 0x40, 0x40, 0x40} // 4c L
51. ,{0x7f, 0x02, 0x0c, 0x02, 0x7f} // 4d M
52. ,{0x7f, 0x04, 0x08, 0x10, 0x7f} // 4e N
53. ,{0x3e, 0x41, 0x41, 0x41, 0x3e} // 4f O
54. ,{0x7f, 0x09, 0x09, 0x09, 0x06} // 50 P
55. ,{0x3e, 0x41, 0x51, 0x21, 0x5e} // 51 Q
56. ,{0x7f, 0x09, 0x19, 0x29, 0x46} // 52 R
57. ,{0x46, 0x49, 0x49, 0x49, 0x31} // 53 S
58. ,{0x01, 0x01, 0x7f, 0x01, 0x01} // 54 T
59. ,{0x3f, 0x40, 0x40, 0x40, 0x3f} // 55 U
60. ,{0x1f, 0x20, 0x40, 0x20, 0x1f} // 56 V
61. ,{0x3f, 0x40, 0x38, 0x40, 0x3f} // 57 W
62. ,{0x63, 0x14, 0x08, 0x14, 0x63} // 58 X
63. ,{0x07, 0x08, 0x70, 0x08, 0x07} // 59 Y
64. ,{0x61, 0x51, 0x49, 0x45, 0x43} // 5a Z
65. ,{0x20, 0x54, 0x54, 0x54, 0x78} // 61 a
66. ,{0x7f, 0x48, 0x44, 0x44, 0x38} // 62 b
67. ,{0x38, 0x44, 0x44, 0x44, 0x20} // 63 c
68. ,{0x38, 0x44, 0x44, 0x48, 0x7f} // 64 d
69. ,{0x38, 0x54, 0x54, 0x54, 0x18} // 65 e
70. ,{0x08, 0x7e, 0x09, 0x01, 0x02} // 66 f
71. ,{0x0c, 0x52, 0x52, 0x52, 0x3e} // 67 g
72. ,{0x7f, 0x08, 0x04, 0x04, 0x78} // 68 h
73. ,{0x00, 0x44, 0x7d, 0x40, 0x00} // 69 i
74. ,{0x20, 0x40, 0x44, 0x3d, 0x00} // 6a j
75. ,{0x7f, 0x10, 0x28, 0x44, 0x00} // 6b k
76. ,{0x00, 0x41, 0x7f, 0x40, 0x00} // 6c l
77. ,{0x7c, 0x04, 0x18, 0x04, 0x78} // 6d m
78. ,{0x7c, 0x08, 0x04, 0x04, 0x78} // 6e n
79. ,{0x38, 0x44, 0x44, 0x44, 0x38} // 6f o
80. ,{0x7c, 0x14, 0x14, 0x14, 0x08} // 70 p
81. ,{0x08, 0x14, 0x14, 0x18, 0x7c} // 71 q
82. ,{0x7c, 0x08, 0x04, 0x04, 0x08} // 72 r
83. ,{0x48, 0x54, 0x54, 0x54, 0x20} // 73 s
84. ,{0x04, 0x3f, 0x44, 0x40, 0x20} // 74 t
85. ,{0x3c, 0x40, 0x40, 0x20, 0x7c} // 75 u
86. ,{0x1c, 0x20, 0x40, 0x20, 0x1c} // 76 v
87. ,{0x3c, 0x40, 0x30, 0x40, 0x3c} // 77 w
88. ,{0x44, 0x28, 0x10, 0x28, 0x44} // 78 x
89. ,{0x0c, 0x50, 0x50, 0x50, 0x3c} // 79 y
90. ,{0x44, 0x64, 0x54, 0x4c, 0x44} // 7a z
91. };
93. MPL3115A2 MPL311;
95. void LcdCharacter(char);
96. void LcdClear(void);
97. void LcdString(char *);
98. void LcdWrite(byte, byte);
100. void setup()
101. {
102.   Serial.begin(9600);
103.   Serial.println("MPL3115A2!");
105.   LcdInitialise();
106.   LcdClear();
108.   //Rozpoczęcie pracy z czujnikiem
109.   MPL311.begin(); // Get sensor online
111.   //Konfiguracja czujnikow
112.   MPL311.setModeAltimeter();
113.   MPL311.setModeBarometer();
115.   MPL311.setOversampleRate(3);
116.   MPL311.enableEventFlags();
118.   pinMode(CSPin, OUTPUT);
120.   if (!SD.begin(CSPin))
121.   {
122.     Serial.println("Blad inicjalizacji karty");
123.     return;
124.   }
125.     Serial.println("Karta zostala poprawnie zainicjalizowana");
126. }
128. void loop()
129. {
130.   float altitude = MPL311.readAltitude();
131.   Serial.print("Wysokosc: ");
132.   Serial.print(altitude, 2);
133.   dtostrf(altitude, 2, 2, buff1);
134.   LcdString(buff1);
136.   float pressure = MPL311.readPressure();
137.   Serial.print("Cisnienie: ");
138.   Serial.print(pressure, 2);
139.   dtostrf(pressure, 2, 2, buff1);
140.   LcdString(buff2);
142.   float temperature = MPL311.readTemp();
143.   Serial.print("Temperatura: ");
144.   Serial.print(temperature, 2);
145.   dtostrf(temperature, 2, 2, buff1);
146.   LcdString(buff3);
148.   delay(1000);
150.   Serial.println();
152.   File myFile = SD.open("test.txt", FILE_WRITE);
153.   if (myFile)
154.   {
155.     myFile.print("Wysokosc: ");
156.     myFile.print(buff1);
157.    
158.     myFile.print("Cisnienie: ");
159.     myFile.print(buff2);
160.    
161.     myFile.print("Temperatura: ");
162.     myFile.print(buff3);
163.    
164.     myFile.println();
165.     myFile.close();
167.     Serial.print("Dane zapisane");
168.   }
169.   else
170.   {
171.     Serial.println("Blad otwarcia pliku");
172.   }
174.   delay(2000);
175. }
177. void LcdWrite(byte dc, byte data)
178. {
179.   //Wysłanie podanej wartości na wyświetlacz
180.   digitalWrite(PIN_DC, dc);
181.   //Podanie stanu niskiego na pin wybrania urządzenia
182.   digitalWrite(PIN_CE, LOW);
183.   //Funckja shiftOut przesyła jeden bit danych co sygnał zegara
184.   //Wysłanie danych na pin wejścia danych, oraz sygnału zegarowego na CLK
185.   //transmisja rozpoczęta od najbardziej znaczącego bitu
186.   shiftOut(PIN_DIN, PIN_CLK, MSBFIRST, data);
187.   //Podanie stanu wysokiego na pin wybrania urządzenia, zakońćzenie transmisji
188.   digitalWrite(PIN_CE, HIGH);
189. }
191. void LcdString(char *characters)
192. {
193.   //Funckja działająca dopóki są znaki w odwołaniu do funkcji
194.   while (*characters)
195.   {
196.     //Wprowadzanie kolejnego znaku
197.     LcdCharacter(*characters++);
198.   }
199. }
201. void LcdInitialise(void)
202. {
203.   //Inicjalizacja poszczególnych pinów
204.   pinMode(PIN_CE, OUTPUT);
205.   pinMode(PIN_RESET, OUTPUT);
206.   pinMode(PIN_DC, OUTPUT);
207.   pinMode(PIN_DIN, OUTPUT);
208.   pinMode(PIN_CLK, OUTPUT);
209.   digitalWrite(PIN_RESET, LOW);
210.   digitalWrite(PIN_RESET, HIGH);
211.   //Ustawienie odpowiednich komend na wyświetlacz
213.   //000100001 Wybranie zewnętrznych instrukcji
214.   LcdWrite(LCD_C, 0x21 );
215.   //010110001 Ustawienie kontrastu
216.   LcdWrite(LCD_C, 0xB1 );
217.   //000000100 Współczynnik temperaturowy na 0
218.   LcdWrite(LCD_C, 0x04 );
219.   //000010011 Ustawienie wartości Bias mode
220.   //na 4 dla MUX rate 1:48
221.   LcdWrite(LCD_C, 0x13 );
222.   //000100000 Właczenie podstawowych komend
223.   LcdWrite(LCD_C, 0x20 );  // LCD Basic Commands
224.   //000001100 Normalny tryb pracy
225.   LcdWrite(LCD_C, 0x0C );
226. }
228. void LcdClear(void)
229. {
230.   //Funckja przechodzi pomiędzy wszystkimi pikselami na tablicy
231.   //i wprodzana do nich wartość 0, czyli czyści ekran z umieszczonych znaków.
232.   for (int index = 0; index < LCD_X * LCD_Y / 8; index++)
233.   {
234.     LcdWrite(LCD_D, 0);
235.   }
236. }
238. void LcdCharacter(char character)
239. {
240.   //Stan wysoki na wyświetlacz wpisanie 0
241.   LcdWrite(LCD_D, 0);
242.   //Pętla przechodząca pomiędzy wszystkimi elementami
243.   for (int index = 0; index < 5; index++)
244.   {
245.     /*
246.     * Wystawienie stanu wysokiego , znaku z kolejnego miejsca
247.     * W tablicy jest - 0x20 ponieważ przetwarza znak na kod ASCII,
248.     * który jest wpisany do tablicy, a numerowanie w tablicy od 0
249.     */
250.     LcdWrite(LCD_D, ASCII[character - 0x20][index]);
251.   }
252.   //Zakończenie wpisanie 0
253.   LcdWrite(LCD_D, 0);
254. }