[1] PSOC4 - CY8CKIT-049-42xx - Uart, Capsense, LCD2x16

Ten post będzie krótkim projektem jaki wykonałem na nowych dla mnie mikrokontrolerach PSOC4. W obsłudze poprzez wbudowane biblioteki są one niezwykle proste.

Po zainstalowaniu środowiska i włączeniu czystego projektu można rozpocząć pracę z układem. Dosyć dużo informacji można znaleźć na youtubie na kanale Future Electronics. Ja tutaj przedstawię tylko kod programu oraz opis poszczególnych bloków, przynajmniej tych z których ja korzystałem.

Program

Dosyć dużym ułatwieniem jest tworzenie programu w środowisku graficznym. Można go trochę porównać do CubeMx. Z wyglądu wydaje się trochę uboższe natomiast funkcyjnie daje bardzo dużo możliwości.

Pierwszą podstawową rzeczą jest dołączenie bloku Bootloadable, u mnie w wersji 1.50. Pozwala on na zaprogramowanie mikrokontrolera poprzez interfejs UART. Dla mnie jest to jedyna opcja ponieważ posiadam układ CY8CKIT-049-42xx za 4 dolary, który jak na swoje możliwości jest niesamowicie tani i pozwala na wykonanie bardzo wielu zadań. 

Jedynym jego minusem jest to, że trzeba go wpinać i wypinać z portu USB co jest odrobinę niekomfortowe. Dodatkowo może pojawić się taka sytuacja że po podłączeniu program nie będzie widział płytki. W takim przypadku nie pomogą restarty itp. Trzeba odinstalować sterowniki USB-Serial SDK 2.0. Po czym zainstalować je ponownie. U mnie tylko w taki sposób problem zanikł, przynajmniej na teraz. 

Wracając do bloku Bootloadable, to w nim wystarczy tylko skonfigurować zakładkę Dependencies, gdzie wskazuje się na plik, z przykładu SCB_Bootloader (trzeba go skompilować i stworzyć z przykładowych aplikacji). Sciezka do niego to:

UART_Bootloader.cydsn\CortexM0\ARM_GCC_493\Debug\UART_Bootloader.hex

Następny w kolejności jest wyświetlacz LCD. Jego należy dodać poprzez przeciągnięcie z Cypress Component Catalog bloku Character LCD. W moim przypadku była to wersja 2.20.

Jedynym konfigurowalnym elementem jaki tu ustawiłem jest czcionka oraz zaznaczenie bloku dołączenia kodu ASCII.

Następnie blok UART (UART (SCB mode)):

No i wreszcie najważniejszy z nich czyli blok Capsense. 

W przypadku płytki PCB z wyprowadzonymi elektrodami, do testów wstępnych można zastosować kawałek kabla czy drutu podłączonego przez rezystor 560 Ohm do skonfigurowanego pinu. Producenci dopuszczają rezystory o wartościach od 560 do 1kOhm. Jest to głównie zależne od firmy jakiej rozwiązanie będzie stosowane.

Jeśli jest w posiadaniu płytka z przygotowanymi polami dotykowymi to podłączenie jakie należy wykonać wygląda następująco:

Więcej przydatnych materiałów oraz informacji można znaleźć w tym dokumencie.

To testów dobrze jest podłączyć pola odpowiedzialne za masę oraz shielda. Pozwalają one znacznie bardziej polepszyć działanie dotyku.

W przypadku klawiatur pojemnościowych duże znaczenie ma część sprzętowa. Należy się upewnić, że została ona przygotowana zgodnie z tym, co zostało przygotowane w notce producenta. Pozwoli to na poprawne działanie, przynajmniej z tej strony.

Ważne jest także aby odpowiednio poprowadzić pole masy. Należy je zaprojektować w formie siatki, nie powinno być jako pole pełne. Poprawi to znacząco odczuwanie dotyku, ponieważ masa w formie pełnej zwiększy wartości pojemności.

Sam kształt pola też nie jest bez znaczenia:

[AN64846 - str 71.]

Jak widać na obrazku powyżej najlepiej stosować pola okrągłe, opcjonalnie jako pełne z dziurą na diodę.

Same przyciski powinny być oddzielone od palca poprzez warstwę kawałka sztucznego materiału, co znacznie poprawi wygodę użytkowania, oraz pozwoli na dokładne sprawdzenie jakości programu.

PSOC:

Poniżej przejdę przez opis programu jaki przygotowałem do odczytania dotyku z klawiatury pojemnościowej z użyciem bibliotek jakie zostały udostępnione przez producenta.

W programie zdefiniowałem 8 przycisków pojemnościowych oraz jeden czujnik zbliżeniowy.

Wszystkie bloki dodane zostają:

Po dodaniu bloków należy zdefiniować odpowiednio każdy z nich.

Blok USART:

W bloku Capsense dodane zostało 8 przycisków oraz jeden czujnik zbliżeniowy.

Przykładowe opisane dane dla przycisków:

W głównej części, czyli w pierwszym oknie od prawej u góry zdefiniowany został rodzaj filtru oraz aktywny system ochrony dla wody znajdującej się na przyciskach. Pozwoli to na niewywoływanie przypadkowych kliknięć dla płynu znajdującego się na przycisku.

Podłączenie wszystkich linii:

Blok PWM dla diody:

Blok PWM dla buzzera:

Po przygotowaniu projektu w części graficznej należy wejść w opcje Build -> Generate Aplication. Co spowoduje przygotowanie projektu, dołączenie bibliotek itp.

Po tym w części głównej można dodać elementy w części głównej. Dzięki temu, że wykorzystywano bibliotekę część programowa jaką należy dodać jest bardzo krótka.

1. /* ========================================
2.  *
3.  * Copyright YOUR COMPANY, THE YEAR
4.  * All Rights Reserved
5.  * UNPUBLISHED, LICENSED SOFTWARE.
6.  *
7.  * CONFIDENTIAL AND PROPRIETARY INFORMATION
8.  * WHICH IS THE PROPERTY OF your company.
9.  *
10.  * ========================================
11. */
12. #include "project.h"
13. #include "stdio.h"
14. void CapSense_DisplayState(void);
16. int main(void)
17. {
18.     char buffer[10];
19.     uint16_t value = 0;
21.     CyGlobalIntEnable; /* Enable global interrupts. */
22.    
23.     LCD_Char_1_Start();
24.     LCD_Char_1_Position(0u, 0u);
25.    
26.     LCD_Char_1_ClearDisplay();
27.    
28.     UART_Start();
29.     UART_UartPutString("Hello World\n\r");
30.     UART_UartPutString("dziala dziala\n\r");
31.    
32.     CapSense_1_Start();
33.     CapSense_1_EnableWidget(CapSense_1_PROXIMITYSENSOR0__PROX);
34.     UART_UartPutString("CapSense start\n\r");
35.    
36.     CapSense_1_InitializeAllBaselines();
37.     UART_UartPutString("InitializeAllBaselines\n\r");
38.     CapSense_1_ScanEnabledWidgets();
39.    
40.     PWM_1_Start();
41.     PWM_2_Start();
42.    
43.     UART_UartPutString("PWM_1_Start\n\r");
44.    
45.     /* Place your initialization/startup code here (e.g. MyInst_Start()) */
47.     for(;;)
48.     {
49.         CapSense_1_ScanEnabledWidgets();
50.        
51.         while(CapSense_1_IsBusy() != 0) { }
52.        
53.         CapSense_DisplayState();
55.         CapSense_1_UpdateEnabledBaselines();
56.         /* Place your application code here. */
57.     }
58. }
60. void CapSense_DisplayState(void)
61. {
62.     static uint8_t previous_state;
63.    
64.     LCD_Char_1_Position(0u, 0u);
65.    
66.     if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON0__BTN))
67.     {
68.        PWM_1_WriteCompare(20);
69.        LCD_Char_1_PrintString("Button_1");
70.        UART_UartPutString("Przycisk_1\n\r");
71.    
72.        PWM_2_WriteCompare(1700);
73.        CyDelay(100);
74.        PWM_2_WriteCompare(0);
75.     }
76.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON1__BTN))
77.     {
78.        PWM_1_WriteCompare(40);
79.        LCD_Char_1_PrintString("Button_2");
80.        UART_UartPutString("Przycisk_2\n\r");
81.    
82.        PWM_2_WriteCompare(1700);
83.        CyDelay(100);
84.        PWM_2_WriteCompare(0);
85.     }
86.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON2__BTN))
87.     {
88.        PWM_1_WriteCompare(60);
89.        LCD_Char_1_PrintString("Button_3");
90.        UART_UartPutString("Przycisk_3\n\r");
91.        
92.        PWM_2_WriteCompare(1700);
93.        CyDelay(100);
94.        PWM_2_WriteCompare(0);
95.    
96.     }
97.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON3__BTN))
98.     {
99.        PWM_1_WriteCompare(80);
100.        LCD_Char_1_PrintString("Button_4");
101.        UART_UartPutString("Przycisk_4\n\r");
102.        
103.        PWM_2_WriteCompare(1700);
104.        CyDelay(100);
105.        PWM_2_WriteCompare(0);
106.     }
107.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON4__BTN))
108.     {
109.        PWM_1_WriteCompare(80);
110.        LCD_Char_1_PrintString("Button_5");
111.        UART_UartPutString("Przycisk_5\n\r");
112.        
113.        PWM_2_WriteCompare(1700);
114.        CyDelay(100);
115.        PWM_2_WriteCompare(0);
116.     }
117.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON5__BTN))
118.     {
119.        PWM_1_WriteCompare(80);
120.        LCD_Char_1_PrintString("Button_6");
121.        UART_UartPutString("Przycisk_6\n\r");
122.        
123.        PWM_2_WriteCompare(1700);
124.        CyDelay(100);
125.        PWM_2_WriteCompare(0);
126.     }
127.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON6__BTN))
128.     {
129.        PWM_1_WriteCompare(80);
130.        LCD_Char_1_PrintString("Button_7");
131.        UART_UartPutString("Przycisk_7\n\r");
132.        
133.        PWM_2_WriteCompare(1700);
134.        CyDelay(100);
135.        PWM_2_WriteCompare(0);
136.     }
137.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_BUTTON7__BTN))
138.     {
139.        PWM_1_WriteCompare(80);
140.        LCD_Char_1_PrintString("Button_8");
141.        UART_UartPutString("Przycisk_8\n\r");
142.        
143.        PWM_2_WriteCompare(1700);
144.        CyDelay(100);
145.        PWM_2_WriteCompare(0);
146.     }
147.     else if(CapSense_1_CheckIsWidgetActive(CapSense_1_PROXIMITYSENSOR0__PROX))
148.     {
149.        PWM_1_WriteCompare(80);
150.        LCD_Char_1_PrintString("Proximity");
151.        UART_UartPutString("Proximity\n\r");
152.        
153.        PWM_2_WriteCompare(1700);
154.        CyDelay(100);
155.        PWM_2_WriteCompare(0);  
156.     }
157.     else
158.     {
159.        PWM_1_WriteCompare(0);
160.        PWM_2_WriteCompare(0);
161.        LCD_Char_1_ClearDisplay();
162.     }
163. }

Program składa się z dwóch elementów na początku inicjalizowane są wszystkie bloki włącznie z wykrywaniem dotyku oraz włączeniem przerwań. W pętli głównej sprawdzany jest czy wykryto dotyk, jeśli tak to następuje wejście do funkcji CapsenseDisplayState, która w zależności od klawisza sygnalizuje dotyk poprzez zapalenie diody, wypisanie tekstu na ekranie HD44780, wypisanie danych poprzez usart oraz sygnałem dźwiękowym buzzera.

W kolejnych postach postaram się przedstawić w jaki sposób przygotować wykrywanie dotyku, bez konieczności korzystania z biblioteki, tylko samemu zaimplementować odpowiednie algorytmy.

Pliki z projektem można znaleźć na dysku Google pod tym linkiem.