int main(int argc, char **argv) {
IoT_Error_t rc = FAILURE;
parseInputArgsForConnectParams(argc, argv);
if (!readDataFromFile()) {
printf("Config file '%s' not found. Robot cannot work without configuration.\n", filename);
return -1;
}
else {
if (connectToThingAndSubscribeToTopic(argc, argv)) {
publishMessage(getFieldAsString());
publishRobotState();
while (true) {
//Max time the yield function will wait for read messages
rc = aws_iot_mqtt_yield(&mqttClient, 1000);
if (NETWORK_ATTEMPTING_RECONNECT == rc) { // || NETWORK_ATTEMPTING_RECONNECT == rc1) {
// If the client is attempting to reconnect we will skip the rest of the loop.
continue;
}
sleep(3);
if (currentState == GO) {
if (checkNextStep()) {
currentState = GO;
currentSensor = NONE;
makeStep();
}
}
}
}
return 0;
}
}
int main(int argc, char** argv) {
IoT_Error_t rc = NONE_ERROR;
int32_t i = 0;
int j = 0;
int ret = 0;
time_t timestamp = time(NULL);
int timeout = 3600;
bool infinitePublishFlag = true;
unsigned short len = 0;
char chaccessKey[17] = {0};
unsigned char Password[100] = {0};
char userName[100] = {0};
char clientId[256] = {0};
//char subTopic[256] = {0};
char pubTopic[256] = {0};
parseInputArgsForConnectParams(argc, argv);
INFO("\nAWS IoT SDK Version %d.%d.%d-%s\n", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_TAG);
(void)iot_tls_set_host(ACHostAddr);
(void)AC_RegisterAccessCallBack(getAccessPointAction);
ret = AC_DeviceServiceInit(domainName, subdomainName, deviceId, "0-0-0");
if (0 != ret)
{
INFO("\nAC Init error\n");
return AC_INIT_ERROR;
}
ret = AC_GetAccessPoints();
if (0 != ret)
{
INFO("\nAC get access points error\n");
return AC_GET_ACCESS_POINTS_ERROR;
}
while (0 == strcmp(HostAddress, "dev.ablecloud.cn"))
{
INFO("-->equal");
sleep(1);
}
INFO("HostAddress is %s\n", HostAddress);
do
{
ret = (int)MQTTConnectCloud();
if (NONE_ERROR != ret)
{
ret = getNextAccessPoint();
if (NONE_ERROR == ret)
{
continue;
}
else
{
/* delete file */
AC_DelAccessPointFile();
/* get access point again */
ret = AC_GetAccessPoints();
}
}
else
{
break;
}
}while(NONE_ERROR == ret);
/*
* 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;
}
if (NONE_ERROR == rc)
{
rc = ACMqttSubscribe();
if (NONE_ERROR != rc)
{
ERROR("Error subscribing,error is %d", rc);
}
}
/* report version */
MQTTReportVersion();
if (publishCount != 0) {
infinitePublishFlag = false;
}
char cPayload[100];
sprintf(cPayload, "%s", "hello from SDK");
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);
rc = ACMqttPublish(210, 0, cPayload, 14);
if (NONE_ERROR != rc)
{
ERROR("Publish error\n");
}
if (publishCount > 0) {
publishCount--;
}
}
if (NONE_ERROR != rc) {
ERROR("An error occurred in the loop.\n");
} else {
INFO("Publish done\n");
}
return rc;
}
int main(int argc, char** argv) {
IoT_Error_t rc = NONE_ERROR;
int32_t i = 0;
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;
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);
parseInputArgsForConnectParams(argc, argv);
// initialize the mqtt client
MQTTClient_t mqttClient;
aws_iot_mqtt_init(&mqttClient);
ShadowParameters_t sp = ShadowParametersDefault;
sp.pMyThingName = AWS_IOT_MY_THING_NAME;
sp.pMqttClientId = AWS_IOT_MQTT_CLIENT_ID;
sp.pHost = AWS_IOT_MQTT_HOST;
sp.port = AWS_IOT_MQTT_PORT;
sp.pClientCRT = clientCRT;
sp.pClientKey = clientKey;
sp.pRootCA = rootCA;
INFO("Shadow Init");
rc = aws_iot_shadow_init(&mqttClient);
if (NONE_ERROR != rc) {
ERROR("Shadow Connection Error");
return rc;
}
INFO("Shadow Connect");
rc = aws_iot_shadow_connect(&mqttClient, &sp);
if (NONE_ERROR != rc) {
ERROR("Shadow Connection Error");
return rc;
}
jsonStruct_t deltaObject;
deltaObject.pData = stringToEchoDelta;
deltaObject.pKey = "state";
deltaObject.type = SHADOW_JSON_OBJECT;
deltaObject.cb = DeltaCallback;
/*
* Register the jsonStruct object
*/
rc = aws_iot_shadow_register_delta(&mqttClient, &deltaObject);
// Now wait in the loop to receive any message sent from the console
while (rc == NONE_ERROR) {
/*
* Lets check for the incoming messages for 200 ms.
*/
rc = aws_iot_shadow_yield(&mqttClient, 200);
if (messageArrivedOnDelta) {
INFO("\nSending delta message back %s\n", stringToEchoDelta);
rc = aws_iot_shadow_update(&mqttClient, AWS_IOT_MY_THING_NAME, stringToEchoDelta, UpdateStatusCallback, NULL, 2, true);
messageArrivedOnDelta = false;
}
// sleep for some time in seconds
sleep(1);
}
if (NONE_ERROR != rc) {
ERROR("An error occurred in the loop %d", rc);
}
INFO("Disconnecting");
rc = aws_iot_shadow_disconnect(&mqttClient);
if (NONE_ERROR != rc) {
ERROR("Disconnect error %d", rc);
}
return rc;
}
int main(int argc, char** argv) {
IoT_Error_t rc = SUCCESS;
int32_t i = 0;
char rootCA[PATH_MAX + 1];
char clientCRT[PATH_MAX + 1];
char clientKey[PATH_MAX + 1];
char CurrentWD[PATH_MAX + 1];
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);
parseInputArgsForConnectParams(argc, argv);
// initialize the mqtt client
AWS_IoT_Client mqttClient;
ShadowInitParameters_t sp = ShadowInitParametersDefault;
sp.pHost = AWS_IOT_MQTT_HOST;
sp.port = AWS_IOT_MQTT_PORT;
sp.pClientCRT = clientCRT;
sp.pClientKey = clientKey;
sp.pRootCA = rootCA;
sp.enableAutoReconnect = false;
sp.disconnectHandler = NULL;
IOT_INFO("Shadow Init");
rc = aws_iot_shadow_init(&mqttClient, &sp);
if (SUCCESS != rc) {
IOT_ERROR("Shadow Connection Error");
return rc;
}
ShadowConnectParameters_t scp = ShadowConnectParametersDefault;
scp.pMyThingName = AWS_IOT_MY_THING_NAME;
scp.pMqttClientId = AWS_IOT_MQTT_CLIENT_ID;
scp.mqttClientIdLen = (uint16_t) strlen(AWS_IOT_MQTT_CLIENT_ID);
IOT_INFO("Shadow Connect");
rc = aws_iot_shadow_connect(&mqttClient, &scp);
if (SUCCESS != rc) {
IOT_ERROR("Shadow Connection Error");
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_shadow_set_autoreconnect_status(&mqttClient, true);
if(SUCCESS != rc){
IOT_ERROR("Unable to set Auto Reconnect to true - %d", rc);
return rc;
}
jsonStruct_t deltaObject;
deltaObject.pData = stringToEchoDelta;
deltaObject.pKey = "state";
deltaObject.type = SHADOW_JSON_OBJECT;
deltaObject.cb = DeltaCallback;
/*
* Register the jsonStruct object
*/
rc = aws_iot_shadow_register_delta(&mqttClient, &deltaObject);
// Now wait in the loop to receive any message sent from the console
while (NETWORK_ATTEMPTING_RECONNECT == rc || NETWORK_RECONNECTED == rc || SUCCESS == rc) {
/*
* Lets check for the incoming messages for 200 ms.
*/
rc = aws_iot_shadow_yield(&mqttClient, 200);
if (NETWORK_ATTEMPTING_RECONNECT == rc) {
sleep(1);
// If the client is attempting to reconnect we will skip the rest of the loop.
continue;
}
if (messageArrivedOnDelta) {
IOT_INFO("\nSending delta message back %s\n", stringToEchoDelta);
rc = aws_iot_shadow_update(&mqttClient, AWS_IOT_MY_THING_NAME, stringToEchoDelta, UpdateStatusCallback, NULL, 2, true);
messageArrivedOnDelta = false;
}
// sleep for some time in seconds
sleep(1);
}
if (SUCCESS != rc) {
IOT_ERROR("An error occurred in the loop %d", rc);
}
IOT_INFO("Disconnecting");
rc = aws_iot_shadow_disconnect(&mqttClient);
if (SUCCESS != rc) {
IOT_ERROR("Disconnect error %d", rc);
}
return rc;
}
int main(int argc, char **argv) {
IoT_Error_t rc = FAILURE;
int32_t i = 0;
char JsonDocumentBuffer[MAX_LENGTH_OF_UPDATE_JSON_BUFFER];
size_t sizeOfJsonDocumentBuffer = sizeof(JsonDocumentBuffer) / sizeof(JsonDocumentBuffer[0]);
char *pJsonStringToUpdate;
float temperature = 0.0;
bool windowOpen = false;
jsonStruct_t windowActuator;
windowActuator.cb = windowActuate_Callback;
windowActuator.pData = &windowOpen;
windowActuator.dataLength = sizeof(bool);
windowActuator.pKey = "windowOpen";
windowActuator.type = SHADOW_JSON_BOOL;
jsonStruct_t temperatureHandler;
temperatureHandler.cb = NULL;
temperatureHandler.pKey = "temperature";
temperatureHandler.pData = &temperature;
temperatureHandler.dataLength = sizeof(float);
temperatureHandler.type = SHADOW_JSON_FLOAT;
char rootCA[PATH_MAX + 1];
char clientCRT[PATH_MAX + 1];
char clientKey[PATH_MAX + 1];
char CurrentWD[PATH_MAX + 1];
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);
parseInputArgsForConnectParams(argc, argv);
// initialize the mqtt client
AWS_IoT_Client mqttClient;
ShadowInitParameters_t sp = ShadowInitParametersDefault;
sp.pHost = AWS_IOT_MQTT_HOST;
sp.port = AWS_IOT_MQTT_PORT;
sp.pClientCRT = clientCRT;
sp.pClientKey = clientKey;
sp.pRootCA = rootCA;
sp.enableAutoReconnect = false;
sp.disconnectHandler = NULL;
IOT_INFO("Shadow Init");
rc = aws_iot_shadow_init(&mqttClient, &sp);
if(SUCCESS != rc) {
IOT_ERROR("Shadow Connection Error");
return rc;
}
ShadowConnectParameters_t scp = ShadowConnectParametersDefault;
scp.pMyThingName = AWS_IOT_MY_THING_NAME;
scp.pMqttClientId = AWS_IOT_MQTT_CLIENT_ID;
scp.mqttClientIdLen = (uint16_t) strlen(AWS_IOT_MQTT_CLIENT_ID);
IOT_INFO("Shadow Connect");
rc = aws_iot_shadow_connect(&mqttClient, &scp);
if(SUCCESS != rc) {
IOT_ERROR("Shadow Connection Error");
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_shadow_set_autoreconnect_status(&mqttClient, true);
if(SUCCESS != rc) {
IOT_ERROR("Unable to set Auto Reconnect to true - %d", rc);
return rc;
}
rc = aws_iot_shadow_register_delta(&mqttClient, &windowActuator);
if(SUCCESS != rc) {
IOT_ERROR("Shadow Register Delta Error");
}
temperature = STARTING_ROOMTEMPERATURE;
// loop and publish a change in temperature
while(NETWORK_ATTEMPTING_RECONNECT == rc || NETWORK_RECONNECTED == rc || SUCCESS == rc) {
rc = aws_iot_shadow_yield(&mqttClient, 200);
if(NETWORK_ATTEMPTING_RECONNECT == rc) {
sleep(1);
// If the client is attempting to reconnect we will skip the rest of the loop.
continue;
}
IOT_INFO("\n=======================================================================================\n");
IOT_INFO("On Device: window state %s", windowOpen ? "true" : "false");
simulateRoomTemperature(&temperature);
rc = aws_iot_shadow_init_json_document(JsonDocumentBuffer, sizeOfJsonDocumentBuffer);
if(SUCCESS == rc) {
rc = aws_iot_shadow_add_reported(JsonDocumentBuffer, sizeOfJsonDocumentBuffer, 2, &temperatureHandler,
&windowActuator);
if(SUCCESS == rc) {
rc = aws_iot_finalize_json_document(JsonDocumentBuffer, sizeOfJsonDocumentBuffer);
if(SUCCESS == rc) {
IOT_INFO("Update Shadow: %s", JsonDocumentBuffer);
rc = aws_iot_shadow_update(&mqttClient, AWS_IOT_MY_THING_NAME, JsonDocumentBuffer,
ShadowUpdateStatusCallback, NULL, 4, true);
}
}
}
IOT_INFO("*****************************************************************************************\n");
sleep(1);
}
if(SUCCESS != rc) {
IOT_ERROR("An error occurred in the loop %d", rc);
}
IOT_INFO("Disconnecting");
rc = aws_iot_shadow_disconnect(&mqttClient);
if(SUCCESS != rc) {
IOT_ERROR("Disconnect error %d", rc);
}
return rc;
}
int main(int argc, char** argv) {
IoT_Error_t rc = NONE_ERROR;
int32_t i = 0;
MQTTClient_t mqttClient;
aws_iot_mqtt_init(&mqttClient);
char JsonDocumentBuffer[MAX_LENGTH_OF_UPDATE_JSON_BUFFER];
size_t sizeOfJsonDocumentBuffer = sizeof(JsonDocumentBuffer) / sizeof(JsonDocumentBuffer[0]);
char *pJsonStringToUpdate;
float temperature = 0.0;
bool windowOpen = false;
jsonStruct_t windowActuator;
windowActuator.cb = windowActuate_Callback;
windowActuator.pData = &windowOpen;
windowActuator.pKey = "windowOpen";
windowActuator.type = SHADOW_JSON_BOOL;
jsonStruct_t temperatureHandler;
temperatureHandler.cb = NULL;
temperatureHandler.pKey = "temperature";
temperatureHandler.pData = &temperature;
temperatureHandler.type = SHADOW_JSON_FLOAT;
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(dev) %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("Using rootCA %s", rootCA);
DEBUG("Using clientCRT %s", clientCRT);
DEBUG("Using clientKey %s", clientKey);
ShadowParameters_t sp = ShadowParametersDefault;
sp.pMyThingName = AWS_IOT_MY_THING_NAME;
sp.pMqttClientId = AWS_IOT_MQTT_CLIENT_ID;
sp.pHost = HostAddress;
sp.port = port;
sp.pClientCRT = clientCRT;
sp.pClientKey = clientKey;
sp.pRootCA = rootCA;
INFO("Shadow Init");
rc = aws_iot_shadow_init(&mqttClient);
INFO("Shadow Connect");
rc = aws_iot_shadow_connect(&mqttClient, &sp);
if (NONE_ERROR != rc) {
ERROR("Shadow Connection Error %d", rc);
}
rc = aws_iot_shadow_register_delta(&mqttClient, &windowActuator);
if (NONE_ERROR != rc) {
ERROR("Shadow Register Delta Error");
}
temperature = STARTING_ROOMTEMPERATURE;
// loop and publish a change in temperature
while (NONE_ERROR == rc) {
rc = aws_iot_shadow_yield(&mqttClient, 200);
INFO("\n=======================================================================================\n");
INFO("On Device: window state %s", windowOpen?"true":"false");
simulateRoomTemperature(&temperature);
rc = aws_iot_shadow_init_json_document(JsonDocumentBuffer, sizeOfJsonDocumentBuffer);
if (rc == NONE_ERROR) {
rc = aws_iot_shadow_add_reported(JsonDocumentBuffer, sizeOfJsonDocumentBuffer, 2, &temperatureHandler,
&windowActuator);
if (rc == NONE_ERROR) {
rc = aws_iot_finalize_json_document(JsonDocumentBuffer, sizeOfJsonDocumentBuffer);
if (rc == NONE_ERROR) {
INFO("Update Shadow: %s", JsonDocumentBuffer);
rc = aws_iot_shadow_update(&mqttClient, AWS_IOT_MY_THING_NAME, JsonDocumentBuffer, ShadowUpdateStatusCallback,
NULL, 4, true);
}
}
}
INFO("*****************************************************************************************\n");
sleep(1);
}
if (NONE_ERROR != rc) {
ERROR("An error occurred in the loop %d", rc);
}
INFO("Disconnecting");
rc = aws_iot_shadow_disconnect(&mqttClient);
if (NONE_ERROR != rc) {
ERROR("Disconnect error %d", rc);
}
return rc;
}
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;
}
/*******************************************************************************
* Main
*
********************************************************************************/
int main(int argc, char** argv)
{
IoT_Error_t rc = NONE_ERROR;
int32_t i = 0;
int ret =0;
char rootCA[PATH_MAX + 1];
char clientCRT[PATH_MAX + 1];
char clientKey[PATH_MAX + 1];
char CurrentWD[PATH_MAX + 1];
char cafileName[] = "/rootCA.crt";
char clientCRTName[] = "/aws.crt";
char clientKeyName[] = "/aws.key";
char* thingID;
//
//Register ctrl-c handler
//
signal(SIGINT, CTRL_C_Handler);
//
//Parse Input-parameters
//
parseInputArgsForConnectParams(argc, argv);
//
// Get the ThingID/MachineID
//
thingID = GetMachineID();
//
// Export GPIO12 for LED output
//
ret = Export_GPIO(GPIO12); //Export GPIO12 for LED output
if (ret != 0) {
ERROR("Could not export LED GPIO");
}
//
//Register Event-handler for Vol+/- button
//
ret = RegisterEventHandler(VOL_UP_EVENT, On_VolUp_ButtonPress, (void*) thingID);
if (ret != 0) {
ERROR("Could not register EventHandler");
}
ret = RegisterEventHandler(VOL_DOWN_EVENT, On_VolDown_ButtonPress,(void*) thingID);
if (ret != 0) {
ERROR("Could not register EventHandler");
}
//
//Create the mainloop for polling the button events
//
loop = g_main_loop_new( NULL, false );
if(!loop) {
ERROR("Could not Create Main loop");
return -1;
}
//
//Setting path to private key and certificates
//
sprintf(rootCA, "%s%s", certDirectory, cafileName);
sprintf(clientCRT, "%s%s", certDirectory, clientCRTName);
sprintf(clientKey, "%s%s", certDirectory, clientKeyName);
INFO("ThingID: %s", thingID);
INFO("AWS IoT SDK: %d.%d.%d-%s", VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH, VERSION_TAG);
INFO("rootCA: %s", rootCA);
INFO("clientCRT: %s", clientCRT);
INFO("clientKey: %s\n", clientKey);
struct stat reqFileStat;
if (stat(rootCA, &reqFileStat) < 0 || stat(clientCRT, &reqFileStat) < 0 ||
stat(clientKey, &reqFileStat) < 0)
{
ERROR("Root certificate and client certificate and key MUST be present.");
exit(1);
}
//
// Connect MQTT client
//
INFO("Connecting to %s:%d", HostAddress, port);
rc = MQTT_Connect(HostAddress,port, thingID, rootCA, clientCRT, clientKey);
if (NONE_ERROR != rc) {
ERROR("Error[%d] connecting to %s:%d", rc, HostAddress, port);
}
//
// Subscribe to LED status-changes topic
//
char topic[512];
sprintf(topic, led_state_sub_topic, thingID);
INFO("Subscribing to topic:%s", topic);
rc = MQTT_Subscribe(topic, QOS_0, MQTTcallbackHandler);
if (NONE_ERROR != rc) {
ERROR("Error[%d] subscribing to topic: %s", rc, led_state_sub_topic);
}
//iot_mqtt_yield(1000); //TODO: clarify
//
//Hook in a function into main loop that calls iot_mqtt_yield in regular intervals
//
g_timeout_add(1000, timer_func, 0);
//
//start the main loop
//This call is blocking until the main loop is exited with a call to g_main_loop_quit(loop)
//from the CTRL-C handler;
INFO("Entering main-loop, please press ctrl-c to quit the demo-app:");
g_main_loop_run( loop );
INFO("Cleaning up application ...");
//Unsubscribe from Topics
//Disconnect MQTT connection
//Unregister GPIO-EventHandlers
//UnExport GPIO's
//Destroy main loop
if(loop)
g_main_loop_unref(loop);
return rc;
}
