Raspberry Pi - Układ do bezpiecznego włączania/wyłączania

W tym poście chciałbym opisać układ będący częścią wcześniejszego postu o wyłączaniu i włączaniu Raspberry Pi.

[Źródło: https://www.raspberrypi.org/products/raspberry-pi-3-model-b/]

Główny układ zarządzający sterowaniem jest ATTiny.

Programy sterujące zostały przygotowane zarówno dla Raspberry Pi jak i dla ATTiny.

Głównym powodem dla którego taki układ mógłby być przydatny jest konieczność wyłączania i włączania Raspberry Pi gdy niemożliwe jest wyłączenie np. komendą i ponowne wpięcie kabla do układu w celu uruchomienia urządzenia. 

Raspberry Pi:

W związku z tym, że linia I2C jest wykorzystywana to wyłączanie zasilania wykonałem na innym pinie. Tutaj można wykorzystać właściwie każdy z dostępnych pinów.

Jedynym zadaniem tego programu, jest oczekiwanie na wciśniecie przycisku. Gdy zostanie on już wciśnięty to następuje odliczenie czasu, około 10s, co zostało rozwiązane za pomocą opóźnienia Po czasie 1 sekundy zostaje zwiększony licznik z danymi przechowującymi ilość odczekanych sekund.

Jak już odliczanie dobiegnie końca to następuje wyłączenie Raspberry Pi za pomocą komendy:

1. sudo shutdown -h now

Cały kod umieszczony na raspberry został napisany w języku Python. I wygląda następująco:

1. from gpiozero import Button, LED
2. import time
3. import os
5. statusLine = LED(4)
6. stopButton = Button(26)
7. checkValue = 0
9. statusLine.on()
11. while True:
12.     if stopButton.is_pressed:
13.         time.sleep(1)
14.         if stopButton.is_pressed:
15.             checkValue = checkValue + 1
16.         else:
17.             checkValue=0
18.         if checkValue==10:
19.             checkValue=0
20.             statusLine.off()
21.             os.system("sudo shutdown now -h")
22.             statusLine.off()
23.     if checkValue==0:
24.         time.sleep(1)

Do sterowania portami wykorzystałem bibliotekę gpiozero. Button odpowiada za sygnał wejściowy, LED za wyjściowy.

Skrypt musi być uruchamiany przy każdym włączeniu urządzenia. Pod tym linkiem można znaleźć kilka sposobów na wywołanie programu po starcie systemu LINK.

ATTiny:

Tutaj dzieje się już znacznie więcej, natomiast też nie jest to mocno skomplikowany projekt.

Zacznę od opisu części sprzętowej. Poniżej schemat dodatkowej płytki pomagającej wykonanie funkcji resetu:

Głównym układem zarządzającym jest ATtiny13. Do płyty został podłączony jeden przycisk który odpowiada za włączenie/wyłączenie urządzenia. Drugi przycisk odpowiada za awaryjny reset urządzenia.

Kolejnym elementem jest wyjście zasilania, które podaje napięcie na Raspberry Pi. Po włączeniu zasilania i spełnieniu warunków do uruchomienia wysterowywany jest tranzystor p mosfet.

Ponieważ do projektu jest dołączona bateria to wykorzystuje także przetwornik ADC. Gdy poziom baterii będzie za niski to układ automatycznie wyłączony Raspberry Pi, bądź nie pozwoli na jego uruchomienie. 

W związku z tym, że wykorzystywane jest ADC to niezbędne jest stabilne napięcie zasilania. Dlatego został dołączony stabilizator napięcie 5V. Tak aby napięcie zasilajce zawsze wynosiło 5V bez względu na stan baterii.

Ostatnie dwa wyprowadzenia służą do ustawiania i sprawdzania stanu ustawionego na RPI. Linia PB1 ustawiania stan wysoki w celu rozpoczęcia przez RPI odliczania do wyłączenia systemu.

Druga linia PB4 sprawdza stan na RPI. Gdy system wystartował to ta linia ustawiana jest na wysoko (przez RPI). Po wyłączeniu raspbiana linia podciągana jest do masy. Dzięki temu po stanie pinu można określić kiedy odciąć zasilanie.

Po wciśnięciu przycisku układ wystawia stan wysoki na jeden z pinów. Tak aby Raspberry pi mogło rozpocząć odliczanie.

ATTiny program:

Zacznę od definicji poszczególnych portów:

1.     DDRB  &= ~SYS_OK_PIN;
2.     PORTB &= ~SYS_OK_PIN;
3.    
4.     DDRB |= STANDBY_PIN;
5.     PORTB |= STANDBY_PIN;
7.     DDRB  &= ~BUTTON_PIN;
8.     PORTB &= ~BUTTON_PIN;
10.     DDRB |= ON_OFF_DC_PIN;
11.     PORTB |= ON_OFF_DC_PIN;
12.    
13.     ADMUX |= (1 << MUX0)|(1 << MUX1); // select ADC3 (PB3)
14.     ADCSRA |= (1 << ADPS1) | (1 << ADPS0) | (1 << ADEN);
15.     ADMUX |= (0 << REFS0);

Powyżej opisane są ustawienia dla portów:

• SYS-OK - Wejście informujące o działaniu Raspberry Pi. Gdy system uruchomiony to linia jest wysterowana wysoko.
• STANDBY - Pin wyjściowy sterujący włączeniem/wyłączeniem urządzenia. Podłączony bezpośrednio do Raspberry.
• BUTTON - Pod tą linię zostały podpięty przycisk włączania/wyłączania Raspberry.
• ON_OFF_DC - Uruchomienie zasilania. 
• ADC - Pomiar stanu baterii.

W pętli głównej sprawdzane są poszczególne elementy np. wykonywane pomiary ADC itp.

Na samym początku sprawdzany jest stan przycisku:

1. if ((PINB & BUTTON_PIN) == BUTTON_PIN)
2. {  
3.     if((analogData > 630) && ((PINB & ON_OFF_DC_PIN) == ON_OFF_DC_PIN) && (PINB & SYS_OK_PIN) != SYS_OK_PIN)
4.     {
5.         PORTB &= ~ON_OFF_DC_PIN;    //Uruchomienie zasilania
6.         enablePowerFlag = 1;
7.     }
8.     else if((PINB & SYS_OK_PIN) == SYS_OK_PIN)
9.     {
10.         PORTB &= ~STANDBY_PIN;
11.         enablePowerFlag = 0;
12.         checkOffBtnState_Flag = 1;
13.     }
14.     else
15.     {
16.         PORTB |= STANDBY_PIN;
17.     }
18. }

Tutaj sprawdzam czy przycisk został wciśnięty jeśli tak to należy się upewnić czy urządzenia jest wyłączone czy nie na podstawie pinu SYS_OK. Aby urządzenie mogło zostać poprawnie uruchomione to bateria musi być odpowiednio naładowana. To sprawdzam przez pomiar ADC.

Pomiar wartości ADC z prostym uśrednianiem:

1. analogData = 0;
2. for(uint8_t i=0; i<8; i++)
3. {
4.     analogData += adc_read();
5.     _delay_ms(1);
6. }
7.    
8. analogData = analogData/8;
10. if(analogData < 630)
11. {
12.     counterADCValues++;
13.     if(counterADCValues >= MAX_ADC_BELOW_VALUES)
14.     {
15.         counterADCValues = 0;
16.         PORTB &= ~STANDBY_PIN;
17.     }
18. }
19. else
20. {
21.     counterADCValues=0;
22. }

Odczyt danych z przetwornika ADC:

1. int adc_read (void)
2. {
3.     ADCSRA |= (1 << ADSC);
4.    
5.     while (ADCSRA & (1 << ADSC));
6.    
7.     return ADC;
8. }

Sprawdzenie ustawienia flagi i utrzymywania sygnału na pinie przycisku:

1. if((checkOffBtnState_Flag == 1) && (PINB & BUTTON_PIN) != BUTTON_PIN)
2. {
3.     PORTB |= STANDBY_PIN;
4.     checkOffBtnState_Flag = 0;
5. }

Teraz część dotycząca wyłączania/załączania zasilania w zależności od stanu na pinach:

1. if((PINB & SYS_OK_PIN) == SYS_OK_PIN)      
2. {
3.     enablePowerFlag = 0;
4. }
5. else if(((PINB & SYS_OK_PIN) != SYS_OK_PIN) && enablePowerFlag == 1)
6. {
7.     _delay_ms(1000);
8.     bootingCounter++;
9.    
10.     if(bootingCounter == 40) //Błąd działania wyłącz urządzenie
11.     {
12.         bootingCounter = 0;
13.         PORTB &= ~STANDBY_PIN;
14.     }  
15. }
16. else if(((PINB & SYS_OK_PIN) != SYS_OK_PIN) && enablePowerFlag == 0)
17. {
18.     _delay_ms(10000);
19.     PORTB |= ON_OFF_DC_PIN;
20.     PORTB |= STANDBY_PIN;
21. }

Tutaj sprawdzam stan na pinach. Po wykryciu sygnału niskiego na pinie SYS_OK system odczekuje krótki interwał czasowy po czym wyłącza zasilanie. Przerwa czasowa jest przewidziana na wyłączenie Raspberry, gdbyby z jakichś powodów zajęło to dłuższy odcinek czasu. W przypadku braku reakcji urządzenie zostanie wyłączone siłowo przez odcięcie zasilania jeśli czas na odłączenie będzie większy niż zadany.

Poniżej cały program dla ATTiny:

1. #define F_CPU 9600000
3. #include <avr/io.h>
4. #include <util/delay.h>
5. #include <avr/interrupt.h>
7. #define ON_OFF_DC_PIN   (1<<PB0)
8. #define STANDBY_PIN (1<<PB1)
9. #define SYS_OK_PIN  (1<<PB4)
10. #define AKU_ADC_PIN (1<<PB3)        //ADC3
11. #define BUTTON_PIN  (1<<PB2)
13. #define MAX_ADC_BELOW_VALUES  10
15. volatile uint16_t analogData = 0;  
16. volatile uint8_t counterADCValues = 0;
17. volatile uint8_t enablePowerFlag = 0;
18. volatile uint16_t bootingCounter = 0;
19. volatile uint8_t checkOffBtnState_Flag = 0;
21. int adc_read (void)
22. {
23.     ADCSRA |= (1 << ADSC);
24.     while (ADCSRA & (1 << ADSC));
25.     return ADC;
26. }
28. int main(void)
29. {
30.     DDRB  &= ~SYS_OK_PIN;
31.     PORTB &= ~SYS_OK_PIN;
33.     DDRB |= STANDBY_PIN;
34.     PORTB |= STANDBY_PIN;
36.     DDRB  &= ~BUTTON_PIN;
37.     PORTB &= ~BUTTON_PIN;
39.     //URUCHOMIENIE ZASILANIA
40.     DDRB |= ON_OFF_DC_PIN;
41.     PORTB |= ON_OFF_DC_PIN;
42.    
43.     ////ADC
44.     ADMUX |= (1 << MUX0)|(1 << MUX1); // select ADC3 (PB3)
45.     ADCSRA |= (1 << ADPS1) | (1 << ADPS0) | (1 << ADEN);
46.     ADMUX |= (0 << REFS0);
47.            
48.     while(1)
49.     {
50.         if ((PINB & BUTTON_PIN) == BUTTON_PIN)
51.         {  
52.             if((analogData > 630) && ((PINB & ON_OFF_DC_PIN) == ON_OFF_DC_PIN) && (PINB & SYS_OK_PIN) != SYS_OK_PIN)
53.             {
54.                 PORTB &= ~ON_OFF_DC_PIN;
55.                 enablePowerFlag = 1;
56.             }
57.             else if((PINB & SYS_OK_PIN) == SYS_OK_PIN)
58.             {
59.                 PORTB &= ~STANDBY_PIN;
60.                 enablePowerFlag = 0;
61.                 checkOffBtnState_Flag = 1;
62.             }
63.             else
64.             {
65.                 PORTB |= STANDBY_PIN;
66.             }
67.         }
68.         //------------------------------------------------------------------------
69.         if((checkOffBtnState_Flag == 1) && (PINB & BUTTON_PIN) != BUTTON_PIN)
70.         {
71.             PORTB |= STANDBY_PIN;
72.             checkOffBtnState_Flag = 0;
73.         }
74.         //------------------------------------------------------------------------
75.         //Wylaczenie zasilania gdy nie ma nic na pinie SYS_OK      
76.         if((PINB & SYS_OK_PIN) == SYS_OK_PIN)      
77.         {
78.             enablePowerFlag = 0;
79.             //System dzia�a
80.         }
81.         else if(((PINB & SYS_OK_PIN) != SYS_OK_PIN) && enablePowerFlag == 1)
82.         {
83.             _delay_ms(1000);
84.             bootingCounter++;
85.            
86.             if(bootingCounter == 40) //B��d dzia�ania wy��cz urz�dzenie
87.             {
88.                 bootingCounter = 0;
89.                 PORTB &= ~STANDBY_PIN;
90.             }
91.         }
92.         else if(((PINB & SYS_OK_PIN) != SYS_OK_PIN) && enablePowerFlag == 0)
93.         {
94.             _delay_ms(10000);
95.             PORTB |= ON_OFF_DC_PIN;
96.             PORTB |= STANDBY_PIN;
97.         }
98.         //-----------------------------------------------------------------------
99.         //Pomiar ADC
100.         analogData = 0;
101.         for(uint8_t i=0; i<8; i++)
102.         {
103.             analogData += adc_read();
104.             _delay_ms(1);
105.         }
106.        
107.         analogData = analogData/8;
109.         if(analogData < 630)
110.         {
111.             counterADCValues++;
112.             if(counterADCValues >= MAX_ADC_BELOW_VALUES)
113.             {
114.                 counterADCValues = 0;
115.                 PORTB &= ~STANDBY_PIN;
116.             }
117.         }
118.         else
119.         {
120.             counterADCValues=0;
121.         }
122.     }
123. }