[39] STM32F4 - Obsługa wyświetlacza firmy Nextion

W tym poście chciałbym opisać sposób sterowania wyświetlaczem firmy Nextion, który jest sterowany za pomocą linii UART.

[Źródło: https://nextion.tech]

Wyświetlacze można zamówić np. w sklepie elty (https://elty.pl/pl/c/Nextion-HMI/241).

Model używany prze zemnie w testach to 4.3" NX4827TO43.

Przygotowanie projektu graficznego:

Cały projekt graficzny jaki będzie wymagany dla urządzenia można wykonać w programie udostępnionym przez producenta (Nextion Editor). Interfejs programu jest dosyć intuicyjny i pozwala na weryfikację rozmieszczenia poszczególnych elementów.

Dodatkowo wgrywanie danych można wykonać poprzez podłączenie wyświetlacza przez konwerter UART->USB do komputera (przycisk Upload). Dzięki temu po wgraniu można przetestować działanie wyświetlacza bez konieczności podłączania go pod docelowe urządzenie sterujące.

Jednym minusem wyświetlacza, a dokładniej modelu testowanego przeze mnie jest brak obsługi grafik transparentnych (nie wiem jak to wygląda w przypadku droższych modeli). Po wgraniu ich na wyświetlacz wyświetlają się jako jednokolorowy prostokąt. Natomiast widok grafik wgranych do programu Nextion Editor jest poprawny.

Terminal testy:

Wyświetlacz wykorzystuje komunikację przez UART. Co oznacza, że wstępną weryfikację przygotowanego projektu, bądź jego zbudowanie tylko przez przesłane komendy można dokonać w programach typu terminal.

Aby przesłać ramkę w formacie akceptowalnym przez Nextion należy wprowadzać komendę w następujący sposób:

1. <komenda>$FF$FF$FF
2. np. page 4$FF$FF$FF

Aby wyświetlić tekst na ekranie w stworzonej kontrolce należy umieścić napis w cudzysłowie:

1. main.t0.txt="test"
2. main.t1.txt="sprawdzenie"

Lub z pominięciem nazwy okna:

1. t0.txt="test"
2. t1.txt="sprawdzenie"

W każdym przypadku przesłana ramka przez UART musi zawierać zakończenie w postaci trzech bajtów o wartości 0xFF.

Biblioteka:

Pełny wykaz instrukcji do obsługi wyświetlacza można znaleźć na stronie producenta (https://nextion.tech/instruction-set/#s3).

Poniżej opis niektórych z zaimplementowanych funkcji.

Bibliotekę można pobrać z dysku Google pod tym linkiem.

Assignment  Statements:

Zmiana wartości pola tekstowego w podanej kontrolce:

1. void Nextion_WriteTxtToControlOnSpecWindow(const uint8_t *windowName,
2.         const uint8_t *controlName,
3.         const uint8_t *valueToWrite)
4. {
5.     uint8_t dataToWrite[100] = {0x00};
6.     uint8_t size = sprintf((char *)dataToWrite, "%s.%s.txt=\"%s\"", windowName, controlName, valueToWrite);
8.     Nextion_SendCommand(dataToWrite, size + 1);
9. }
11. void Nextion_WriteTxtToControl(const uint8_t *controlName, const uint8_t *valueToWrite)
12. {
13.     uint8_t dataToWrite[100] = {0x00};
14.     uint8_t size = sprintf((char *)dataToWrite, "%s.txt=\"%s\"", controlName, valueToWrite);
16.     Nextion_SendCommand(dataToWrite, size + 1);
17. }

Dodanie tekstu do pola txt wybranej kontrolki

1. void Nextion_AddTxtToControlOnSpecWindow(const uint8_t *windowName, const uint8_t *controlName, const uint8_t *valueToWrite) {
2.     uint8_t dataToWrite[100] = {0x00};
3.     uint8_t size = sprintf((char *)dataToWrite, "%s.%s.txt+=\"%s\"", windowName, controlName, valueToWrite);
5.     Nextion_SendCommand(dataToWrite, size + 1);
6. }
7. void Nextion_AddTxtToControl(const uint8_t *controlName, const uint8_t *valueToWrite) {
8.     uint8_t dataToWrite[100] = {0x00};
9.     uint8_t size = sprintf((char *)dataToWrite, "%s.txt+=\"%s\"", controlName, valueToWrite);
11.     Nextion_SendCommand(dataToWrite, size + 1);
12. }

Operational Commands:

W celu załadowania stworzonej w edytorze strony należy podać jej numer, lub jej nazwę:

1. void Nextion_LoadNewPage_PageId(const uint8_t pageId)
2. {
3.     uint8_t pageCommand[6] = {0x00};
5.     pageCommand[0] = 'p';
6.     pageCommand[1] = 'a';
7.     pageCommand[2] = 'g';
8.     pageCommand[3] = 'e';
9.     pageCommand[4] = ' ';
10.     pageCommand[5] = pageId + 0x30;
12.     Nextion_SendCommand(pageCommand, sizeof(pageCommand) + 1);
13. }
15. void Nextion_LoadNewPage_PagaName(const uint8_t *pageName, const uint8_t pageNameSize)
16. {
17.     uint8_t pageCommand[30] = {0x00};
19.     pageCommand[0] = 'p';
20.     pageCommand[1] = 'a';
21.     pageCommand[2] = 'g';
22.     pageCommand[3] = 'e';
23.     pageCommand[4] = ' ';
25.     for(uint8_t i=0; i<pageNameSize; i++)
26.     {
27.         pageCommand[i + 5] = *(pageName + i);
28.     }
30.     Nextion_SendCommand(pageCommand, (6 + pageNameSize));
31. }

Reset wyświetlacza:

1. void Nextion_ResetDisplay(void)
2. {
3.     uint8_t resetCommand[] = "rest";
4.     Nextion_SendCommand(resetCommand, sizeof(resetCommand));
5. }

GUI Design Commands:

Czyszczenie ekranu zadanym kolorem. W postaci ciągu znaków np. BLUE, BROWN itp. Bądź za pomocą koloru RGB565 zapisanego w systemie dziesiętnym.

1. void Nextion_ClearScreenWithColorConstant(const uint8_t *colorName, const uint8_t colorNameLength)
2. {
3.     uint8_t clearScreenColorFrame[30] = {0x00};
5.     clearScreenColorFrame[0] = 'c';
6.     clearScreenColorFrame[1] = 'l';
7.     clearScreenColorFrame[2] = 's';
8.     clearScreenColorFrame[3] = ' ';
10.     for(uint8_t i=0; i<colorNameLength; i++)
11.     {
12.         clearScreenColorFrame[i + 4] = *(colorName + i);
13.     }
15.     Nextion_SendCommand(clearScreenColorFrame, (5 + colorNameLength));
16. }
18. void Nextion_ClearScreenWithColorRGB565(const uint16_t colorRGB565)
19. {
20.     uint8_t clearScreenColorFrame[30] = {0x00};
21.     uint8_t frameSize = sprintf((char *)clearScreenColorFrame, "cls %u", colorRGB565);
23.     Nextion_SendCommand(clearScreenColorFrame, (frameSize + 1));
24. }

Funkcja odpowiedzialna za przygotowanie końcowej ramki do wysłania:

1. static size_t Nextion_SendCommand(uint8_t *command, const uint8_t commandSize)
2. {
3.     uint8_t arrayToSend[(commandSize - 1) + 4];
5.     for(uint8_t i = 0; i<sizeof(arrayToSend); i++)
6.     {
7.         arrayToSend[i] = 0x00;
8.     }
10.     for(uint8_t loop = 0; loop < (commandSize - 1); loop++) {
11.         arrayToSend[loop] = *(command + loop);
12.     }
14.     arrayToSend[commandSize - 1] = 0xFF;
15.     arrayToSend[commandSize + 0] = 0xFF;
16.     arrayToSend[commandSize + 1] = 0xFF;
17.     arrayToSend[commandSize + 2] = 0x00;
19.     return USART_SendString(&arrayToSend[0]);
20. }

Wyświetlenie kontrolki text na ekranie:

1. void Nextion_WriteTxtOnScreen_XStr(uint16_t x, uint16_t y, uint16_t w, uint16_t h,
2.                                     uint8_t fontID, char *str, uint32_t bgColour,
3.                                     uint32_t fgColour, uint8_t bgType,
4.                                     Nextion_FontAlignment_TypeDef xCentre,
5.                                     Nextion_FontAlignment_TypeDef yCentre)
6. {
7.     uint8_t commandBuffer[200] = {0x00};
8.     uint8_t frameSize = sprintf((char *)commandBuffer, "xstr %d,%d,%d,%d,%d,%ld,%ld,%d,%d,%d,\"%s\"",
9.                x, y, w, h, fontID, fgColour, bgColour, xCentre, yCentre, bgType, str);
10.     Nextion_SendCommand(commandBuffer, (frameSize + 1));
11. }

Wyświetlenie linii na ekranie:

1. void Nextion_DeleteTxtToControlOnSpecWindow(const uint8_t *windowName, const uint8_t *controlName, const uint8_t numberOfCharsToDelete) {
2.     uint8_t dataToWrite[100] = {0x00};
3.     uint8_t size = sprintf((char *)dataToWrite, "%s.%s.txt-=%u", windowName, controlName, numberOfCharsToDelete);
5.     Nextion_SendCommand(dataToWrite, size + 1);
6. }
8. void Nextion_DeleteTxtToControl(const uint8_t *controlName, const uint8_t numberOfCharsToDelete) {
9.     uint8_t dataToWrite[100] = {0x00};
10.     uint8_t size = sprintf((char *)dataToWrite, "%s.txt-=%u", controlName, numberOfCharsToDelete);
12.     Nextion_SendCommand(dataToWrite, size + 1);
13. }

System Variables:

Ustawienie wartości podświetlenia. Komenda DIM ustawia wartość do momentu resetu wyświetlacza. Natomiast DIMS zapisuje ustawienia w wyświetlaczu na stałe:

1. void Nextion_SetBacklight_Dim(uint8_t dimPercentValue)
2. {
3.     if(dimPercentValue > 100) {
4.         dimPercentValue = 100;
5.     }
7.     uint8_t dimFrame[30] = {0x00};
8.     uint8_t frameSize = sprintf((char *)dimFrame, "dim=%u", dimPercentValue);
10.     Nextion_SendCommand(dimFrame, (frameSize + 1));
11. }
13. void Nextion_SetBacklight_Dims(uint8_t dimPercentValue)
14. {
15.     if(dimPercentValue > 100) {
16.         dimPercentValue = 100;
17.     }
19.     uint8_t dimFrame[30] = {0x00};
20.     uint8_t frameSize = sprintf((char *)dimFrame, "dims=%u", dimPercentValue);
22.     Nextion_SendCommand(dimFrame, (frameSize + 1));
23. }

Ustawienie wartości baudrate dla komunikacji z wyświetlaczem:

1. void Nextion_SetUartBaudrate_Baud(Nextion_Baudrate_TypeDef baudrateValue)
2. {
3.     uint8_t dimFrame[30] = {0x00};
4.     uint8_t frameSize = sprintf((char *)dimFrame, "baud=%u", baudrateValue);
6.     Nextion_SendCommand(dimFrame, (frameSize + 1));
7. }
9. void Nextion_SetUartBaudrate_Bauds(Nextion_Baudrate_TypeDef baudrateValue)
10. {
11.     uint8_t dimFrame[30] = {0x00};
12.     uint8_t frameSize = sprintf((char *)dimFrame, "bauds=%u", baudrateValue);
14.     Nextion_SendCommand(dimFrame, (frameSize + 1));
15. }

Poniżej pełny wykaz funkcji jaki został zaimplementowany w bibliotece:

Assign Statement:

1. //Assign Statement//
2. //Write txt to specific control, clears previously write txt in control
3. void Nextion_WriteTxtToControlOnSpecWindow(const uint8_t *windowName, const uint8_t *controlName, const uint8_t *valueToWrite);
4. void Nextion_WriteTxtToControl(const uint8_t *controlName, const uint8_t *valueToWrite);
5. //Add txt to existing txt value in control
6. void Nextion_AddTxtToControlOnSpecWindow(const uint8_t *windowName, const uint8_t *controlName, const uint8_t *valueToWrite);
7. void Nextion_AddTxtToControl(const uint8_t *controlName, const uint8_t *valueToWrite);
8. //Delete selected number of chars from control
9. void Nextion_DeleteTxtToControlOnSpecWindow(const uint8_t *windowName, const uint8_t *controlName, const uint8_t numberOfCharsToDelete);
10. void Nextion_DeleteTxtToControl(const uint8_t *controlName, const uint8_t numberOfCharsToDelete);
11. //Change font size in control
12. void Nextion_ChangeFontSizeInControl(const uint8_t *windowName, const uint8_t *controlName, const uint8_t fontID);

Operational Commands:

1. //Operational Commands
2. //PAGE
3. void Nextion_LoadNewPage_PageId(const uint8_t pageId);
4. void Nextion_LoadNewPage_PagaName(const uint8_t *pageName, const uint8_t pageNameSize);
5. //REST
6. void Nextion_ResetDisplay(void);
7. //REF
8. void Nextion_RefreshDisplay_ComName(const uint8_t *componentName);
9. void Nection_RefreshDisplay_ComId(const uint8_t comId);
10. //CLICK
11. void Nextion_TriggerClick_ComName(const uint8_t *componentName, const uint8_t touchPressRelease);
12. void Nextion_TriggerClick_ComId(const uint8_t comId, const uint8_t touchPressRelease);
13. //REF_START
14. void Nextion_StopRefDefaultWaveform(void);
15. //REF_STOP
16. void Nextion_StopsRefDefaultWaveform(void);
17. //GET
18. void Nextion_SendAttribute(const uint8_t *attribute);
19. //SENDME
20. void Nextion_SendNumberOfCurrentlyLoadedPage(const uint8_t *attribute);

Gnu Design Commands:

1. //GUI Design Commands//
2. //CLS
3. void Nextion_ClearScreenWithColorConstant(const uint8_t *colorName, const uint8_t colorNameLength);
4. void Nextion_ClearScreenWithColorRGB565(const uint16_t colorRGB565);
5. //PIC
6. void Nextion_DispResoursePicture_Pic(const uint16_t xPos, const uint16_t yPos, const uint8_t picId);
7. //PICQ
8. void Nextion_CropPicture_Picq(const uint16_t xUpperLeftCorner, const uint16_t yUpperLeftCorner,
9. const uint16_t widthCropArea, const uint16_t heightCropArea, const uint8_t picId);
10. //XPIC
11. void Nextion_AdvancedCropPicture_Xpic(const uint16_t xUpperLeftCorner, const uint16_t yUpperLeftCorner,
12. const uint16_t widthCropArea, const uint16_t heightCropArea, const uint16_t xUpperLeftCornerCropArea, const uint16_t yUpperLeftCornerCropArea, const uint8_t picId);
13. //XSTR
14. void Nextion_WriteTxtOnScreen_XStr(const uint16_t xPos, const uint16_t yPos, const uint16_t contrWidth, const uint16_t contrHeight,
15. const uint8_t fontID, const uint32_t bgColour, const uint32_t fgColour, const uint8_t bgFill,
16. const Nextion_FontAlignment_TypeDef xCentre, const Nextion_FontAlignment_TypeDef yCentre, const char *str);
17. //FILL
18. void Nextion_FillAreaWithColor_Fill(const uint16_t xStart, const uint16_t yStart, const uint16_t fillWidth, const uint16_t fillHeight, const uint16_t rgb565Colour);
19. //LINE
20. void Nextion_DrawLineOnScreen_Line(const uint16_t xStart, const uint16_t yStart, const uint16_t xEnd, const uint16_t yEnd, const uint16_t rgb565Colour);
21. //DRAW
22. void Nextion_DrawHollowRectange_Draw(const uint16_t xUpperLeftCorner, const uint16_t yUpperLeftCorner, const uint16_t xLowerRightCorner, const uint16_t yLowerRightCorner, const uint16_t rgb565Colour);
23. //CIR
24. void Nextion_DrawHollowCircle_Cir(const uint16_t xCenterPoint, const uint16_t yCenterPoint, const uint16_t circleRadius, const uint16_t rgb565Colour);
25. //CIRS
26. void Nextion_DrawFilledCircle_Cirs(const uint16_t xCenterPoint, const uint16_t yCenterPoint, const uint16_t circleRadius, const uint16_t rgb565Colour);

System Variables:

1. //System Variables//
2. //DIM
3. void Nextion_SetBacklight_Dim(uint8_t dimPercentValue);
4. //DIMS
5. void Nextion_SetBacklight_Dims(uint8_t dimPercentValue);
6. //BAUD
7. void Nextion_SetUartBaudrate_Baud(Nextion_Baudrate_TypeDef baudrateValue);
8. //BAUDS
9. void Nextion_SetUartBaudrate_Bauds(Nextion_Baudrate_TypeDef baudrateValue);
10. //SPAX
11. void Nextion_SetDefaultRenderingFontForXstr_Spax(const uint8_t fontValue);
12. //SPAY
13. void Nextion_SetDefaultRenderingSpaceForXstr_Spay(const uint16_t fontValue);
14. //THC
15. void Nextion_SetTouchDrawingBrushColor_Thc(const uint16_t color);
16. //THDRA
17. void Nextion_TurnsInternalDrawindFunct_Thdra(uint8_t functionValue);
18. //USSP
19. void Nextion_SetsInterNoSerSleepTim_Ussp(uint16_t usspTimer);
20. //THSP
21. void Nextion_SetsInterNoTouchSleepTim_Thsp(uint16_t thspTimerVal);
22. //THUP
23. void Nextion_AutoWakeOnTouch_Thup(uint16_t thupVal);
24. //SENDXY
25. void Nextion_RealTimeTouchCords_SendXy(uint16_t sendXySendingStatus);
26. //DELAY
27. void Nextion_DelayFuncMs_Delay(const uint16_t delayTime);
28. //SLEEP
29. void Nextion_EnterExitSleepMode_Sleep(uint8_t sleepModeVal);
30. //BKCMD
31. void Nextion_SetLevelReturnData_Bkcmd(uint8_t retDataLevel);
32. //WUP
33. void Nextion_WakeOnSerialData_Wup(const uint8_t wupValue);
34. //USUP
35. void Nextion_WakeOnSerialData_Usup(uint8_t usupValue);

Funkcja sprawdzająca otrzymane kody od wyświetlacza i wprowadzająca je do struktury:

2. typedef struct Nextion_ReceiveFrame{
3.     uint8_t commandCode;
4.     uint8_t receiveData[10];
5. }Nextion_ReceiveFrame_TypedefStruct;
7. //Return Codes dependent on bkcmd value being greater than 0
8. #define NEXTION_INVALID_INSTRUCTION_CODE        0x00    //0x00 0xFF 0xFF 0xFF
9. #define NEXTION_INSTRUCTION_SUCCESSFUL_CODE     0x01    //0x01 0xFF 0xFF 0xFF
10. #define NEXTION_INVALID_COMPONENT_ID_CODE       0x02    //0x02 0xFF 0xFF 0xFF
11. #define NEXTION_INVALID_PAGE_ID_CODE            0x03    //0x03 0xFF 0xFF 0xFF
12. #define NEXTION_INVALID_PICTURE_ID_CODE         0x04    //0x04 0xFF 0xFF 0xFF
13. #define NEXTION_INVALID_FONT_ID                 0x05    //0x05 0xFF 0xFF 0xFF
14. #define NEXTION_INVALID_FILE_OPERAT_CODE        0x06    //0x06 0xFF 0xFF 0xFF
15. #define NEXTION_INVALID_CRC_CODE                0x09    //0x09 0xFF 0xFF 0xFF
16. #define NEXTION_INVALID_BAUDRATE_CODE           0x11    //0x11 0xFF 0xFF 0xFF
17. #define NEXTION_INVALID_WAVEFORM_ID_CHANNEL_CODE    0x12    //0x12 0xFF 0xFF 0xFF
18. #define NEXTION_INVALID_VAR_NAME_ATRRIBUTE_CODE     0x1A    //0x1A 0xFF 0xFF 0xFF
19. #define NEXTION_INVALID_VAR_OPERATION_CODE      0x1B    //0x1B 0xFF 0xFF 0xFF
20. #define NEXTION_FAILED_ASSIGNMENT_CODE          0x1C    //0x1C 0xFF 0xFF 0xFF
21. #define NEXTION_FAILED_EEPROM_OPER_CODE         0x1D    //0x1D 0xFF 0xFF 0xFF
22. #define NEXTION_INVALID_QUANT_OF_PARAM_CODE     0x1E    //0x1E 0xFF 0xFF 0xFF
23. #define NEXTION_FAILED_IO_OPERAT_CODE           0x1F    //0x1F 0xFF 0xFF 0xFF
24. #define NEXTION_INVALID_ESCAPE_CHAR_CODE        0x20    //0x20 0xFF 0xFF 0xFF
25. #define NEXTION_TOO_LONG_VAR_NAME_CODE          0x23    //0x23 0xFF 0xFF 0xFF
27. //Return Codes not affected by bkcmd value, valid in all cases
28. #define NEXTION_STARTUP_CODE                0x00    //0x00 0x00 0x00 0xFF 0xFF 0xFF
29. #define NEXTION_SERIAL_BUFFER_OVERFLOW      0x24    //0x24 0xFF 0xFF 0xFF
30. #define NEXTION_RETURN_CODE_TOUCH_EVENT     0x65    //0x65 0x00 0x01 0x01 0xFF 0xFF 0xFF
31. #define NEXTION_CURRENT_PAGE_NUMBER         0x66    //0x66 0x01 0xFF 0xFF 0xFF
32. #define NEXTION_TOUCH_COORDINATE_AWAKE      0x67    //0x67 0x00 0x7A 0x00 0x1E 0x01 0xFF 0xFF 0xFF
33. #define NEXTION_TOUCH_COORDINATE_SLEEP      0x68    //0x68 0x00 0x7A 0x00 0x1E 0x01 0xFF 0xFF 0xFF
34. #define NEXTION_STRING_DATA_ENCLOSED        0x70    //0x70 0x61 0x62 0x31 0x32 0x33 0xFF 0xFF 0xFF
35. #define NEXTION_NUMERIC_DATA_ENCLOSED       0x71    //0x71 0x01 0x02 0x03 0x04 0xFF 0xFF 0xFF
36. #define NEXTION_AUTO_ENTERED_SLEEP_MODE     0x86    //0x86 0xFF 0xFF 0xFF
37. #define NEXTION_AUTO_WAKE_FROM_SLEEP        0x87    //0x87 0xFF 0xFF 0xFF
38. #define NEXTION_READY                       0x88    //0x88 0xFF 0xFF 0xFF
39. #define NEXTION_START_MICRO_SD_UPGRADE      0x89    //0x89 0xFF 0xFF 0xFF
40. #define NEXTION_TRANSPARENT_DATA_FINISHED   0xFD    //0xFD 0xFF 0xFF 0xFF
41. #define NEXTION_TRANSPARENT_DATA_READY      0xFE    //0xFE 0xFF 0xFF 0xFF
43. Nextion_ReceiveFrame_TypedefStruct Nextion_DecodeReceiveMsg(uint8_t *recFrame, uint8_t recFrameFlag, uint8_t recMsgLength)
44. {
45.     Nextion_ReceiveFrame_TypedefStruct Nextion_ReceiveFrame;
46.     Nextion_ReceiveFrame.commandCode = 0x00;
47.     for(uint8_t i=0; i<sizeof(Nextion_ReceiveFrame.receiveData); i++)
48.     {
49.         Nextion_ReceiveFrame.receiveData[i] = 0x00;
50.     }
52.     if(recFrameFlag == 0)
53.     {
54.         Nextion_ReceiveFrame.commandCode = 0x31;
55.         return Nextion_ReceiveFrame; //No Frame Received
56.     }
58.     if(recMsgLength < 4 || recMsgLength > 9)
59.     {
60.         Nextion_ReceiveFrame.commandCode = 0x32;
61.         return Nextion_ReceiveFrame; //Receive too few or too many bytes
62.     }
64.     Nextion_ReceiveFrame.commandCode = *(recFrame + 0);
66.     if(recMsgLength == 4)
67.     {
68.         return Nextion_ReceiveFrame;
69.     }
70.    
71.     for(uint8_t i=0; i<(recMsgLength - 4); i++)
72.     {
73.         Nextion_ReceiveFrame.receiveData[i] = *(recFrame + i + 1);
74.     }
75.    
76.     return Nextion_ReceiveFrame;
77. }

Szkielet funkcji odpowiedzialnej za wykonanie akcji w zależności od otrzymanej komendy:

1. void Nextion_MakeActionForReceiveMsg(Nextion_ReceiveFrame_TypedefStruct *ReceiveMsgStructPtr)
2. {
3.     switch(ReceiveMsgStructPtr->commandCode)
4.     {
5.         case NEXTION_INVALID_INSTRUCTION_CODE:
6.             if(msgLength == 6)
7.             {
8.                 //NEXTION_START_UP_CODE
9.             }
10.             else
11.             {
12.                 //NEXTION_INVALID_INSTRUCTION_CODE
13.             }
14.             break;
15.         case NEXTION_INSTRUCTION_SUCCESSFUL_CODE:
16.             /* */
17.             break;
18.         case NEXTION_INVALID_COMPONENT_ID_CODE:
19.             /* */
20.             break;
21.         case NEXTION_INVALID_PAGE_ID_CODE:
22.             /* */
23.             break;
24.         //...
25.         //...
26.         //...
27.         default:
28.         break;
29.     }
30. }

Jedyną sytuacją jaką należy sprawdzić jest 0x00 czyli Start Up lub Invalid Instruction. Ponieważ mają one zdefiniowane te same kody komendy. Różnica polega w wielkości przesłanej ramki danych.

Bibliotekę można w bardzo łatwy sposób przenieść na inne mikrokontrolery. Wystarczy zmodyfikować funkcję przesyłające dane. Tak aby odpowiadały one wybranemu układowi.

Np. dla LPC1769 funkcję wysyłające informację wyglądają następująco:

1. static void USART_SendChar(const uint8_t c)
2. {
3.     while( !(LPC_UART0->LSR & UART_LSR_THRE) );
5.     LPC_UART0->THR = c;
6. }
8. static size_t USART_SendString(const uint8_t * str) {
9.     uint16_t charCount = 0;
11.     while(*str) {
12.         USART_SendChar(*str++);
13.         charCount++;
14.     }
15.     return charCount;
16. }

Odbieranie danych od wyświetlacza w przerwaniu od RX:

1. void UART0_IRQHandler(void) {
2.     uint32_t iirSource = 0;
4.     iirSource = LPC_UART0->IIR;
5.     iirSource &= UART_IIR_INTID_MASK;
7.     if(iirSource == UART_IIR_INTID_RDA) {
8.         memset(rxbuf, 0, sizeof rxbuf);
9.         if(UART_RcvData(rxbuf, sizeof rxbuf))
10.         {
11.             uartDataReceived = true;
12.             NVIC_DisableIRQ(UART0_IRQn);
13.         }
14.     }
15. }

Strony:

[1] Strona producenta: https://nextion.tech/
[2] Wykaz rozkazów: https://nextion.tech/instruction-set/#s3