使用 coreMQTT 的 MQTT Agent 及其演示
包括 Over the Air (OTA) 更新

/**


 * The MQTT client identifier used in this example.  Each client identifier


 * must be unique so edit as required to ensure no two clients connecting to the


 * same broker use the same client identifier.


 *


 *!!! Please note a #defined constant is used for convenience of demonstration


 *!!! only.  Production devices can use something unique to the device that can


 *!!! be read by software, such as a production serial number, instead of a


 *!!! hard coded constant.


 *


 * Below is an example only.


 */

#define democonfigCLIENT_IDENTIFIER    "Thing1"



/**


 * MQTT broker endpoint to connect to.


 *


 * This demo application can be run with any MQTT broker, although it is


 * recommended to use one that supports mutual authentication. If mutual


 * authentication is not used, then #democonfigUSE_TLS should be set to 0.


 *


 * Not for AWS users: Your AWS IoT Core endpoint can be found in the AWS IoT


 * console under Settings/Custom Endpoint, or using the describe-endpoint REST


 * API (with AWS CLI command line tool).


 *


 * #define democonfigMQTT_BROKER_ENDPOINT   "insert here."


 *


 * Examples include:


 * #define democonfigMQTT_BROKER_ENDPOINT   "test.mosquitto.org"


 * #define democonfigMQTT_BROKER_ENDPOINT   "x-ats.iot.us-west-2.amazonaws.com"


 */

#define democonfigMQTT_BROKER_ENDPOINT   "192.168.0.100" /* Local broker */



/**


 * The TCP port to connect to.


 *


 * In general, port 8883 is for secured MQTT connections, and port 1883 if not


 * using TLS.


 *


 * #define democonfigMQTT_BROKER_PORT    ( insert here. )


 *


 * Below is an example only.


 */

#define democonfigMQTT_BROKER_PORT ( 8883 )



/**


 * Whether to use mutual authentication. If this macro is not set to 1 or not


 * defined, then plaintext TCP will be used instead of TLS over TCP.


 */

#define democonfigUSE_TLS                   1

/**


 * The maximum number of pending acknowledgments to track for a single


 * connection.


 *


 * The MQTT agent tracks MQTT commands (such as PUBLISH and SUBSCRIBE) that


 * are still waiting to be acknowledged.  MQTT_AGENT_MAX_OUTSTANDING_ACKS set


 * the maximum number of acknowledgments that can be outstanding at any one time.


 * If this threshold is reached, packets will still be sent, but reported as failure.


 * The higher this number is the greater the agent’s RAM consumption will be.


 * Each entry uses up to 8 bytes on a 32-bit microprocessor.


 */

#ifndef MQTT_AGENT_MAX_OUTSTANDING_ACKS

    #define MQTT_AGENT_MAX_OUTSTANDING_ACKS               ( 20 )

#endif



/**


 * Time in MS that the MQTT agent task will wait in the Blocked state (so not


 * using any CPU time) for a command to arrive in its command queue before


 * exiting the blocked state so it can call MQTT_ProcessLoop().


 *


 * It is important MQTT_ProcessLoop() is called often if there is known MQTT


 * traffic, but calling it too often can take processing time away from lower


 * priority tasks and waste CPU time and power.


 */

#ifndef MQTT_AGENT_MAX_EVENT_QUEUE_WAIT_TIME

    #define MQTT_AGENT_MAX_EVENT_QUEUE_WAIT_TIME         ( 1000 )

#endif

/* Application defined structure that will get typedef'ed to CommandContext_t. */

struct CommandContext

{

    TaskHandle_t xTaskToNotify;

    MQTTStatus_t xReturnStatus;

};



static const char * const pcTopicName = "/my/topic/x";



/* The information associated with a single MQTT agent. Each agent context


 * holds the information for a single MQTT connection. This context must be


 * initialized with a call to MQTTAgent_Init() prior to its use. */

static MQTTAgentContext_t xAgentContext;



/* Callback executed when the MQTT PUBLISH is acknowledged by the MQTT broker. */

static void prvCommandCallback( void *pxCommandContext,

                                MQTTStatus_t xReturnStatus )

{

CommandContext_t *pxApplicationDefinedContext = ( CommandContext_t * ) pxCommandContext;



    /* Store the result in the application defined context and send a notification


    to the initiating task. Since this callback executes in the thread context of


    the MQTT agent task, the notification is necessary to signal the caller. */

    pxApplicationDefinedContext->xReturnStatus = xReturnStatus;

    xTaskNotify( pxApplicationDefinedContext->xTaskToNotify,

                 xReturnStatus,

                 eSetValueWithOverwrite );

}





void ExampleOfCallingAgentPublish( char *pcPayload, uint16_t usPayloadLength )

{

    MQTTPublishInfo_t xPublishInfo;

    /* The context for the completion callback must stay in scope until


     * the completion callback is invoked. In this example, using a stack variable


     * is safe because the function waits for the callback to execute before returning. */

    CommandContext_t xCommandContext;

    MQTTStatus_t xCommandAdded;

    BaseType_t xReturn;

    CommandInfo_t xCommandInformation;



    /* Complete an MQTTPublishInfo_t structure describing the publish operation.


    MQTTPublishInfo_t is defined by coreMQTT and is the same as would be passed


    into MQTT_Publish. */

    xPublishInfo.qos = MQTTQoS1;

    xPublishInfo.pTopicName = pcTopicName;

    xPublishInfo.topicNameLength = ( uint16_t ) strlen( pcTopicName );

    xPublishInfo.pPayload = pcPayload;

    xPublishInfo.payloadLength = usPayloadLength;



    /* Complete the CommandContext_t structure that will get passed into the


    callback that executes when the publish command is ACKed by the MQTT


    broker.  The application writer defines this structure, and can put whatever


    they like in it.  This simple example stores the handle of the calling task


    and provides a variable to store the status of the operation. See the


    implementation of prvCommandCallback() above. */

    xCommandContext.xTaskToNotify = xTaskGetCurrentTaskHandle();



    /* Callback to execute the PUBLISH is acknowledged by the server. */

    xCommandInformation.cmdCompleteCallback = prvCommandCallback;

    /* The parameter to pass into the callback. In this case the parameter just


     * holds the handle of the task calling this function. */

    xCommandInformation.pCmdCompleteCallbackContext = &xCommandContext

    /* Maximum time to wait enqueue the command for the agent. */

    xCommandInformation.blockTimeMs = mqttexampleMAX_COMMAND_SEND_BLOCK_TIME_MS;



    /* Send the command to the MQTT agent. */

    xCommandAdded = MQTTAgent_Publish( /* The MQTT context to use. */

                                       &xAgentContext,

                                       /* Structure that defined the MQTT PUBLISH


                                       operation. */

                                       &xPublishInfo,

                                       /* Command Information. */

                                       &xCommandInformation );

    if( xCommandAdded == MQTTSuccess )

    {

        /* The command was successfully sent to the agent.  At this point the


        application writer can opt to wait for the callback to be executed,


        meaning the MQTT broker acknowledged the MQTT PUBLISH.  Note the data


        pointed to by xPublishInfo.pTopicName and xPublishInfo.pPayload must


        remain valid (not be lost from a stack frame or overwritten in a buffer)


        until the PUBLISH is acknowledged.  In this simple example the callback


        sends a notification to this task. */

        xReturn = xTaskNotifyWait( 0,

                                   0,

                                   NULL,

                                   portMAX_DELAY ); /* Wait indefinitely. */



        if( xReturn != pdFAIL )

        {

            /* The message was acknowledged and


            xCommandContext.xReturnStatus holds the result of the operation. */

        }

    }

}