IoT_Error_t aws_iot_jobs_send_update( AWS_IoT_Client *pClient, QoS qos, const char *thingName, const char *jobId, const AwsIotJobExecutionUpdateRequest *updateRequest, char *topicBuffer, uint16_t topicBufferSize, char *messageBuffer, size_t messageBufferSize) { if (thingName == NULL || topicBuffer == NULL || jobId == NULL || updateRequest == NULL) { return NULL_VALUE_ERROR; } int neededSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, JOB_UPDATE_TOPIC, JOB_REQUEST_TYPE, thingName, jobId); CHECK_GENERATE_STRING_RESULT(neededSize, topicBufferSize); uint16_t topicSize = (uint16_t) neededSize; int serializeResult = aws_iot_jobs_json_serialize_update_job_execution_request(messageBuffer, messageBufferSize, updateRequest); CHECK_GENERATE_STRING_RESULT(serializeResult, messageBufferSize); IoT_Publish_Message_Params publishParams; publishParams.qos = qos; publishParams.isRetained = 0; publishParams.isDup = 0; publishParams.id = 0; publishParams.payload = messageBuffer; publishParams.payloadLen = (size_t) serializeResult; return aws_iot_mqtt_publish(pClient, topicBuffer, topicSize, &publishParams); }
void publishMessage(char* message) { IoT_Error_t rc = FAILURE; IoT_Publish_Message_Params paramsQOS0; paramsQOS0.qos = QOS0; paramsQOS0.payload = (void *) message; paramsQOS0.isRetained = 0; while (NETWORK_ATTEMPTING_RECONNECT == rc || NETWORK_RECONNECTED == rc || SUCCESS != rc) { //Max time the yield function will wait for read messages rc = aws_iot_mqtt_yield(&mqttClient, 1000); if (NETWORK_ATTEMPTING_RECONNECT == rc) { // If the client is attempting to reconnect we will skip the rest of the loop. continue; } paramsQOS0.payloadLen = strlen(message); do { rc = aws_iot_mqtt_publish(&mqttClient, publishTopicName, strlen(publishTopicName), ¶msQOS0); } while (MQTT_REQUEST_TIMEOUT_ERROR == rc); } if (SUCCESS != rc) { IOT_ERROR("An error occurred while publishing message.\n"); } }
int AWS_IOT::publish(char *pubtopic,char *pubPayLoad) { IoT_Error_t rc; paramsQOS0.qos = QOS0; paramsQOS0.payload = (void *) pubPayLoad; paramsQOS0.isRetained = 0; paramsQOS0.payloadLen = strlen(pubPayLoad); rc = aws_iot_mqtt_publish(&client, pubtopic, strlen(pubtopic), ¶msQOS0); return rc; }
IoT_Error_t publishToShadowAction(const char *pThingName, ShadowActions_t action, const char *pJsonDocumentToBeSent) { IoT_Error_t ret_val = SUCCESS; char TemporaryTopicName[MAX_SHADOW_TOPIC_LENGTH_BYTES]; topicNameFromThingAndAction(TemporaryTopicName, pThingName, action, SHADOW_ACTION); IoT_Publish_Message_Params msgParams;// = MQTTMessageParamsDefault; msgParams.qos = QOS0; msgParams.payloadLen = strlen(pJsonDocumentToBeSent) + 1; msgParams.payload = (char *) pJsonDocumentToBeSent; ret_val = aws_iot_mqtt_publish(pMqttClient, TemporaryTopicName, (uint16_t)strlen(TemporaryTopicName), &msgParams); return ret_val; }
IoT_Error_t aws_iot_jobs_send_query( AWS_IoT_Client *pClient, QoS qos, const char *thingName, const char *jobId, const char *clientToken, char *topicBuffer, uint16_t topicBufferSize, char *messageBuffer, size_t messageBufferSize, AwsIotJobExecutionTopicType topicType) { if (thingName == NULL || topicBuffer == NULL || (clientToken != NULL && messageBuffer == NULL)) { return NULL_VALUE_ERROR; } int neededSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, topicType, JOB_REQUEST_TYPE, thingName, jobId); CHECK_GENERATE_STRING_RESULT(neededSize, topicBufferSize); uint16_t topicSize = (uint16_t) neededSize; char emptyBuffer[1]; size_t messageLength; if (clientToken == NULL) { messageLength = 0; messageBuffer = emptyBuffer; } else { int serializeResult = aws_iot_jobs_json_serialize_client_token_only_request(messageBuffer, messageBufferSize, clientToken); CHECK_GENERATE_STRING_RESULT(serializeResult, messageBufferSize); messageLength = (size_t)serializeResult; } IoT_Publish_Message_Params publishParams; publishParams.qos = qos; publishParams.isRetained = 0; publishParams.isDup = 0; publishParams.id = 0; publishParams.payload = messageBuffer; publishParams.payloadLen = messageLength; return aws_iot_mqtt_publish(pClient, topicBuffer, topicSize, &publishParams); }
IoT_Error_t aws_iot_jobs_describe( AWS_IoT_Client *pClient, QoS qos, const char *thingName, const char *jobId, const AwsIotDescribeJobExecutionRequest *describeRequest, char *topicBuffer, uint16_t topicBufferSize, char *messageBuffer, size_t messageBufferSize) { if (thingName == NULL || topicBuffer == NULL || describeRequest == NULL) { return NULL_VALUE_ERROR; } int neededSize = aws_iot_jobs_get_api_topic(topicBuffer, topicBufferSize, JOB_DESCRIBE_TOPIC, JOB_REQUEST_TYPE, thingName, jobId); CHECK_GENERATE_STRING_RESULT(neededSize, topicBufferSize); uint16_t topicSize = (uint16_t) neededSize; char emptyBuffer[1]; size_t messageLength; if (messageBuffer == NULL) { messageLength = 0; messageBuffer = emptyBuffer; } else { int serializeResult = aws_iot_jobs_json_serialize_describe_job_execution_request(messageBuffer, messageBufferSize, describeRequest); CHECK_GENERATE_STRING_RESULT(serializeResult, messageBufferSize); messageLength = (size_t) serializeResult; } IoT_Publish_Message_Params publishParams; publishParams.qos = qos; publishParams.isRetained = 0; publishParams.isDup = 0; publishParams.id = 0; publishParams.payload = messageBuffer; publishParams.payloadLen = messageLength; return aws_iot_mqtt_publish(pClient, topicBuffer, topicSize, &publishParams); }
IoT_Error_t ACMqttPublish(unsigned char msgCode, unsigned char msgId, unsigned char *pbody, unsigned short len) { char pubTopic[256] = {0}; unsigned short realLen = 0; MQTTPublishParams Params = MQTTPublishParamsDefault; MQTTMessageParams Msg = MQTTMessageParamsDefault; sprintf(pubTopic, "device/%s/%s/%s/out", domainName, subdomainName, deviceId); ACEventBuildMsg(msgCode, msgId, g_Payload, &realLen, pbody, len); Msg.qos = QOS_0; Msg.pPayload = (void *)g_Payload; Msg.PayloadLen = realLen; Params.pTopic = pubTopic; Params.MessageParams = Msg; return aws_iot_mqtt_publish(&Params); }
int main(void) { int i, j, err, sock, dev_id = -1; struct hci_dev_info dev_info; inquiry_info *info = NULL; bdaddr_t target; char addr[19] = { 0 }; char name[248] = { 0 }; uuid_t uuid = { 0 }; //Change this to your apps UUID char *uuid_str="4e5d48e0-75df-11e3-981f-0800200c9a66"; uint32_t range = 0x0000ffff; sdp_list_t *response_list = NULL, *search_list, *attrid_list; int s, loco_channel = -1, status; struct sockaddr_rc loc_addr = { 0 }; pthread_t blueThread; FILE *fp_Setting; char message_Buffer[64]; char mode[30], language[16], topic[16], topicLen[16]; size_t len = 16; (void) signal(SIGINT, SIG_DFL); changeTopic_flag = 1; ///////////////////////////MRAA///////////////////////////// //Initialize MRAA mraa_init(); //Initialize MRAA Pin 8 == IO8 == GP49 mraa_gpio_context BearButton = mraa_gpio_init(8); //Check for successful initialization or else return if (BearButton == NULL){ printf("Error initializing Push to Talk Pin, IO2\n"); return -1; } //Set pin to an input mraa_gpio_dir(BearButton, MRAA_GPIO_IN); printf("Set Pin to an input\n"); int curr_pin = mraa_gpio_get_pin(BearButton); printf("The current pin number is %d\n", curr_pin); int curr_raw = mraa_gpio_get_pin_raw(BearButton); printf("The raw pin number is %d\n", curr_raw); printf("Going to start reading the button via polling\n"); //////////////////////AWS/////////////////////////////////// aws_flag = 0; IoT_Error_t rc = NONE_ERROR; char HostAddress[255] = AWS_IOT_MQTT_HOST; char certDirectory[PATH_MAX + 1] = "/AWS/SDK/certs/"; uint32_t port = AWS_IOT_MQTT_PORT; MQTTMessageParams Msg = MQTTMessageParamsDefault; Msg.qos = QOS_0; char cPayload[100]; Msg.pPayload = (void *) cPayload; char rootCA[PATH_MAX + 1]; char clientCRT[PATH_MAX + 1]; char clientKey[PATH_MAX + 1]; char cafileName[] = AWS_IOT_ROOT_CA_FILENAME; char clientCRTName[] = AWS_IOT_CERTIFICATE_FILENAME; char clientKeyName[] = AWS_IOT_PRIVATE_KEY_FILENAME; sprintf(rootCA, "/%s/%s", certDirectory, cafileName); sprintf(clientCRT, "/%s/%s", certDirectory, clientCRTName); sprintf(clientKey, "/%s/%s", certDirectory, clientKeyName); MQTTConnectParams connectParams = MQTTConnectParamsDefault; connectParams.KeepAliveInterval_sec = 14000; connectParams.isCleansession = true; connectParams.MQTTVersion = MQTT_3_1_1; connectParams.pClientID = "TED"; connectParams.pHostURL = HostAddress; connectParams.port = port; connectParams.isWillMsgPresent = false; connectParams.pRootCALocation = rootCA; connectParams.pDeviceCertLocation = clientCRT; connectParams.pDevicePrivateKeyLocation = clientKey; connectParams.mqttCommandTimeout_ms = 2000; connectParams.tlsHandshakeTimeout_ms = 5000; connectParams.isSSLHostnameVerify = true;// ensure this is set to true for production connectParams.disconnectHandler = disconnectCallbackHandler; MQTTPublishParams CurriculumParams = MQTTPublishParamsDefault; CurriculumParams.pTopic = "Bear/Curriculum/Request"; MQTTPublishParams MetricsParams = MQTTPublishParamsDefault; MetricsParams.pTopic = "Bear/Curriculum/Metrics"; /////////////////////////////////////////////////////////////////////////////////////// dev_id = hci_get_route(NULL); if (dev_id < 0) { perror("No Bluetooth Adapter Available"); exit(1); } if (hci_devinfo(dev_id, &dev_info) < 0) { perror("Can't get device info"); exit(1); } sock = hci_open_dev( dev_id ); if (sock < 0) { perror("HCI device open failed"); free(info); exit(1); } if( !str2uuid( uuid_str, &uuid ) ) { perror("Invalid UUID"); free(info); exit(1); } do { printf("Scanning ...\n"); sdp_session_t *session; int retries; int foundit, responses; str2ba(TABLET_ADDRESS,&target); memset(name, 0, sizeof(name)); if (hci_read_remote_name(sock, &target, sizeof(name), name, 0) < 0){ strcpy(name, "[unknown]"); } printf("Found %s %s, searching for the the desired service on it now\n", addr, name); // connect to the SDP server running on the remote machine sdpconnect: session = 0; retries = 0; while(!session) { session = sdp_connect( BDADDR_ANY, &target, SDP_RETRY_IF_BUSY ); if(session) break; if(errno == EALREADY && retries < 5) { perror("Retrying"); retries++; sleep(1); continue; } break; } if ( session == NULL ) { perror("Can't open session with the device"); continue; } search_list = sdp_list_append( 0, &uuid ); attrid_list = sdp_list_append( 0, &range ); err = 0; err = sdp_service_search_attr_req( session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list); sdp_list_t *r = response_list; sdp_record_t *rec; // go through each of the service records foundit = 0; responses = 0; for (; r; r = r->next ) { responses++; rec = (sdp_record_t*) r->data; sdp_list_t *proto_list; // get a list of the protocol sequences if( sdp_get_access_protos( rec, &proto_list ) == 0 ) { sdp_list_t *p = proto_list; // go through each protocol sequence for( ; p ; p = p->next ) { sdp_list_t *pds = (sdp_list_t*)p->data; // go through each protocol list of the protocol sequence for( ; pds ; pds = pds->next ) { // check the protocol attributes sdp_data_t *d = (sdp_data_t*)pds->data; int proto = 0; for( ; d; d = d->next ) { switch( d->dtd ) { case SDP_UUID16: case SDP_UUID32: case SDP_UUID128: proto = sdp_uuid_to_proto( &d->val.uuid ); break; case SDP_UINT8: if( proto == RFCOMM_UUID ) { printf("rfcomm channel: %d\n",d->val.int8); loco_channel = d->val.int8; foundit = 1; } break; } } } sdp_list_free( (sdp_list_t*)p->data, 0 ); } sdp_list_free( proto_list, 0 ); } if (loco_channel > 0) break; } printf("No of Responses %d\n", responses); if ( loco_channel > 0 && foundit == 1 ) { printf("Found service on this device, now gonna blast it with dummy data\n"); s = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); loc_addr.rc_family = AF_BLUETOOTH; loc_addr.rc_channel = loco_channel; loc_addr.rc_bdaddr = *(&target); status = connect(s, (struct sockaddr *)&loc_addr, sizeof(loc_addr)); if( status < 0 ) { perror("uh oh"); } rc = pthread_create(&blueThread, NULL, threadListen, (void *)s); if (rc){ printf("ERROR: %d\n", rc); exit(1); } MQTTSubscribeParams subParams = MQTTSubscribeParamsDefault; //Loop through trying to subscribe to AWS incase the first attempt fails, so will keep trying until the app sends the edison proper network info. do{ INFO("Connecting..."); rc = aws_iot_mqtt_connect(&connectParams); if (NONE_ERROR != rc) { ERROR("Error(%d) connecting to %s:%d", rc, connectParams.pHostURL, connectParams.port); } subParams.mHandler = MQTTcallbackHandler; subParams.pTopic = "Bear/Curriculum/Response"; subParams.qos = QOS_0; if (NONE_ERROR == rc) { INFO("Subscribing..."); rc = aws_iot_mqtt_subscribe(&subParams); if (NONE_ERROR != rc) { ERROR("Error subscribing"); } } sleep(1); }while(NONE_ERROR != rc); aws_flag = 1; //////////////////////////Start of teaching stuff////////////////////////////////////////// do { if(changeTopic_flag){ sprintf(cPayload, "{\"BearID\":\"%s\"}",BEARID); Msg.PayloadLen = strlen(cPayload) + 1; CurriculumParams.MessageParams = Msg; rc = aws_iot_mqtt_publish(&CurriculumParams); while(rc == NONE_ERROR && changeTopic_flag){ rc = aws_iot_mqtt_yield(100); INFO("-->sleep"); sleep(1); } changeTopic_flag = 0; } fp_Setting = fopen("/Curriculum/BearSettings.txt", "r"); fgets(language, sizeof(language), fp_Setting); fgets(mode, sizeof(mode), fp_Setting); fgets(topic, sizeof(topic), fp_Setting); fgets(topicLen, sizeof(topicLen), fp_Setting); language[strlen(language)-1] = 0; mode[strlen(mode)-1] = 0; topic[strlen(topic)-1] = 0; topicLen[strlen(topicLen)-1] = 0; fclose(fp_Setting); //Wait for the tablet to tell the edison to start the lesson while(strcmp(threadMessage, "learning")){ printf("Waiting for learning, got: %s\n", threadMessage); if(!strcmp(threadMessage, "crash")){ memset(threadMessage, 0, sizeof(threadMessage)); goto CRASHED; } memset(threadMessage, 0, sizeof(threadMessage)); sleep(1); } printf("Current Mode: %s\n", mode); printf("Current Language: %s\n", language); printf("Current topic: %s\n", topic); //Call a different function depending on what teaching mode it is, also write to the tablet based on the topic info and lesson if(!strcmp(mode, "Repeat After Me")){ sprintf(message_Buffer,"%s,1,%s",language, topicLen); status = write(s,message_Buffer,sizeof(message_Buffer)); if(!strcmp(language, "English")){ status = repeat_after_me_english(s, topic, MetricsParams, BearButton); } else{ status = repeat_after_me_foreign(s, language, topic, MetricsParams, BearButton); } } else if(!strcmp(mode, "English to Foreign")){ sprintf(message_Buffer,"%s,3,%s",language, topicLen); status = write(s,message_Buffer,sizeof(message_Buffer)); status = english_to_foreign(s, language, topic, MetricsParams, BearButton); } else if(!strcmp(mode, "Foreign to English")){ sprintf(message_Buffer,"%s,2,%s",language, topicLen); status = write(s,message_Buffer,sizeof(message_Buffer)); status = foreign_to_english(s, language, topic, MetricsParams, BearButton); } changeTopic_flag = 1; printf("Changing Topic"); sleep(5); } while (status > 0); CRASHED: printf("\nBluetooth Disconnected\n"); close(s); sdp_record_free( rec ); } sdp_close(session); if (loco_channel > 0) { goto sdpconnect; //break; } sleep(1); } while (1); printf("Exiting...\n"); }
int main(int argc, char **argv) { bool infinitePublishFlag = true; char rootCA[PATH_MAX + 1]; char clientCRT[PATH_MAX + 1]; char clientKey[PATH_MAX + 1]; char CurrentWD[PATH_MAX + 1]; char cPayload[100]; int32_t i = 0; IoT_Error_t rc = FAILURE; AWS_IoT_Client client; IoT_Client_Init_Params mqttInitParams = iotClientInitParamsDefault; IoT_Client_Connect_Params connectParams = iotClientConnectParamsDefault; IoT_Publish_Message_Params paramsQOS0; IoT_Publish_Message_Params paramsQOS1; parseInputArgsForConnectParams(argc, argv); IOT_INFO("\nAWS IoT SDK Version %d.%d.%d-%s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_TAG); getcwd(CurrentWD, sizeof(CurrentWD)); snprintf(rootCA, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_ROOT_CA_FILENAME); snprintf(clientCRT, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_CERTIFICATE_FILENAME); snprintf(clientKey, PATH_MAX + 1, "%s/%s/%s", CurrentWD, certDirectory, AWS_IOT_PRIVATE_KEY_FILENAME); IOT_DEBUG("rootCA %s", rootCA); IOT_DEBUG("clientCRT %s", clientCRT); IOT_DEBUG("clientKey %s", clientKey); mqttInitParams.enableAutoReconnect = false; // We enable this later below mqttInitParams.pHostURL = HostAddress; mqttInitParams.port = port; mqttInitParams.pRootCALocation = rootCA; mqttInitParams.pDeviceCertLocation = clientCRT; mqttInitParams.pDevicePrivateKeyLocation = clientKey; mqttInitParams.mqttCommandTimeout_ms = 20000; mqttInitParams.tlsHandshakeTimeout_ms = 5000; mqttInitParams.isSSLHostnameVerify = true; mqttInitParams.disconnectHandler = disconnectCallbackHandler; mqttInitParams.disconnectHandlerData = NULL; rc = aws_iot_mqtt_init(&client, &mqttInitParams); if(SUCCESS != rc) { IOT_ERROR("aws_iot_mqtt_init returned error : %d ", rc); return rc; } connectParams.keepAliveIntervalInSec = 10; connectParams.isCleanSession = true; connectParams.MQTTVersion = MQTT_3_1_1; connectParams.pClientID = AWS_IOT_MQTT_CLIENT_ID; connectParams.clientIDLen = (uint16_t) strlen(AWS_IOT_MQTT_CLIENT_ID); connectParams.isWillMsgPresent = false; IOT_INFO("Connecting..."); rc = aws_iot_mqtt_connect(&client, &connectParams); if(SUCCESS != rc) { IOT_ERROR("Error(%d) connecting to %s:%d", rc, mqttInitParams.pHostURL, mqttInitParams.port); return rc; } /* * Enable Auto Reconnect functionality. Minimum and Maximum time of Exponential backoff are set in aws_iot_config.h * #AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL * #AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL */ rc = aws_iot_mqtt_autoreconnect_set_status(&client, true); if(SUCCESS != rc) { IOT_ERROR("Unable to set Auto Reconnect to true - %d", rc); return rc; } IOT_INFO("Subscribing..."); rc = aws_iot_mqtt_subscribe(&client, "sdkTest/sub", 11, QOS0, iot_subscribe_callback_handler, NULL); if(SUCCESS != rc) { IOT_ERROR("Error subscribing : %d ", rc); return rc; } sprintf(cPayload, "%s : %d ", "hello from SDK", i); paramsQOS0.qos = QOS0; paramsQOS0.payload = (void *) cPayload; paramsQOS0.isRetained = 0; paramsQOS1.qos = QOS1; paramsQOS1.payload = (void *) cPayload; paramsQOS1.isRetained = 0; if(publishCount != 0) { infinitePublishFlag = false; } while((NETWORK_ATTEMPTING_RECONNECT == rc || NETWORK_RECONNECTED == rc || SUCCESS == rc) && (publishCount > 0 || infinitePublishFlag)) { //Max time the yield function will wait for read messages rc = aws_iot_mqtt_yield(&client, 100); if(NETWORK_ATTEMPTING_RECONNECT == rc) { // If the client is attempting to reconnect we will skip the rest of the loop. continue; } IOT_INFO("-->sleep"); sleep(1); sprintf(cPayload, "%s : %d ", "hello from SDK QOS0", i++); paramsQOS0.payloadLen = strlen(cPayload); rc = aws_iot_mqtt_publish(&client, "sdkTest/sub", 11, ¶msQOS0); if(publishCount > 0) { publishCount--; } sprintf(cPayload, "%s : %d ", "hello from SDK QOS1", i++); paramsQOS1.payloadLen = strlen(cPayload); rc = aws_iot_mqtt_publish(&client, "sdkTest/sub", 11, ¶msQOS1); if (rc == MQTT_REQUEST_TIMEOUT_ERROR) { IOT_WARN("QOS1 publish ack not received.\n"); rc = SUCCESS; } if(publishCount > 0) { publishCount--; } } if(SUCCESS != rc) { IOT_ERROR("An error occurred in the loop.\n"); } else { IOT_INFO("Publish done\n"); } return rc; }
int main(int argc, char** argv) { wiringPiSetup () ; pinMode (0, OUTPUT) ; IoT_Error_t rc = NONE_ERROR; bool infinitePublishFlag = true; char rootCA[PATH_MAX + 1]; char clientCRT[PATH_MAX + 1]; char clientKey[PATH_MAX + 1]; char CurrentWD[PATH_MAX + 1]; char cafileName[] = AWS_IOT_ROOT_CA_FILENAME; char clientCRTName[] = AWS_IOT_CERTIFICATE_FILENAME; char clientKeyName[] = AWS_IOT_PRIVATE_KEY_FILENAME; parseInputArgsForConnectParams(argc, argv); INFO("\nAWS IoT SDK Version %d.%d.%d-%s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_TAG); getcwd(CurrentWD, sizeof(CurrentWD)); sprintf(rootCA, "%s/%s/%s", CurrentWD, certDirectory, cafileName); sprintf(clientCRT, "%s/%s/%s", CurrentWD, certDirectory, clientCRTName); sprintf(clientKey, "%s/%s/%s", CurrentWD, certDirectory, clientKeyName); DEBUG("rootCA %s", rootCA); DEBUG("clientCRT %s", clientCRT); DEBUG("clientKey %s", clientKey); MQTTConnectParams connectParams = MQTTConnectParamsDefault; connectParams.KeepAliveInterval_sec = 10; connectParams.isCleansession = true; connectParams.MQTTVersion = MQTT_3_1_1; connectParams.pClientID = "CSDK-test-device"; connectParams.pHostURL = HostAddress; connectParams.port = port; connectParams.isWillMsgPresent = false; connectParams.pRootCALocation = rootCA; connectParams.pDeviceCertLocation = clientCRT; connectParams.pDevicePrivateKeyLocation = clientKey; connectParams.mqttCommandTimeout_ms = 2000; connectParams.tlsHandshakeTimeout_ms = 5000; connectParams.isSSLHostnameVerify = true; // ensure this is set to true for production connectParams.disconnectHandler = disconnectCallbackHandler; INFO("Connecting..."); rc = aws_iot_mqtt_connect(&connectParams); if (NONE_ERROR != rc) { ERROR("Error(%d) connecting to %s:%d", rc, connectParams.pHostURL, connectParams.port); } /* * Enable Auto Reconnect functionality. Minimum and Maximum time of Exponential backoff are set in aws_iot_config.h * #AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL * #AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL */ rc = aws_iot_mqtt_autoreconnect_set_status(true); if (NONE_ERROR != rc) { ERROR("Unable to set Auto Reconnect to true - %d", rc); return rc; } MQTTSubscribeParams subParams = MQTTSubscribeParamsDefault; subParams.mHandler = MQTTcallbackHandler; subParams.pTopic = "sdkTest/sub"; subParams.qos = QOS_0; if (NONE_ERROR == rc) { INFO("Subscribing..."); rc = aws_iot_mqtt_subscribe(&subParams); if (NONE_ERROR != rc) { ERROR("Error subscribing"); } } MQTTMessageParams Msg = MQTTMessageParamsDefault; Msg.qos = QOS_0; char cPayload[100]; sprintf(cPayload, "%s", "hello from SDK"); Msg.pPayload = (void *) cPayload; MQTTPublishParams Params = MQTTPublishParamsDefault; Params.pTopic = "sdkTest/sub"; if (publishCount != 0) { infinitePublishFlag = false; } while ((NETWORK_ATTEMPTING_RECONNECT == rc || RECONNECT_SUCCESSFUL == rc || NONE_ERROR == rc) && (publishCount > 0 || infinitePublishFlag)) { //Max time the yield function will wait for read messages rc = aws_iot_mqtt_yield(100); if(NETWORK_ATTEMPTING_RECONNECT == rc){ INFO("-->sleep"); sleep(1); // If the client is attempting to reconnect we will skip the rest of the loop. continue; } INFO("-->sleep"); sleep(1); if (digitalRead (0) == HIGH) sprintf(cPayload, "%s:%d", "turn on the light", 1); sleep(1); if (digitalRead (0) == LOW) sprintf(cPayload, "%s:%d", "turn off the light", 0); sleep(1); Msg.PayloadLen = strlen(cPayload) + 1; Params.MessageParams = Msg; rc = aws_iot_mqtt_publish(&Params); if (publishCount > 0) { publishCount--; } } if (NONE_ERROR != rc) { ERROR("An error occurred in the loop.\n"); } else { INFO("Publish done\n"); } return rc; }
void aws_iot_task(void *param) { char cPayload[100]; int32_t i = 0; IoT_Error_t rc = FAILURE; AWS_IoT_Client client; IoT_Client_Init_Params mqttInitParams = iotClientInitParamsDefault; IoT_Client_Connect_Params connectParams = iotClientConnectParamsDefault; IoT_Publish_Message_Params paramsQOS0; IoT_Publish_Message_Params paramsQOS1; ESP_LOGI(TAG, "AWS IoT SDK Version %d.%d.%d-%s", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_TAG); mqttInitParams.enableAutoReconnect = false; // We enable this later below mqttInitParams.pHostURL = HostAddress; mqttInitParams.port = port; #if defined(CONFIG_EXAMPLE_EMBEDDED_CERTS) mqttInitParams.pRootCALocation = (const char *)aws_root_ca_pem_start; mqttInitParams.pDeviceCertLocation = (const char *)certificate_pem_crt_start; mqttInitParams.pDevicePrivateKeyLocation = (const char *)private_pem_key_start; #elif defined(CONFIG_EXAMPLE_FILESYSTEM_CERTS) mqttInitParams.pRootCALocation = ROOT_CA_PATH; mqttInitParams.pDeviceCertLocation = DEVICE_CERTIFICATE_PATH; mqttInitParams.pDevicePrivateKeyLocation = DEVICE_PRIVATE_KEY_PATH; #endif mqttInitParams.mqttCommandTimeout_ms = 20000; mqttInitParams.tlsHandshakeTimeout_ms = 5000; mqttInitParams.isSSLHostnameVerify = true; mqttInitParams.disconnectHandler = disconnectCallbackHandler; mqttInitParams.disconnectHandlerData = NULL; #ifdef CONFIG_EXAMPLE_SDCARD_CERTS ESP_LOGI(TAG, "Mounting SD card..."); sdmmc_host_t host = SDMMC_HOST_DEFAULT(); sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT(); esp_vfs_fat_sdmmc_mount_config_t mount_config = { .format_if_mount_failed = false, .max_files = 3, }; sdmmc_card_t* card; esp_err_t ret = esp_vfs_fat_sdmmc_mount("/sdcard", &host, &slot_config, &mount_config, &card); if (ret != ESP_OK) { ESP_LOGE(TAG, "Failed to mount SD card VFAT filesystem. Error: %s", esp_err_to_name(ret)); abort(); } #endif rc = aws_iot_mqtt_init(&client, &mqttInitParams); if(SUCCESS != rc) { ESP_LOGE(TAG, "aws_iot_mqtt_init returned error : %d ", rc); abort(); } /* Wait for WiFI to show as connected */ xEventGroupWaitBits(wifi_event_group, CONNECTED_BIT, false, true, portMAX_DELAY); connectParams.keepAliveIntervalInSec = 10; connectParams.isCleanSession = true; connectParams.MQTTVersion = MQTT_3_1_1; /* Client ID is set in the menuconfig of the example */ connectParams.pClientID = CONFIG_AWS_EXAMPLE_CLIENT_ID; connectParams.clientIDLen = (uint16_t) strlen(CONFIG_AWS_EXAMPLE_CLIENT_ID); connectParams.isWillMsgPresent = false; ESP_LOGI(TAG, "Connecting to AWS..."); do { rc = aws_iot_mqtt_connect(&client, &connectParams); if(SUCCESS != rc) { ESP_LOGE(TAG, "Error(%d) connecting to %s:%d", rc, mqttInitParams.pHostURL, mqttInitParams.port); vTaskDelay(1000 / portTICK_RATE_MS); } } while(SUCCESS != rc); /* * Enable Auto Reconnect functionality. Minimum and Maximum time of Exponential backoff are set in aws_iot_config.h * #AWS_IOT_MQTT_MIN_RECONNECT_WAIT_INTERVAL * #AWS_IOT_MQTT_MAX_RECONNECT_WAIT_INTERVAL */ rc = aws_iot_mqtt_autoreconnect_set_status(&client, true); if(SUCCESS != rc) { ESP_LOGE(TAG, "Unable to set Auto Reconnect to true - %d", rc); abort(); } const char *TOPIC = "test_topic/esp32"; const int TOPIC_LEN = strlen(TOPIC); ESP_LOGI(TAG, "Subscribing..."); rc = aws_iot_mqtt_subscribe(&client, TOPIC, TOPIC_LEN, QOS0, iot_subscribe_callback_handler, NULL); if(SUCCESS != rc) { ESP_LOGE(TAG, "Error subscribing : %d ", rc); abort(); } sprintf(cPayload, "%s : %d ", "hello from SDK", i); paramsQOS0.qos = QOS0; paramsQOS0.payload = (void *) cPayload; paramsQOS0.isRetained = 0; paramsQOS1.qos = QOS1; paramsQOS1.payload = (void *) cPayload; paramsQOS1.isRetained = 0; while(1) { //Max time the yield function will wait for read messages rc = aws_iot_mqtt_yield(&client, 100); if(NETWORK_ATTEMPTING_RECONNECT == rc) { // If the client is attempting to reconnect we will skip the rest of the loop. continue; } ESP_LOGI(TAG, "Stack remaining for task '%s' is %lu bytes", pcTaskGetTaskName(NULL), uxTaskGetStackHighWaterMark(NULL)); vTaskDelay(1000 / portTICK_RATE_MS); sprintf(cPayload, "%s : %d ", "hello from ESP32 (QOS0)", i++); paramsQOS0.payloadLen = strlen(cPayload); rc = aws_iot_mqtt_publish(&client, TOPIC, TOPIC_LEN, ¶msQOS0); sprintf(cPayload, "%s : %d ", "hello from ESP32 (QOS1)", i++); paramsQOS1.payloadLen = strlen(cPayload); rc = aws_iot_mqtt_publish(&client, TOPIC, TOPIC_LEN, ¶msQOS1); if (rc == MQTT_REQUEST_TIMEOUT_ERROR) { ESP_LOGW(TAG, "QOS1 publish ack not received."); rc = SUCCESS; } } ESP_LOGE(TAG, "An error occurred in the main loop."); abort(); } static void initialise_wifi(void) { tcpip_adapter_init(); wifi_event_group = xEventGroupCreate(); ESP_ERROR_CHECK( esp_event_loop_init(event_handler, NULL) ); wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT(); ESP_ERROR_CHECK( esp_wifi_init(&cfg) ); ESP_ERROR_CHECK( esp_wifi_set_storage(WIFI_STORAGE_RAM) ); wifi_config_t wifi_config = { .sta = { .ssid = EXAMPLE_WIFI_SSID, .password = EXAMPLE_WIFI_PASS, }, }; ESP_LOGI(TAG, "Setting WiFi configuration SSID %s...", wifi_config.sta.ssid); ESP_ERROR_CHECK( esp_wifi_set_mode(WIFI_MODE_STA) ); ESP_ERROR_CHECK( esp_wifi_set_config(WIFI_IF_STA, &wifi_config) ); ESP_ERROR_CHECK( esp_wifi_start() ); }