Wireless MCU中的主题 Re: KW41Z controlled from another MCU Host Device

KW41Z controlled from another MCU Host Device

steffenjahnkepa — Fri, 17 Nov 2017 07:14:38 GMT

maybe you or someone else could help me with my little project. I want to control the KW41Z Chip, which is on the FRDM-KW41Z board, from a host system via the UART0 on the PinHeaders.

After some research i found some documentation in the SDK doc-folder, like the Kinetis FSCI Host Application Programming Interface.pdf or the Kinetis Thread Host Control Interface Reference Manual.pdf. But all these examples using host sytems, which are operating systems like Linux, Windows or OpenWRT. What i want to do is to control the KW41Z from another MCU like an STM32 via the UART lines. There could also running a FreeRTOS on the STM32.

Is this not possible right now? Are there plans to do this in the future? Or did i research badly?

Thanks a lot!

Best regards,

Steffen

Re: KW41Z controlled from another MCU Host Device

ovidiu_usturoi — Tue, 21 Nov 2017 07:21:19 GMT

Hi Steffen,

I'm not aware for an existing example of using a host uC to control kw41, other than linux examples, but this could be easily build it.

The fist step is to set the UART FRDM header pins:

- in function BOARD_InitLPUART you should enable the following:

     PORT_SetPinMux(PORTC, PIN17_IDX, kPORT_MuxAlt4);            /* PORTC17 is configured as UART0_RX */
     PORT_SetPinMux(PORTC, PIN18_IDX, kPORT_MuxAlt4);            /* PORTC18 is configured as UART0_TX */
   SIM->SOPT5 = ((SIM->SOPT5 &
             (~(SIM_SOPT5_LPUART0RXSRC_MASK)))                        /* Mask bits to zero which are setting */
              | SIM_SOPT5_LPUART0RXSRC(SOPT5_LPUART0RXSRC_LPUART_RX) /* LPUART0 Receive Data Source                Select: LPUART_RX pin */
        );

- this is used to forward the UART messages from USB to FRDM - UART header (J1 header - pins 6 - UART0_TX, 7 - UART0_RX). Please consider that based on the board Revision, you will need to solder SH12 and SH11 connections.

The next step is to decide what do you want to use: Shell or THCI and implement the same on the Host uC.

For THCI you will need to consider the data transfer format, as below:

where the STX is the synchronization byte, and by default is set to 0x02. The possible values for Opcode and Message type are detailed in the following document: Kinetis Thread Host Control Interface Reference Manual.

Please consider that the delivered sdk items contains also a C implementation for the THCI protocol, that could help you on the host app implementation. This is usually located in sdk at the following location:

...\SDK_2.2_FRDM-KW41Z\tools\wireless\host_sdk\hsdk.

For shell, please consider the Kinetis Thread Stack Shell Interface User's Guide for a complete list of supported commands.

Other considerations are: default UART baud rate = 115200 with no flow control.

Let us know about your progress.

Regards,

Ovidiu

Re: KW41Z controlled from another MCU Host Device

steffenjahnkepa — Wed, 22 Nov 2017 06:47:07 GMT

Hello ovidiu-alexandruusturoi‌,

Thanks for this Information! I will try this!

Best Regards,

Steffen

Re: KW41Z controlled from another MCU Host Device

ovidiu_usturoi — Wed, 22 Nov 2017 10:58:44 GMT

Hi Steffen,

Let us know about your progress. I will be happy to assist you with any further questions.

Regards,

Ovidiu

Re: KW41Z controlled from another MCU Host Device

ovidiu_usturoi — Wed, 22 Nov 2017 11:55:38 GMT

Hi Steffen,

Consider also the following steps in building your host application using THCI:

1. Start from generic function for UART communcation :
   - serial_send_data (uint8_t *pBuffer, uint16_t bufferLen) - to send data via UART interface
   - serial_receive_data(uint8_t *pBuffer, uint16_t bufferLen) - to receive data via UART interface

2. define some internal structures:
   /* Format of packets exchanged between the external client and THCI. */
   typedef struct clientPacketHdr_tag
   {
       uint8_t startMarker;
       uint8_t opGroup;
       uint8_t opCode;
       uint8_t len[2];      /* Actual length of payload[] */
   } clientPacketHdr_t;

   typedef struct clientPacketStructured_tag
   {
       clientPacketHdr_t header;
       uint8_t payload[gTHCIMaxPayload_c];
       uint8_t checksum;
   } clientPacketStructured_t;

   /* defines the working packet type */
   typedef union clientPacket_tag
   {
       uint8_t raw[sizeof(clientPacketStructured_t)];       /* The entire packet as unformatted data. */
       clientPacketStructured_t structured;              /* The packet as header + payload. */
   } clientPacket_t;

/* define command status */

   typedef enum{
         eFsciSuccess_c                 = 0x00,
          ...
         eFsciTooBig_c                  = 0xFE,
         eFsciError_c                   = 0xFF    /* General catch all error. */
   } fsci_Status_t;

#define gTHCIMaxPayload_c 512

3. define THCI handlers:

   /* function used to check if the received packet is valid or not */
   fsci_packetStatus_t THCI_CheckPacket( clientPacket_t *pData, uint16_t bytes )
   {
       uint8_t checksum = 0;
       uint16_t len;

       if((!pData) ||
               (pData->raw[0] != gFsciStartMarker_c))
       {
           return ePacketInvalid_c;
       }

       if ( bytes < sizeof(clientPacketHdr_t) )
       {
           return ePacketToShort_c;            /* Too short to be valid. */
       }

       if ( bytes >= sizeof(clientPacket_t) )
       {
           return eFramingError_c;
       }

       /* The packet's len field does not count the STX, the opcode group, the */
       /* opcode, the len field, or the checksum. */
       len = pData->structured.header.len[0] + (pData->structured.header.len[1]<<8);

       /* If the length appears to be too long, it might be because the external */
       /* client is sending a packet that is too long, or it might be that we're */
       /* out of sync with the external client. Assume we're out of sync. */
       if ( len > sizeof(pData->structured.payload) )
       {
           return eFramingError_c;
       }

       if ( bytes < len + sizeof(clientPacketHdr_t) + sizeof(checksum) )
       {
           return ePacketToShort_c;
       }

       /* If the length looks right, make sure that the checksum is correct. */
       if( bytes == len + sizeof(clientPacketHdr_t) + sizeof(checksum) )
       {
           checksum = THCI_ComputeChecksum(pData->raw+1, len + sizeof(clientPacketHdr_t)-1);
           if( checksum == pData->structured.payload[len] )
           {
               return ePacketValid_c;
           }
       }

       return eFramingError_c;
   }


   /* function used to manage request/response commands */
   void THCI_ProcessRxPkt (clientPacket_t* pPacket)
   {
       fsci_Status_t status;

       if(!pPacket){
           return;
       }

       /* Process only FSCI confirms */
       if( pPacket->structured.header.opGroup == gFSCI_CnfOpcodeGroup_c )
       {
           /* receive a confirm for a request.
           * At this moment the requests are send from RadioUpgrade module */

           //TBD add your handler here
           switch(pPacket->structured.header.opCode)
           {
               case ...
               default:
                   break;
           }
       }
       else if(pPacket->structured.header.opGroup == gFSCI_ReqOpcodeGroup_c)
       {
           /* receive a request */

           //TBD - add your handler here
           switch(pPacket->structured.header.opCode)
           {
               case ...
               default:
                   break;
           }
       }
   }


   /* function used to send formatted packets */
   void THCI_TransmitFormatedPacket( clientPacket_t *pPacket )
   {
       uint32_t size;
       uint8_t checksum;
       uint16_t packetLen = pPacket->structured.header.len[0] + (pPacket->structured.header.len[1]<<8);

pPacket->structured.header.startMarker = gFsciStartMarker_c;
size = sizeof(clientPacketHdr_t) + packetLen + 1 /* CRC */;

       /* Compute Checksum */
       checksum = THCI_ComputeChecksum( pPacket->raw+1, size - 2);
       pPacket->structured.payload[packetLen] = checksum;

       /* send message to the serial interface */
       serial_send_data(pPacket->raw, size);
   }

   /* compute checksum */
   static uint8_t THCI_ComputeChecksum( uint8_t *pBuffer, uint16_t size )
   {
       uint16_t index;
       uint8_t checksum = 0;

       for ( index = 0; index < size; index++ )
       {
           checksum ^= pBuffer[index];
       }

       return checksum;
   }

4. Update serial receive function to handle THCI packets

   void serial_receive_data(uint8_t *pBuffer, uint16_t bufferLen)
   {
       ...

       if(THCI_CheckPacket((clientPacket_t *)buffer, bufferLen) == ePacketValid_c)
       {
           /* THCI Packet received */
           THCI_ProcessRxPkt((clientPacket_t *)rx_buf->buf);
       }

       ...
   }

Let me know if you need more details,

Ovidiu

Re: KW41Z controlled from another MCU Host Device

amwilhite — Thu, 07 Jun 2018 20:26:48 GMT

Is this also available for KW40Z? If so, where can I find the implementation?

Re: KW41Z controlled from another MCU Host Device

flaminatakam — Mon, 04 May 2020 08:47:05 GMT

hello,

please can i have more details on this host application that you proposed? ovidiu-alexandruusturoi‌

Re: KW41Z controlled from another MCU Host Device

ovidiu_usturoi — Mon, 04 May 2020 15:48:33 GMT

Hi flaminatakam@gmail.com‌,

Can you provide more details on your project?

If you look on our SDK, are two possibilities to communicate via serial line:

1. Shell;

2. THCI (Thread Host controller interface); For more details, please check the documentation folder from the SDK.

Usually, THCI is used for communicating with an external application processor. In the SDK, we have implemented the host SDK in the :. ..\sdk\SDK_2.2.1_FRDM-KW41Z\tools\wireless\host_sdk. There is a python and C language implementation for this protocol, mainly defined for the Linux environment.

What I tried to explain in https://community.nxp.com/thread/464273#comment-963478 is a simple example of how to validate a THCI packet reception and how to transmit. As required pins are only the UART_TX/UART_RX pins are required.

Regards.

Ovidiu

Re: KW41Z controlled from another MCU Host Device

flaminatakam — Wed, 06 May 2020 12:59:43 GMT

For the need of our project, we want to send all the commands for creating, joining and sending tcp messages from the stm32 acting as a host processor to the KW41Z.

KW41Z will be just like a black box flashed with kinetis thread stack.

stm32 runs freertos.

We have written a program but we are not able to communicate with FRDM-KW41 via UART in order to send our commands.

What can be the problem?

Thank you

Re: KW41Z controlled from another MCU Host Device

flaminatakam — Thu, 07 May 2020 09:14:43 GMT

if we want to use THCI, can we use the requests seen in test tool application? like THR_FactoryReset.Request or should we use THCI_FactoryResetReq?

i can't see which one will be suitable for my project between shell and thci.

please can you help me?

Re: KW41Z controlled from another MCU Host Device

ovidiu_usturoi — Thu, 07 May 2020 14:53:30 GMT

Hi flaminatakam@gmail.com‌,

As you noted, in our SDK are 2 possibilities for serial communication:

- shell

- THCI.

Shell is let say human-readable format. All the commands are listed using the help command

THCI has been designed for communication with a host processor. The format of the command is containing an opgroup, messageType, CRC... This is what I specified in this comment: https://community.nxp.com/thread/464273#comment-962988

If you want to use THCI, in the project you should enable the following:

#define THREAD_USE_SHELL 0

#define THREAD_USE_THCI 1

All of the THCI commands can be sent from TestTool (https://www.nxp.com/webapp/sps/download/license.jsp?colCode=TESTTOOL_SETUP&appType=file1&location=null&DOWNLOAD_ID=null).

In this case, the TestTool is used to simulate an application processor.

For example, the THCI Factory Reset Command:

As you can see, the format of the command is: 0x02, 0xCE, 0x1F, 0x00, 0x00, 0xD1

where you should map this command to:

STX = 0x02

Opcode Group = 0xCE - used to identify a Thread IP Stack command

Message Type = 0x1F - used to identify the gTHCI_ThrFactoryReset_c command

Lenght = 0x0000;

No Payload

CRC = 0xD1;

Considering the implementation from this comment:https://community.nxp.com/thread/464273#comment-963478

you should use something like:

uint8_t APP_SendResetToFactoryDefault(void)
{
clientPacketHdrr_t header = {

.startMarker = 0x02,

.opGroup = 0xCE,

.opCode = 0x1f,

.len = {0x00, 0x00}

};
clientPacket_t resetToFactoryDefaultCmd;

/* copy the header */
memcpy(&resetToFactoryDefaultCmd.structured.header, &header, sizeof(header));

/* copy the payload if required */

//memcpy(&resetToFactoryDefaultCmd.structured.payload, &payload, payloadLen);

/* call the function to send data via the serial - this function will add the CRC and use the right format for the command*/

THCI_TransmitFormatedPacket(&resetToFactoryDefaultCmd);
}

Let me know if you need more details,

Regards,

Ovidiu