Receiving messages is it interrupt or polling based?

[aardrasystems]

Hi

In the ESP32 example a message is sent to IoT Hub every 1 second and then the following code

xResult = AzureIoTHubClient_ProcessLoop( &xAzureIoTHubClient,
                                                     sampleazureiotPROCESS_LOOP_TIMEOUT_MS );
            configASSERT( xResult == eAzureIoTSuccess );

Am i correct un understanding that this is polling or is this MQTT subsctiption interupt?

Do we need to keep polling this funciton?

What we intend to do is send a message once a minute but wait for any incoming message.

[danewalton-msft]

Hi @aardrasystems sorry for the late reply here but I'll still give one.

The ProcessLoop functions intends to process incoming messages. It should be routinely called to make sure you receive any messages from the service. You may still send messages once a minute, but make sure to call the process function with higher frequency to make sure you aren't missing anything.

[aardrasystems]

Hi @danewalton

Thanks, that's fine. This is what I am doing at the moment. Please advise if this is the correct way to approach it.

This code is in sample_azure_iot_pnp.c file.

sensor_data(), create my data string. This function is called by ulCreateTelemetry. this file is in sample_azure_iot_pnp_simulated_data.c

Am i correct with my data other TelemetryData is also being sent? Like the demo temperature data?

 for( ; ; )
      {
          /* Hook for sending Telemetry */
       if ((message_tx_cycle_delay >= message_tx_cycle_delay_count) || (message_force_tx()==true))
          {

                      
              rst_message_force_tx();
              
              message_tx_cycle_delay = 0;
              if( ( ulCreateTelemetry( ucScratchBuffer, sizeof( ucScratchBuffer ), &ulScratchBufferLength ) == 0 ) &&
                  ( ulScratchBufferLength > 0 ) )
              {
                  
                  xResult = AzureIoTHubClient_SendTelemetry( &xAzureIoTHubClient,
                                                          ucScratchBuffer, ulScratchBufferLength,
                                                          NULL, eAzureIoTHubMessageQoS1, NULL );
                  configASSERT( xResult == eAzureIoTSuccess );
              }

              /* Hook for sending update to reported properties */
              ulReportedPropertiesUpdateLength = ulCreateReportedPropertiesUpdate( ucReportedPropertiesUpdate, sizeof( ucReportedPropertiesUpdate ) );

              if( ulReportedPropertiesUpdateLength > 0 )
              {
                  xResult = AzureIoTHubClient_SendPropertiesReported( &xAzureIoTHubClient, ucReportedPropertiesUpdate, ulReportedPropertiesUpdateLength, NULL );
                  configASSERT( xResult == eAzureIoTSuccess );
              }
          }
          else
          {
              message_tx_cycle_delay++;
          }
        //  LogInfo( ( "Attempt to receive publish message from IoT Hub.\r\n" ) );
          xResult = AzureIoTHubClient_ProcessLoop( &xAzureIoTHubClient,
                                                   sampleazureiotPROCESS_LOOP_TIMEOUT_MS );
          configASSERT( xResult == eAzureIoTSuccess );

          /* Leave Connection Idle for some time. */
          //LogInfo( ( "Keeping Connection Idle...\r\n\r\n" ) );
          //LogInfo(( "***")); 
          vTaskDelay( sampleazureiotDELAY_BETWEEN_PUBLISHES_TICKS );
          //LogInfo(( "@@@")); 
      }


uint32_t ulCreateTelemetry( uint8_t * pucTelemetryData,
                          uint32_t ulTelemetryDataSize,
                          uint32_t * ulTelemetryDataLength )
{


  int result = snprintf( ( char * ) pucTelemetryData, ulTelemetryDataSize,
                         sensor_data(), xDeviceCurrentTemperature );



  if( ( result >= 0 ) && ( result < ulTelemetryDataSize ) )
  {
      *ulTelemetryDataLength = result;
      result = 0;
  }
  else
  {
      result = 1;
  }

  return result;
}