Creating Wi-Fi and Ethernet Applications Using MPLAB® Harmony Framework

I. Introduction

This article describes the process of creating a simple Wi-Fi and Ethernet application on a PIC^®32MX microcontroller using the MPLAB^® Harmony software framework. The concept is equally applicable when you want to add Wi-Fi^® and/or Ethernet functionality to an existing PIC32 Harmony project.

What you will need

Software

Tool	‍ About	Installers			‍ Installation Instructions
Tool	‍ About	‍ Windows	‍ Linux	‍ Mac OSX	‍ Installation Instructions
‍ MPLAB^® X Integrated Development Environment Version 4.0 ( Not Current Release)	‍	‍	‍	‍	‍
‍ MPLAB^® XC32 C/C++ Compiler	‍	‍	‍	‍	‍
MPLAB Harmony Integrated Software Framework v2.04	‍	‍	‍	‍	‍
MPLAB® Harmony Configurator (MHC) Plugin v2.0.4.0	‍	‍	‍	‍	‍
Tera Term Terminal Emulator Communications Program	‍	‍	‍	‍	‍

Hardware

Tool	‍ About	‍ Purchase
PIC32MX795F512L Plug-in-Module	‍	‍
Explorer 16/32 Development Board You may use Explorer 16 as an alternative	‍	‍
WINC1500 PICTAIL^™/PICTAIL PLUS Daughter Board Part Number: AC164156	‍	‍
Fast 100 Mbps Ethernet PICtail Plus Daughter Board ENC624J600 10/100 Base-T Ethernet	‍	‍
PICtail^™ Plus Expansion Board Part Number: AC240100	‍	‍
MPLAB REAL ICE^™ You may also use ICD3 or ICD4	‍	‍

Reference Documents

Harmony Compiled HTML Help file help_harmony.chm (located at C:\microchip\harmony\v2_04\doc\
PIC32MX795F512L 100-pin to 100-pin TQFP CAN-USB Plug-in Module (PIM) Information Sheet
WINC1500 PICTAILTM/PICTAIL PLUS Daughter Board User’s Guide
Fast 100 Mbps Ethernet PICtail™ Plus Daughter Board User’s Guide
Explorer 16 Development Board User’s Guide

Alternate Development tools

If you do not have the specific tools listed above, you can study the process of configuring drivers in MHC as shown in this article and port it to other combinations of development tools. For example:

PIC32MZ EC Starter Kit or
PIC32MX Starter Kit with
- Starter Kit I/O Expansion Board and
- WINC1500 Wi-Fi PICTail Board or
PIC32MZEF Curiosity Development Board, etc.

You can also use this article in combination with online help available on Microchip Developer Help (click here) and replace the Wi-Fi function with Ethernet. The Developer Help website contains a lot of interesting Harmony tutorials including peripherals and middleware.

II. Getting Started

▶ Show Section

III. Using MPLAB® MHC plugin to import, configure modules and generate application templates

▶ Show Section

▼ Hide Section

Create New Project

Start MPLAB X IDE and create a 'new project'.

Select '32-bit MPLAB Harmony Project'.

Complete the Harmony project details as shown in the image below.

You can keep the default Project Location in the applications folder or set a desired one as shown below.

Enter an appropriate 'Configuration Name'.

If there is no target board available for your microcontroller, leave it blank. It is helpful for importing respective board support package.

Click on the Finish button to create a project which launches the MHC by default.

Configuring FreeRTOS

Under the MPLAB Harmony Configurator 'Options' tab, expand 'Third Party Libraries' and 'RTOS' trees:

Check the 'Use RTOS?' box to enable it
Set 'Select RTOS' to FreeRTOS

Select the first FreeRTOS option which is the latest version.

Expand the 'RTOS Configuration' tree:

Set 'Tick rate (Hz)' to 1000
Set 'Minimal stack size' to 512 bytes
Set 'ISR stack size' to 512 bytes
Set 'Memory management type' to Heap 2
Set 'Total heap size' to 40960 bytes

The increased stack and heap sizes are to accommodate TCP/IP and Wi-Fi driver tasks.

Note that timer and clock speed options are locked to specified values. This indicates Timer 1 is used by FreeRTOS to manage ticks. Each module (drivers and system services) in MHC will contain its own RTOS configuration settings which will be addressed in following sections.

Setting FreeRTOS Application Task(s)

Under the MHC 'Options' tab, expand the 'Application Configuration' tree:

Set the 'Number of Applications' to 1

For now you are creating only one application.

Expand the 'Application 0 Configuration' tree:

Set the 'Application Name' to something meaningful (for example: wnetcom)

This is your Wi-Fi network application.

Enable 'Generate Application Code For Selected Harmony Components'

Expand TCPIP:

Enable 'TCP Server: Transmit and Receive (same socket)'

If you want, change the TCP template parameters (port, text, etc.). Otherwise keep them as default.

If you are adding a new application to an existing project, make sure you increment the 'Number of Applications' number and select appropriate 'Application-‘n’-Configuration'.

Under 'Application 0 Configuration' expand 'RTOS Configuration':

Set 'Task Priority' to 2
Enable 'Use Task Delay?' by checking the box
Set 'Task Delay' to 1

MHC will highlight a conflict at this point. You may notice grayed out modules in MHC. Ignore them for now. You will resolve them later.

Using Board Support Package (BSP)

Expand 'BSP Configuration' tree.

Under 'Select BSP To Use For PIC32MX795F512L Device' check the 'PIC32MX795F512L PIM w\Explorer 16' box to enable it.

Setting FreeRTOS System Task

Under the MPLAB Harmony Configurator 'Options' tab, expand the 'Harmony Framework Configuration' tree.

Expand the 'RTOS Configuration' tree:

Set 'System Task Size' to 2048
Set 'System Task Priority' to 3
Enable 'Use System Task Delay?' by checking the box
Set 'System Task Delay' to 1

At this point, you have configured a FreeRTOS system task and FreeRTOS application task.

To achieve consistency with the Harmony structure without RTOS (i.e. a SYS_Tasks() super loop), MHC will provide you a choice to include further driver tasks as a part of 'system task' or to be 'standalone task'. You will set drivers and systems services as part of 'system task' whereas Wi-Fi driver has to be run as 'standalone task'.

Debug and Reset System Services

The WINC1500 Wi-Fi driver uses the Debug system service to send logs to the console output.

Under 'Harmony Framework Configuration', expand 'System Services'.

Expand 'Debug':

Enable 'Use Debug System Service?' by checking the box
Set 'Debug Print Buffer Size' to 512

Expand 'Reset' system service:

Check the 'Use Reset System Service?' to enable it if not already enabled.

MHC has interdependencies between modules. Enabling one module sometimes enables the dependent modules.

Command and Console System Service

For any embedded project, it is important to have a way of printing messages to the console for debugging purposes. For this project, you will use the Harmony Command and Console System Service to send messages to a host computer using the UART module. The Explorer 16 board features a UART communication interface (Refer to the Explorer 16 User’s Guide).

Expand the 'Command' tree:

Enable 'Use Command Processor System Service?' by checking the box
Under 'RTOS Configuration', set 'Run Library Tasks As' to Combined with System Tasks
Set 'Command Print Buffer Size' to 1024 bytes

Expand the 'Console' tree:

Enable 'Use Console System Service?' by checking the box
Set 'Select Peripheral for Console instance' to UART_CONSOLE
Under 'RTOS Configuration (Instance 0)', set 'Run Library Tasks As' to Combined with System Tasks

In the following steps, you will be configuring the corresponding UART driver to work with the console service.

Under 'Harmony Framework Configuration' expand 'Drivers'.

The 'Use USART Driver?' module should already be enabled because of the previous step.

Expand 'USART Driver Instance 0':

Under 'RTOS Configuration (Instance 0)', 'Run This Driver Instance As' to Combined with System Tasks
Set 'USART Module ID' to USART_ID_2

This is because the Explorer 16 board UART2 is connected to the UART interface.

To complete UART driver configuration you will need to assign Tx/Rx pins for UART2 module. From the schematics (Refer to Explorer 16 User's Guide), note that U2RX is pin-49 (RF4) and U2TX is pin-50 (RF5).

Go to MHC 'Pin Table' in MPLAB X IDE and click on the corresponding pin boxes:

or you can go to 'Pin Settings' tab and modify function column for respective pins:

Sometimes there may be a conflict with pin assignments. You will need to un-assign them from the pin table first.

You can right click on module name in Pin Table and isolate them for a better view as shown above.

To revert, right click on module name>show> all.

Configuring TCP/IP Module:

Expand 'TCP/IP Stack' tree:

'Use TCP/IP Stack?' should already be enabled due to the TCP template configuration in Step 3.

Expand 'Use TCP\IP Stack?' tree:

Under 'RTOS Configuration', set 'Run Library Tasks As' to Combined with System Tasks

Expand 'Network Configuration 0' tree:

Set 'Interface' to WINC1500
Enter a suitable 'Host Name' (for example: PIC32_WINC)

The TCP/IP Stack can support multiple network interfaces. For example, you can have a single Wi-Fi or simultaneous Ethernet and Wi-Fi interfaces defined here. For this article, you will only use one Wi-Fi instance.

Leave other network parameters for the TCP/IP Stack to configure since we use DHCP client to get valid IP address (if you want to use static IP, enter it here and disable DHCP client).

Under 'Network Configuration Start-up Flags', make sure that 'DNS Client Enabled on this Interface' is checked.

Enable 'Use ICMPv4 Server'
This will allow you to use the ping service.

The WINC1500 Wi-Fi driver uses Wi-Fi commands:

Enable 'Use TCP/IP Commands':
- Check 'Enable Storage for Stack Commands'
- Check 'Enable Wi-Fi Related Commands'

Configuring Timer System Service and Timer Driver

At this point, you will need to configure corresponding drivers and services for the TCP/IP Stack. The TCP/IP Stack uses Timer System Service to keep track of all the timeout events. After looking at the Timer System Service, you will notice that it uses 'Timer Driver instance 0'. This means you will need to configure both Timer System Service and Timer Driver (which will be done in this Step). Also, since the PIC32 communicates to the WINC1500 module via an SPI interface on the Explorer 16 board, you need to configure two drivers: Wi-Fi (Step 10) and SPI (Step 12).

Under System Services >Timer:

Under 'RTOS Configuration', set 'Run Library Tasks As' to Combined with System Tasks
Check the 'Interrupt Notification Enabled' box

Under 'Harmony Framework Configuration':

Expand 'Drivers'.

In Timer driver, MHC has detected a conflict. Expand it to see why.

Under 'TMR Driver Instance 0':

Set 'Timer Module ID' to TMR_ID_2
Under 'RTOS Configuration (Instance 0)', set 'Interrupt Priority' to INT_PRIORITY_LEVEL4

Remember that Timer 1 is already dedicated to FreeRTOS. This should resolve the conflict.

Configuring Wi-Fi Driver

Under 'Drivers':

Disable 'Use Internal Ethernet MAC Driver?' by unchecking the box

This is important because enabling the TCP module in Step 3 - Setting up FreeRTOS Application Task(s) enables the Ethernet driver by default. In order to use Wi-Fi, you must disable it for this project.

Under the 'Wi-Fi' driver:

Enable 'Use Wi-Fi Driver?'
Set 'Wi-Fi Device' to WINC1500
Under 'RTOS Configuration', ensure that 'Run Wi-Fi Driver RTOS Task' is set to Standalone
Ensure 'Wi-Fi Network Type' is set to Infrastructure which means you will connect the WINC1500 to an existing Wi-Fi network
Enter the 'Wi-Fi SSID' in the space provided or indicated by <Your Wi-Fi Name> in the image below
Set 'Wi-Fi Security Mode' to your security mode
Enter the 'Wi-Fi WPA-PSK' or 'WPA2-PSK Pass Phrase' in the space provided or indicated by <Your Wi-Fi Password> in the image below

Set WINC1500 Pin Port Channels and Pin Bit Positions

You can determine the Pin Port Channels and Pin Bit Positions by examining Appendix A-1. The WINC1500 to PIC32 connections are shown in the table below:

WINC1500 pin	PIC32 Pin Port	PIC32 Pin Bit
Chip Enable	F	1
Reset	F	0
Interrupt	E	8 (INT10)
SPI Clock	D	10 (SCK1)
SPI Data IN	D	0 (SDO1)
SPI Data OUT	C	4 (SDI1)
SPI Slave Select	D	9 (SS1)

Go to the Harmony 'Pin Settings' tab and change 'Function' for pin number 87 (RF0) and 88 (RF1) to GPIO_OUT. These two pins are Reset and Chip Enable. You will set the SPI pins later in Step 12.

Note that you will be using the External Interrupt for Change Notification. This means you need to configure External Interrupt Service under 'System Services' (Step 11).

Setting External Interrupt System Services

Go to System Services > Interrupts:

Enable 'Use External Interrupts?' by checking the box

External interrupts will be used by the Wi-Fi driver.

Ensure 'External Interrupt Instance 0' is enabled:

Set 'External Interrupt Module ID' to INT_EXTERNAL_INT_SOURCE_1

This will connect the WINC1500 interrupt pin to the PIC32 INT1 pin.

Enable 'Generate ISR Code?' :
- Set 'Interrupt Priority' to INT_PRIORITY_LEVEL3
- Set 'Interrupt Sub-priority' to INT_SUBPRIORITY_LEVEL1
- Set 'Polarity' to INT_EDGE_TRIGGER_FALLING

In the Pin Table:

Assign pin 18 (RE8) to the External Interrupt 1 module.

Configuring SPI Driver:

You will be using the SPI driver in interrupt mode.

You may see MHC showing SPI driver grayed out.

Enable 'Use Interrupt Mode?' by checking the box

Under 'SPI Driver Instance 0':

Set 'RTOS Configuration (Instance 0)' to Combined with System Tasks
Set 'SPI Module ID' to SPI_ID_1
Enable 'Driver Mode' by checking the 'Interrupt Mode' box (This should resolve the SPI issue.)
Set 'Clock Mode' to DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL
Set 'Dummy Byte Value' to 0x00

In the Pin Table, assign SPI1 (SPI_ID_1) pins as:

SCK1 = pin 70 (RD10)
SDI1 = pin 9 (RC4)
SDO1 = pin 72 (RD0)
SS1 = pin 69 (RD9).

Complete the MHC Configuration

Click on the Generate Code button in the MHC toolbar.

Save the configuration in next popup window.

In the Generate Project window ,select desired merging strategy and click Generate.

You will notice several source files and header files created in the project window.

main.c file has the generic state machine while loop.
wnetcom.c file is your application file where you will be writing and updating code.

All the variable and state names will be coherent with your application name defined in Step 3.

You can close MHC now. To re-open, set the project as Main Project and go to Tools> Embedded > MHC

IV. Adding code to the application template

▶ Show Section

▼ Hide Section

In this section you will write a simple LED toggle application which receives commands from the Tera Term terminal emulation program which acts as a TCP Client.

In the wnetcom.c file (under Source Files > app >), you will notice that MHC has generated a basic TCP server template for you. The three functions are:

void WNETCOM_Initialize (void)
void WNETCOM_Tasks (void)
static void TCP_Server_TXRX_Task (void)

The basic flow of the project is as follows:

Check if TCP/IP Stack is successfully initialized. Proceed after successful initialization.
Check the number of available network interfaces. (in our case, it’s only 1: Wi-Fi)
Wait till the interface receives a valid IP address from DHCP server.
After receiving a valid IP, open a TCP server socket on the specified port.
Wait for incoming connection from a TCP Client.
After receiving a TCP Client connection, send the greeting “Hello Client!”
Wait for any messages from the client and parse them. Toggle LED on Explorer 16 board if a valid message is received.
Keep checking the connection continuously.
Notify when the client disconnects.
Go back to step (5).

API functions used are:
(You can read their description in C:\microchip\harmony\v2_04\doc\help_harmony.htm file)

TCPIP_STACK_Status()
TCPIP_STACK_NumberOfNetworksGet()
TCPIP_STACK_IndexToNet()
TCPIP_STACK_NetAddress()
TCPIP_STACK_NetIsReady()
TCPIP_TCP_ServerOpen()
TCPIP_TCP_ArrayPut()
TCPIP_TCP_GetIsReady()
TCPIP_TCP_ArrayGet()

By referring to the code flow above and the API functions, analyze the application structure. Let’s start adding code to your application file. (Line numbers in the images are for reference only and may vary in your project).

In WNETCOM_Tasks() function and WNETCOM_STATE_INIT state, Change the appInitialized declaration to false.

bool appInitialized = false;

If TCPIP_STACK_Status() returns a negative value, notify user that TCP Stack Initialization has failed. You will use the console service API to send formatted strings to the serial terminal.

Make sure you put console print statements before state variable changes in code. Otherwise the logs may be confusing!

SYS_CONSOLE_PRINT("WNETCOM[%d]: TCP/IP stack initialization failed!\r\n", wnetcomData.state);

Add these lines to set appInitialized equal to true when the TCP/IP Stack becomes ready and display a message.

appInitialized = true;
SYS_CONSOLE_PRINT("WNETCOM[%d]: TCP/IP stack initialized!\r\n", wnetcomData.state);

Add another console message while exiting the WNETCOM_STATE_INIT state.

SYS_CONSOLE_PRINT("WNETCOM[%d]: Application initialized!\r\n", wnetcomData.state);

At this point, the function WNETCOM_Tasks() enters state WNETCOM_STATE_SERVICE_TASKS where it is executing TCP_Server_TXRX_Task() continuously. This function maintains its own state machine to handle the TCP server.

In the WNETCOM_STATE_INIT state, set the TXRX state machine in WNETCOM_TCPIP_WAIT_FOR_IP after TCP/IP Stack state becomes SYS_STATUS_READY. Change the TXRX function code in the WNETCOM_TCPIP_WAIT_FOR_IP state as follows:

case WNETCOM_TCPIP_WAIT_FOR_IP:
       {
           // Check if the IP address of an interface has changed
            wnetcom_nNets = TCPIP_STACK_NumberOfNetworksGet();
            for (i = 0; i < wnetcom_nNets; i++)
            {
                wnetcom_netH = TCPIP_STACK_IndexToNet(i);
                ipAddr.Val = TCPIP_STACK_NetAddress(wnetcom_netH);
                if (dwLastIP[i].Val != ipAddr.Val)
                {
                    dwLastIP[i].Val = ipAddr.Val;
                    SYS_CONSOLE_PRINT("TCP_TXRX[%d]: IP Address: ", wnetcomData.txrxTaskState);
                    SYS_CONSOLE_PRINT("%d.%d.%d.%d \r\n", ipAddr.v[0], ipAddr.v[1],
                            ipAddr.v[2], ipAddr.v[3]);
                    if (ipAddr.v[0] != 0 && ipAddr.v[0] != 169) // Wait for a Valid IP
                    {
                        wnetcomData. txrxTaskState = WNETCOM_TCPIP_OPENING_SERVER;
                    }
                }
            }            
        }
        break;

Once a valid IP Address is received, proceed to open a TCP server. Add a couple of console statements to WNETCOM_TCPIP_OPENING_SERVER state for checking (code locations as shown in image below).

  SYS_CONSOLE_PRINT("TCP_TXRX[%d]: Couldn't open server socket\r\n", wnetcomData.txrxTaskState);
  SYS_CONSOLE_PRINT("TCP_TXRX[%d]: Waiting for Client Connection on port: %d\r\n",
                    wnetcomData.txrxTaskState, wnetcomData.port);

Wait till you receive a connection. You can implement a timeout here using a Timer if you want. Send a greeting to the client and change state to wait for client response in the state WNETCOM_TCPIP_WAIT_FOR_CONNECTION.

SYS_CONSOLE_MESSAGE("WNETCOM: Received a connection\r\n");

Modify WNETCOM_TCPIP_WAIT_FOR_RESPONSE state so that if connection is closed, state will be changed to WNETCOM_TCPIP_WAIT_FOR_CONNECTION. If data is received from the client, parse it and add logic for toggling LED’s.

case WNETCOM_TCPIP_WAIT_FOR_RESPONSE:
        {
            if (!TCPIP_TCP_IsConnected(wnetcomData.socket))
            {
                SYS_CONSOLE_PRINT("TCP_TXRX[%d]: Connection closed/lost\r\n", wnetcomData.txrxTaskState);
                SYS_CONSOLE_PRINT("TCP_TXRX[%d]: Waiting for Client Connection on port: %d\r\n", 
                        wnetcomData.txrxTaskState, wnetcomData.port);
                wnetcomData.txrxTaskState = WNETCOM_TCPIP_WAIT_FOR_CONNECTION;
                break;
            }
            if (TCPIP_TCP_GetIsReady(wnetcomData.socket))
            {
                TCPIP_TCP_ArrayGet(wnetcomData.socket, wnetcomMsgFromClient, sizeof(wnetcomMsgFromClient) - 1);
                SYS_CONSOLE_PRINT("TCP_TXRX[%d]: Client sent: %s\r\n", 
                        wnetcomData.txrxTaskState, wnetcomMsgFromClient);
                if (strncmp((char*) wnetcomMsgFromClient, (const char *) "toggle D", 8) == 0)
                {
                    if (wnetcomMsgFromClient[8] == '3')
                    {
                        BSP_LEDToggle(BSP_LED_3);
                        SYS_CONSOLE_PRINT("TCP_TXRX[%d]: LED D%c is toggled\r\n", 
                                wnetcomData.txrxTaskState, wnetcomMsgFromClient[8]);
                    }
                    if (wnetcomMsgFromClient[8] == '4')
                    {
                        BSP_LEDToggle(BSP_LED_4);
                        SYS_CONSOLE_PRINT("TCP_TXRX[%d]: LED D%c is toggled\r\n", 
                                wnetcomData.txrxTaskState, wnetcomMsgFromClient[8]);
                    }
                }
            }
        }
        break;

All the necessary changes are complete. Feel free to modify the parsing code, add more states to the TXRX function to handle the closing of sockets, or implement timeout for sockets and so on.

Save changes
Click on Clean and Build Main Project icon in the MPLAB IDE toolbar
Check for errors

Do not program the device yet.

IMPORTANT: If you modify MHC and regenerate the code it will try to overwrite the application file(s) with a fresh template each time. Pay attention to the merge window generated after MHC generate action and keep the custom code as it is.

V. PC interface to interact with the PIC32 based TCP server

▶ Show Section

VI. Adding Ethernet using MHC

▶ Show Section

▼ Hide Section

Now that you have a working Wi-Fi project you can extend its functionality by adding Ethernet so that you can have simultaneous Wi-Fi and Ethernet.

You will be connecting the Fast 100 Mbps Ethernet PICtail™ Plus Daughter Board (ENC624J600) to the Explorer 16 Development Board or Explorer 16/32 Development Board with a PICtail Plus Expansion Board and communicating via the SPI2 serial interface. You will need to configure the following modules:

TCP/IP Stack
ENCx24J600 driver
SPI driver
Interrupt driver

Configuring the TCP/IP Stack:

In this step you will be configuring the TCP/IP stack to communicate with the Ethernet driver.

Expand the 'TCPIP stack' tree:

The TCP/IP Stack is already configured for one network interface: WINC1500.

Change the 'Number of Network Configurations' to 2
Under 'Network Configuration 1' tree:
- Set 'Interface' as ENCx24J600
- Enter an appropriate 'Host Name' (Example: PIC32_ENC)

Configuring the ENCx24J600 driver

In this step, you will be configuring the ENCx24J600 driver.

Under Drivers > ENCx24J600:

Enable 'Use ENCx24J600 Driver?' by checking the box

Expand 'ENCx24J600 Driver Instance 0':

Set 'SPI Driver Instance Number' to 1

This is because the SPI driver instance 0 is communicating with the WINC1500 Wi-Fi module.

Set 'ENCx24J600 SPI Slave Select Port Pin' to PORTS_BIT_POS_12

To identify pin mappings for ENCx24J600 module refer to Appendix A-2.

ENC624J600 pin	PIC32 Pin Port	PIC32 Pin Bit
Interrupt	A	15 (INT4)
SPI Clock	G	6 (SCK2)
SPI Data IN	G	8 (SDO2)
SPI Data OUT	G	7 (SDI2)
SPI Slave Select	F	12
Shutdown	F	13

In the Pin Settings window

Change the Direction (TRIS) and Latch (LAT) of RF12 (pin 40) and RF13 (pin 39) to Out and High.

Configuring the SPI Driver

In this step, you will be configuring the SPI driver to communicate with the ENC624J600 PICtail Plus daughter board via the SPI2 serial communications port.

Expand the 'SPI Driver' tree:

Change the 'Number of SPI Driver Instances' to 2

Under 'SPI Driver Instance 1' tree:

Under 'RTOS Configuration (Instance 1)', set 'Run This Driver Instance As' to Combined with System Tasks
Set 'SPI Module ID' to SPI_ID_2
Set 'Clock\Baud Rate - Hz' to 13333333
Set 'Clock Mode' to DRV_SPI_CLOCK_MODE_IDLE_LOW_EDGE_FALL
Set 'Input Phase' to SPI_INPUT_SAMPLING_AT_END

In the Pin Table, assign SPI2 (SPI_ID_2) pins as:

SCK2 = pin 10 (RG6)
SDI2 = pin 11 (RG7)
SDO2 = pin 12 (RG8)

You do not need to assign SS2 in the Pin Table as it was assigned in Step 2.b above.

Setting External Interrupt System Service

In this step, you will be configuring the External Interrupt to communicate with the ENC62J600 PICtail Plus daughter board.

Under System Services > Interrupts:

Change the 'Number of External Interrupt Instances' to 2

To be used by the ENC driver.

Under 'External Interrupt Instance 1':

Change 'External Interrupt Module ID' to INT_EXTERNAL_INT_SOURCE_4

Because the ENCx24J600 interrupt pin connects to INT4.

Enable 'Generate ISR Code?' by checking the box
- Set 'Interrupt Priority' to INT_PRIORITY_LEVEL3
- Set 'Interrupt Sub-priority' to INT_SUBPRIORITY_LEVEL1
- Set 'Polarity' to INT_EDGE_TRIGGER_FALLING

In the Pin Table, assign:

pin 67 (RA15) to External Interrupt 4 Module

Completing the MHC Configuration

Click on Generate Code button in MHC toolbar.

Save the configuration in next popup window.

In the Generate Project window, select desired 'merging strategy' and click Generate.

In the merge window, ignore all the differences for wnetcom.c file and click Close. This happens because MHC is comparing a fresh TCP template with your modified one.

Modifying Application code

In order to use the Command System Service to receive commands from the serial terminal, you need to add SYS_CMD_READY_TO_READ() function to the application loop.The function is necessary for the Command System Service and Console System Service to function correctly. You will call it in WNETCOM_Tasks() function in WNETCOM_STATE_SERVICE_TASKS state.