5.4.7 BLE and Parallel 8080 Interface Transparent UART

Recommended Readings

1. Getting Started with Application Building Blocks – See Building Block Examples from Related Links.

2. Getting Started with Peripheral Building Blocks – See Peripheral Devices from Related Links.

3. See BLE Connection from Related Links.

4. See BLE Transparent UART from Related Links.
5. See BLE and LCC Transparent UART from Related Links.

6. BLE Software Specification – See MPLAB® Harmony Wireless BLE in Reference Documentation from Related Links.

Hardware Requirement

SDK Setup

Refer to Getting Started with Software Development from Related Links.

Software Requirement

To install Tera Term tool, refer to the Tera Term web page in Reference Documentation from Related Links.

Smart phone App

Programming the Precompiled Hex File or Application Example

Using MPLAB® X IPE:

1. Import and program the precompiled hex file: <Discover Path>\wireless_apps_pic32_bz6\apps\ble\peripheral_applications\parallel8080_peripheral_trp_uart\precompiled_hex\parallel8080_peripheral_trp_uart.X.production.signed.hex.
2. For detailed steps, refer to Programming a Device in MPLAB® IPE in Reference Documentation from Related Links.
   Note: Ensure to choose the correct Device and Tool information.

Using MPLAB® X IDE:

1. Perform the following the steps mentioned in Running a Precompiled Example. For more information, refer to Running a Precompiled Application Example from Related Links.

2. Open and program the application example parallel8080_peripheral _trp_uart.X located in: <Discover Path>\wireless_apps_pic32_bz6\apps\ble\peripheral_applications\parallel8080_peripheral _trp_uart \firmware.
3. For more details on how to find the Discover path, refer to Download Application Example from Discover in Running a Precompiled Application Example from Related Links.

Demo Description

The following diagram shows the basic flow of the demonstration.

To highlight the graphics controlling capabilities, this demo features a coffee maker interface that allows users to select and brew one of five different drinks.

From the Main screen, users can select one of five drinks. The selected drink is the image between the green arrows. A Bluetooth icon in the upper right corner indicates the BLE connection status: gray when disconnected, and blue when a connection is active.

The system acts as a peripheral device that can advertise to nearby devices. Advertising can be enabled or disabled within the Settings screen shown below.

Testing

Hardware setup:

Ensure the cable is connected to a correct position of the LCD module as shown in the above picture.

This demo utilizes one smartphone device with MBD installed (See BLE Transparent UART from Related Links). This device will act as a central that will scan and connect to our peripheral PIC32-BZ6 Curiosity Board.

Board1 = PIC32-BZ6 Curiosity Board with parallel8080_peripheral _trp_uart application programmed

Phone1 = Smartphone with MBD installed

iOS MBD Setup

Phone1: To begin scanning on the MBD app, follow the sequence of events below:

Select BLE UART:

Select PIC32CXBZ:

Select Start:

Board 1: Open TeraTerm @ (Speed: 115200, Data: 8-bit, Parity: none, stop bits: 1 bit, Flow control: none). Reset the board.

Upon reset, an initial Startup screen will be displayed before the Main screen.

After a 3 second pause, the Main screen will be displayed with Espresso selected by default.

Navigate to the Settings screen by selecting the gear icon in the lower right corner of the screen and ensure that advertising is enabled.

Initiate scanning on MBD and select “Coffee Maker”

After connecting, the following screen will be displayed on MBD

Once connected, the BT Status will change to “Connected” on the Settings screen and the Enable Advertising button will be unchecked and disabled while the connection is active.

Navigate back to the Main screen and observe that the BLE icon in the upper right has turned from gray to blue.

On MBD, select “Text mode” and confirm that “Display Data” is turned on in the MBD settings.

In MBD, send the command “select latte”

The GUI will automatically update the selected drink on the Main screen and will send a response to MBD.

In MBD, send the “start” command to initiate brewing.

The GUI will automatically initiate the brewing and display the Brewing screen. Additionally, the GUI will send a response to MBD notifying that the “start” command was received.

Brewing updates will be sent to MBD that notify the seconds remaining in increments of 30 seconds.

When brewing completes, the Ready screen will display with the selected coffee image displayed in the center. The GUI will also send a notification to MBD saying that the brewing has completed.

Navigate back to the Main screen and use the scrollbar on the left to select another drink. Initiate brewing again by selecting the Start button. When brewing is initiated within the GUI, a notification will be sent to MBD:

While the timer is still going, select the Settings button in the lower right corner of the Brewing screen.

This will simulate a low water alert and the Low Water screen will display:

The icon in the center will flash and a notification will be sent to MBD:

Refill by pressing the flashing icon. This will display the Refill screen:

To complete the filling process, press the settings icon in the lower right corner of the Refill screen. This will display the Resume screen:

Select the Resume button and the timer will resume where it left off.

“Refill” is mandatory before starting another brew, otherwise further brew attempts will not start and will display the Low Water screen.

Selecting the settings icon on any other screen besides the brewing screen and refill screen will display the Settings screen. In the case of brewing and refill, these buttons are used for testing simulation.

Navigate to the Settings screen and select the disconnect button. The BT Status will change back to “Idle” and the Enable Advertising checkbox will be reenabled.

MBD will show that the device has been disconnected.

Developing this Application from Scratch using MCC

1. Create a new harmony project. For more details, see Creating a New MCC Harmony Project from Related Links.

2. Accept dependencies or satisfiers when prompted.
3. Verify if the project graph window has all the expected configuration.

   

Verifying Advertisement, Connection and Transparent UART Profile Configuration

1. Select the BLE Stack component in the Project Graph.

   
2. Select Transparent Profile component in the Project Graph.
   

Verify the FreeRTOS Configuration

Select the FreeRTOS component and verify the configuration.

Verify TC4 Configuration

Select the TC4 component in the Project Graph.

Verify Core Configuration

Select the Core component in the Project Graph.

Verify EVSYS Configuration

Select the EVSYS component in the Project Graph.

Verify CCL Configuration

Select the CCL component in the Project Graph.

Verifying SERCOM0 Configuration

1. Select SERCOM0 component in the Project Graph.

   

Verifying maxTouch Configuration

1. Select maxTouch Controller component in the Project Graph.

   

2. Select the I2C component in the Project Graph.

   

3. Select the SERCOM1 component in the Project Graph.

   

Verify Graphics Configuration

Verifying the Pin Configuration

1. Select Pin Configuration under Plugins in the Project Graph:

   
2. Verify the Pin Settings:
   

Verify the GUI

GUI Design Decisions

The setup that we are using in this demo is the parallel version of #1 in the image above. The design in the BLE and LCC Transparent UART project used an LCC display that was #3 in the above diagram. For more details, refer to the BLE and LCC Transparent UART from Related Links. The main difference is that the display used now has an external controller driven by the parallel 8080-interface. The frame buffer is stored externally. In the LCC project, the frame buffer was stored locally and there was not an external controller. For information on the external controller, see the datasheet. In addition, see the Microchip Graphics Suite (MGS) External Controller Driver User Guide and Hardware Guide for SAME54 Curiosity Ultra with maXTouch® Curiosity Pro Touchscreen Display for information regarding the external controller. This documentation uses the SAME5x devices, but the information can be generalized to this project.

For high resolution displays, one of the main contributors of RAM usage will be the frame buffer which is offloaded to the external display controller.

For this design, the scratch buffer contributes heavily to RAM usage. It is used for drawing segments of the screen on page refreshes. This can be increased or decreased but will impact refreshing performance. For detailed information on the scratch buffer, see Adjusting Scratch Buffer Size in Reference Documentation from Related Links.

Lastly, the fixed heaps also contribute to the RAM usage but are dictated by the number of widgets used. For further information about fixed heaps, see Optimizing the Memory Manager Settings in Reference Documentation from Related Links.

Frame Buffer:

Since we are using Hardware setup 1 for this application, our frame buffer will be allocated outside the PIC32-BZ6 Curiosity Board. In addition, we are using RGB565, so we require two bytes for each pixel. For our 320x480 display, the frame buffer will require 320*480*2byte = 307,200 bytes located on the external controller.

Scratch Buffer:

The tradeoff with better color is that the scratch buffer needs to be equally as large as the frame buffer when the entire screen needs to update. To minimize our memory consumption, we set the scratch Buffer to half of the frame buffer.

Navigating within MGS Harmony Composer for the Coffee Maker GUI

• To launch the composer, click “Microchip Graphics Composer” in the Project Graph Plugins.
  
• The individual screens can be selected at the top of the MGC page:
  
• Adding Widgets: Refer to Widgets Guide in Reference Documentation from Related Links.

New widgets can be dragged and dropped into the MGC screen. Widgets:

Events can be enabled or disabled in MGC in the Event Manager under Project:

Events can also be enabled or disabled in the Object Editor when a widget is selected.

• Event handlers for widgets and screen events are declared in the generated le_gen_screen_<screen name>.h file and must be implemented in user application code. For example, the main screen events are declared in the le_gen_screen_main.h file and the handlers are implemented in the app_Main.c file:
  
  
• Images, fonts, and strings can be added and managed in their respective pages found under Asset:
  

The available schemes in the project can also be used.

Base Scheme is used for the background color and the white text. text_lightseagreen is used for the green colored text.

Notes about Reoptimizing Fixed Heaps

Refer to Optimizing the Memory Manager Settings in Reference Documentation from Related Links.

After adding more widgets to the design, the fixed heaps can be increased and reoptimized. The GFX library provides a function called leMemoryPrintReport() that can print out the fixedHeap usage of the GUI to a terminal.

Regenerate the code, program the device not in debug mode, and run through the entire GUI to ensure there are no crashes.

Tasks and Task Priority

The above diagram shows the multiple tasks running simultaneously. Input system service, External Controller, Legato, and MaxTouch Controller all come from GFX while BLE and App core do not. Legato and External Controller have higher priority than MaxTouch to prioritize screen updates over touch events but lower priority than BLE to avoid throughput deterioration.

Generating a Code

For more details on code generation, refer to MPLAB Code Configurator (MCC) Code Generation from Related Links.

Files and Routines Automatically Generated by the MCC

For details about the BLE configuration that is generated, see BLE Transparent UART from Related Links.

For details about GFX code generation, see Getting Started with a New Harmony Graphics Application in Reference Documentation from Related Links.

User Application Development

Include:

• definitions.h must be included in all the files where UART will be used to print debug information.
  Note: definitions.h is not specific to UART peripheral, instead it must be included in all application source files where peripheral functionality will be exercised.
• Include the user action. For more information, refer to User Action from Related Links.

Required Changes to Generated Graphics File

• After generating the code, the following changes must be made to the “drv_gfx_disp_intf_parallel_portgroup_dma.c” file:
  • Change line 45:

    “#define GFX_DISP_INTF_PORT (PORT_GROUP_1)” ---> “#define GFX_DISP_INTF_PORT GPIO_PORT_B”

  • Change line 47:

    “#define DATABUS_PTR (&(PORT_REGS->GROUP[1].PORT_OUT))” ---> “#define DATABUS_PTR ((uint32_t)(&(GPIOB_REGS->GPIO_PORT)))”

  • Change line 71:

     “PORT_GROUP port;” ---> “GPIO_PORT port;”

Unique Files

The following list of files were either edited or added to the project.

Widgets within app_screen_main.c

The following table shows the widgets with their accompanying event handlers.

Widget	Event handler	Notes
	N/A	This indicates if a BLE connection is currently being held. Gray means disconnected, blue means connected.
	event_Main_lstWheelOptions_OnSelectionChanged(leListWheelWidget* wgt, int32_t idx)	This is the scrollbar that selects a drink to brew. The handler changes the current Item index.
	event_Main_btnStart_OnPressed(leButtonWidget* btn)	Initiates brewing by displaying the brewing screen. Sends a start notification to the connected device.
	event_LowWater_btnSettings_OnPressed(leButtonWidget* btn) event_Main_btnSettings_OnPressed(leButtonWidget* btn) event_Ready_btnSettings_OnPressed(leButtonWidget* btn) event_Resume_btnSettings_OnPressed(leButtonWidget* btn)	Displays the settings screen.
	event_Brewing_btnSettings_OnPressed(leButtonWidget* btn) event_Refill_btnSettings_OnPressed(leButtonWidget* btn)	Toggles the is water low boolean variable. Simulates a low water alert and completing the refill.
	event_Brewing_btnCancel_OnPressed(leButtonWidget* btn) event_LowWater_btnCancel_OnPressed(leButtonWidget* btn) event_Ready_btnCancel_OnPressed(leButtonWidget* btn) event_Refill_btnCancel_OnPressed(leButtonWidget* btn) event_Resume_btnCancel_OnPressed(leButtonWidget* btn) event_Settings_btnCancel_OnPressed(leButtonWidget* btn)	Displays the main screen.
	event_LowWater_btnContinue_OnPressed(leButtonWidget* btn)	Displays the refill screen.
	event_Ready_btnContinue_OnPressed(leButtonWidget* btn)	Displays the main screen. The image in the center will depend on the coffee that was selected and brewed.
	event_Resume_btnContinue_OnPressed(leButtonWidget* btn)	Displays the brewing screen.
	event_Settings_btnEnableAdv_OnPressed(leButtonWidget* btn) event_Settings_btnEnableAdv_OnReleased(leButtonWidget* btn)	Enables or disables advertising.
	N/A	Displays BT Status as “Connected” if a connection is being held or “Idle” if there is no connection being held.
	event_Settings_btnThroughputTest_OnPressed(leButtonWidget* btn) event_Settings_btnThroughputTest_OnReleased(leButtonWidget* btn)	This enables the BLE Throughput Testing mode. Enabling this mode sets a flag that will disable parsing of received commands and will restrict sending responses and notifications to the connected device.
	event_Settings_btnDisconnect_OnPressed(leButtonWidget* btn)	Disconnects the connected device and changes the BT Status to “Idle”.

Additional GUI Interaction within Screen Application Code

All interaction with the GUI should be implemented within the created screen files (In other words, app_Main.c, app_Settings.c, etc.). Therefore, various flags are set by the BLE callback functions that allow the GUI to handle the screen updates. For example, when the start or select commands are received, a ble_start or ble_select flag will be set. All screen update functions (In other words, Main_OnUpdate, Settings_OnUpdate) listen for the flags and perform the screen updates accordingly.

A timer callback is in app.c that is called every 100 ms. This timer is used for various tasks to help update the GUI.

• Screen event callbacks. These functions must handle all the GUI updates.
  • The <screen>_OnShow() function is called once when the screen is first shown.
  • <screen>_OnHide() is the function called when another screen is made visible.
  • <screen>_OnUpdate() is periodically called to update the GUI.

BLE Implementation

When a device is connected successfully, the connection handle is captured to be used with data communication with the connected device. Additionally, a connected_flg will be set so the BT Status will change to “Connected” on the Settings screen and the BLE icon will change to blue on the Main screen. This event is BLE_GAP_EVT_CONNECTED in app_ble_handler.c.

When a disconnect occurs, the connected_flg is cleared.

To handle the transmission of data for sending responses and notifications to the connected device, APP_MSG_COMMAND_RSP_CB is defined in the APP_MsgId_T enum in app.h.

In addition, a service task calls the APP_CommandRSPCBHandler() in app.c.

The APP_CommandRSPCBHandler() function uses the BLE_TRSPS_SendData() API to send the buffered response, which is a global variable set when a response or notification needs to be sent.

When data is received from the central device, BLE_TRSPS_EVT_RECEIVE_DATA in app_trsps_handler.c handles the command parsing and response sending.

app_Brewing.c, app_LowWater.c and app_Main.c send notifications for brewing updates, low water alerts, and start alerts to the central device.