#include <wm_os.h>
#include <wmstdio.h>
#include <wmtime.h>
#include <wmsdk.h>
#include <led_indicator.h>
#include <board.h>
#include <push_button.h>
#include <aws_iot_mqtt_interface.h>
#include <aws_iot_shadow_interface.h>
#include <aws_utils.h>
#include <mdev_gpio.h>
#include <mdev_pinmux.h>
/* configuration parameters */
#include <aws_iot_config.h>
#include "aws_starter_root_ca_cert.h"
enum state {
AWS_CONNECTED = 1,
AWS_RECONNECTED,
AWS_DISCONNECTED
};
/*-----------------------Global declarations----------------------*/
/* This holds LED gpio pin number */
static unsigned int gpio_led;
static unsigned int gpio_led_state;
static unsigned int pin0=GPIO_0;
static unsigned int pin1=GPIO_1;
static unsigned int pin2=GPIO_40;
static unsigned int pin3=GPIO_41;
static unsigned int pin4=GPIO_27;
static unsigned int pin5=GPIO_48;
static unsigned int pin6=GPIO_49;
static unsigned int pin7=GPIO_47;
static unsigned int pin8=GPIO_42;
static unsigned int pin9=GPIO_43;
static unsigned int pin10=GPIO_46;
static unsigned int pin11=GPIO_18;
static unsigned int pin12=GPIO_17;
static unsigned int pin13=GPIO_16;
static unsigned int pin14=GPIO_39;
static unsigned int pin15=GPIO_26;
static unsigned int pin16=GPIO_14;
static unsigned int pin17=GPIO_13;
static unsigned int pin18=GPIO_12;
static unsigned int pin19=GPIO_11;
static unsigned int pin20=GPIO_24;
static unsigned int pin21=GPIO_3;
static unsigned int pin22=GPIO_2;
static unsigned int pin23=GPIO_23;
static unsigned int pin24=GPIO_25;
static unsigned int pin25=GPIO_26;
#define GPIO_LED_FN PINMUX_FUNCTION_0
#if defined(CONFIG_CPU_MW300)
#endif
/* These hold each pushbutton's count, updated in the callback ISR */
static volatile uint32_t led_1_state;
static volatile uint32_t led_1_state_prev = -1;
static output_gpio_cfg_t led_1;
static MQTTClient_t mqtt_client;
static enum state device_state;
/* Thread handle */
static os_thread_t aws_starter_thread;
/* Buffer to be used as stack */
static os_thread_stack_define(aws_starter_stack, 12 * 1024);
/* aws iot url */
static char url[128];
#define MICRO_AP_SSID "aws_starter"
#define MICRO_AP_PASSPHRASE "marvellwm"
#define AMAZON_ACTION_BUF_SIZE 100
#define VAR_LED_1_PROPERTY "PATTERN"
#define RESET_TO_FACTORY_TIMEOUT 5000
#define BUFSIZE 128
#define MAX_MAC_BYTES 6
/* callback function invoked on reset to factory */
static void device_reset_to_factory_cb()
{
/* Clears device configuration settings from persistent memory
* and reboots the device.
*/
invoke_reset_to_factory();
}
/* board_button_2() is configured to perform reset to factory,
* when pressed for more than 5 seconds.
*/
static void configure_reset_to_factory()
{
input_gpio_cfg_t pushbutton_reset_to_factory = {
.gpio = board_button_2(),
.type = GPIO_ACTIVE_LOW
};
push_button_set_cb(pushbutton_reset_to_factory,
device_reset_to_factory_cb,
RESET_TO_FACTORY_TIMEOUT, 0, NULL);
}
static char client_cert_buffer[AWS_PUB_CERT_SIZE];
static char private_key_buffer[AWS_PRIV_KEY_SIZE];
#define THING_LEN 126
#define REGION_LEN 16
static char thing_name[THING_LEN];
static char client_id[MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES];
/* populate aws shadow configuration details */
static int aws_starter_load_configuration(ShadowParameters_t *sp)
{
int ret = WM_SUCCESS;
char region[REGION_LEN];
uint8_t device_mac[MAX_MAC_BYTES];
memset(region, 0, sizeof(region));
/* read configured thing name from the persistent memory */
ret = read_aws_thing(thing_name, THING_LEN);
if (ret != WM_SUCCESS) {
wmprintf("Failed to configure thing. Returning!\r\n");
return -WM_FAIL;
}
sp->pMyThingName = thing_name;
/* read device MAC address */
ret = read_aws_device_mac(device_mac);
if (ret != WM_SUCCESS) {
wmprintf("Failed to read device mac address. Returning!\r\n");
return -WM_FAIL;
}
/* Unique client ID in the format prefix-6 byte MAC address */
snprintf(client_id, MAX_SIZE_OF_UNIQUE_CLIENT_ID_BYTES,
"%s-%02x%02x%02x%02x%02x%02x", AWS_IOT_MQTT_CLIENT_ID,
device_mac[0], device_mac[1], device_mac[2],
device_mac[3], device_mac[4], device_mac[5]);
sp->pMqttClientId = client_id;
/* read configured region name from the persistent memory */
ret = read_aws_region(region, REGION_LEN);
if (ret == WM_SUCCESS) {
snprintf(url, sizeof(url), "data.iot.%s.amazonaws.com",
region);
} else {
snprintf(url, sizeof(url), "data.iot.%s.amazonaws.com",
AWS_IOT_MY_REGION_NAME);
}
sp->pHost = url;
sp->port = AWS_IOT_MQTT_PORT;
sp->pRootCA = rootCA;
/* read configured certificate from the persistent memory */
ret = read_aws_certificate(client_cert_buffer, AWS_PUB_CERT_SIZE);
if (ret != WM_SUCCESS) {
wmprintf("Failed to configure certificate. Returning!\r\n");
return -WM_FAIL;
}
sp->pClientCRT = client_cert_buffer;
/* read configured private key from the persistent memory */
ret = read_aws_key(private_key_buffer, AWS_PRIV_KEY_SIZE);
if (ret != WM_SUCCESS) {
wmprintf("Failed to configure key. Returning!\r\n");
return -WM_FAIL;
}
sp->pClientKey = private_key_buffer;
return ret;
}
void shadow_update_status_cb(const char *pThingName, ShadowActions_t action,
Shadow_Ack_Status_t status,
const char *pReceivedJsonDocument,
void *pContextData) {
if (status == SHADOW_ACK_TIMEOUT) {
wmprintf("Shadow publish state change timeout occurred\r\n");
} else if (status == SHADOW_ACK_REJECTED) {
wmprintf("Shadow publish state change rejected\r\n");
} else if (status == SHADOW_ACK_ACCEPTED) {
wmprintf("Shadow publish state change accepted\r\n");
}
}
void delay(unsigned int val)
{
os_thread_sleep(os_msec_to_ticks(val));
}
/* This function turns on the LED*/
static void gpio_led_on(unsigned int pin)
{
gpio_led=pin;
mdev_t *gpio_dev = gpio_drv_open("MDEV_GPIO");
/* Turn on LED by writing 0 in GPIO register */
gpio_drv_write(gpio_dev, gpio_led, 0);
gpio_drv_close(gpio_dev);
gpio_led_state = 1;
}
/* This function turns off the LED*/
static void gpio_led_off(unsigned int pin)
{
gpio_led=pin;
mdev_t *gpio_dev = gpio_drv_open("MDEV_GPIO");
/* Turn off LED by writing 1 in GPIO register */
gpio_drv_write(gpio_dev, gpio_led, 1);
gpio_drv_close(gpio_dev);
gpio_led_state = 0;
}
/* Configure GPIO pins to be used as LED and push button */
static void configure_gpios()
{
mdev_t *pinmux_dev, *gpio_dev;
/* Initialize pinmux driver */
pinmux_drv_init();
/* Open pinmux driver */
pinmux_dev = pinmux_drv_open("MDEV_PINMUX");
/* Initialize GPIO driver */
gpio_drv_init();
/* Open GPIO driver */
gpio_dev = gpio_drv_open("MDEV_GPIO");
/* Configure GPIO pin function for GPIO connected to LED */
pinmux_drv_setfunc(pinmux_dev, gpio_led, GPIO_LED_FN);
/* Configure GPIO pin direction as Output */
gpio_drv_setdir(gpio_dev, gpio_led, GPIO_OUTPUT);
/* Keep initial state of LED: ON */
gpio_drv_write(gpio_dev, gpio_led, 0);
/* Close drivers */
pinmux_drv_close(pinmux_dev);
gpio_drv_close(gpio_dev);
}
digitalWrite(unsigned int pin,char cond)
{
switch (cond)
{
case 1:{
gpio_led_off(pin);
break;
}
case 0:{
gpio_led_on(pin);
break;
}
}
}
void up()
{
digitalWrite(pin0,1);
digitalWrite(pin1,1);
digitalWrite(pin2,1);
digitalWrite(pin3,1);
digitalWrite(pin4,1);
digitalWrite(pin5,1);
digitalWrite(pin6,1);
digitalWrite(pin7,1);
digitalWrite(pin8,1);
digitalWrite(pin9,1);
digitalWrite(pin10,1);
digitalWrite(pin11,1);
digitalWrite(pin12,1);
digitalWrite(pin13,1);
digitalWrite(pin14,1);
digitalWrite(pin15,1);
digitalWrite(pin16,1);
digitalWrite(pin17,1);
digitalWrite(pin18,1);
digitalWrite(pin19,1);
digitalWrite(pin20,1);
digitalWrite(pin21,1);
digitalWrite(pin22,1);
digitalWrite(pin23,1);
digitalWrite(pin24,1);
digitalWrite(pin25,1);
}
void down()
{
digitalWrite(pin0,0);
digitalWrite(pin1,0);
digitalWrite(pin2,0);
digitalWrite(pin3,0);
digitalWrite(pin4,0);
digitalWrite(pin5,0);
digitalWrite(pin6,0);
digitalWrite(pin7,0);
digitalWrite(pin8,0);
digitalWrite(pin9,0);
digitalWrite(pin10,0);
digitalWrite(pin11,0);
digitalWrite(pin12,0);
digitalWrite(pin13,0);
digitalWrite(pin14,0);
digitalWrite(pin15,0);
digitalWrite(pin16,0);
digitalWrite(pin17,0);
digitalWrite(pin18,0);
digitalWrite(pin19,0);
digitalWrite(pin20,0);
digitalWrite(pin21,0);
digitalWrite(pin22,0);
digitalWrite(pin23,0);
digitalWrite(pin24,0);
digitalWrite(pin25,0);
}
void layer (unsigned int lr)
{
switch(lr)
{
case 1:
{
digitalWrite(pin16,1);
digitalWrite(pin17,1);
break;
}
case 2:
{
digitalWrite(pin16,1);
digitalWrite(pin17,0);
break;
}
case 3:
{
digitalWrite(pin16,0);
digitalWrite(pin17,1);
break;
}
case 4:
{
digitalWrite(pin16,0);
digitalWrite(pin17,0);
break;
}
}
}
void pattern_1(void) //upward_motion
{
int k;
digitalWrite(pin0,1);
digitalWrite(pin1,1);
digitalWrite(pin2,1);
digitalWrite(pin3,1);
digitalWrite(pin4,1);
digitalWrite(pin5,1);
digitalWrite(pin6,1);
digitalWrite(pin7,1);
digitalWrite(pin8,1);
digitalWrite(pin9,1);
digitalWrite(pin10,1);
digitalWrite(pin11,1);
digitalWrite(pin12,1);
digitalWrite(pin13,1);
digitalWrite(pin14,1);
digitalWrite(pin15,1);
for(k=0;k<20;k++)
{
layer(1);
delay(200);
layer(2);
delay(200);
layer(3);
delay(200);
layer(4);
delay(200);
}
}
void pattern_2 (void) //downward_motion
{
int k;
digitalWrite(pin0,1);
digitalWrite(pin1,1);
digitalWrite(pin2,1);
digitalWrite(pin3,1);
digitalWrite(pin4,1);
digitalWrite(pin5,1);
digitalWrite(pin6,1);
digitalWrite(pin7,1);
digitalWrite(pin8,1);
digitalWrite(pin9,1);
digitalWrite(pin10,1);
digitalWrite(pin11,1);
digitalWrite(pin12,1);
digitalWrite(pin13,1);
digitalWrite(pin14,1);
digitalWrite(pin15,1);
for(k=0;k<20;k++)
{
layer(1);
delay(200);
layer(2);
delay(200);
layer(3);
delay(200);
layer(4);
delay(200);
}
}
void pattern_3 (void)//right to left
{
int l,i;
for(i=0;i<10;i++){
digitalWrite(pin0,1);
digitalWrite(pin1,1);
digitalWrite(pin2,1);
digitalWrite(pin3,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin0,0);
digitalWrite(pin1,0);
digitalWrite(pin2,0);
digitalWrite(pin3,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin4,1);
digitalWrite(pin5,1);
digitalWrite(pin6,1);
digitalWrite(pin7,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin4,0);
digitalWrite(pin5,0);
digitalWrite(pin6,0);
digitalWrite(pin7,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin8,1);
digitalWrite(pin9,1);
digitalWrite(pin10,1);
digitalWrite(pin11,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin8,0);
digitalWrite(pin9,0);
digitalWrite(pin10,0);
digitalWrite(pin11,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin12,1);
digitalWrite(pin13,1);
digitalWrite(pin14,1);
digitalWrite(pin15,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin12,0);
digitalWrite(pin13,0);
digitalWrite(pin14,0);
digitalWrite(pin15,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
// delay(500);
}
}
void pattern_4 (void)// left to right
{
int k=0,l;
for(k=0;k<10;k++)
{
digitalWrite(pin12,1);
digitalWrite(pin13,1);
digitalWrite(pin14,1);
digitalWrite(pin15,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin12,0);
digitalWrite(pin13,0);
digitalWrite(pin14,0);
digitalWrite(pin15,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin8,1);
digitalWrite(pin9,1);
digitalWrite(pin10,1);
digitalWrite(pin11,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin8,0);
digitalWrite(pin9,0);
digitalWrite(pin10,0);
digitalWrite(pin11,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin4,1);
digitalWrite(pin5,1);
digitalWrite(pin6,1);
digitalWrite(pin7,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin4,0);
digitalWrite(pin5,0);
digitalWrite(pin6,0);
digitalWrite(pin7,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin0,1);
digitalWrite(pin1,1);
digitalWrite(pin2,1);
digitalWrite(pin3,1);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
digitalWrite(pin0,0);
digitalWrite(pin1,0);
digitalWrite(pin2,0);
digitalWrite(pin3,0);
for(l=0;l<20;l++)
{
layer(1);
delay(3);
layer(2);
delay(3);
layer(3);
delay(3);
layer(4);
delay(3);
}
}
}
/* This function will get invoked when led state change request is received */
void led_indicator_cb(const char *p_json_string,
uint32_t json_string_datalen,
jsonStruct_t *p_context) {
int state;
if (p_context != NULL) {
state = *(int *)(p_context->pData);
switch (state) {
case 1:{
pattern_1();
break;
}
case 2: {
pattern_2();
break;
}
case 3: {
pattern_3();
break;
}
case 4: {
pattern_4();
break;
}
}
}
}
/* Publish thing state to shadow */
int aws_publish_property_state(ShadowParameters_t *sp)
{
char buf_out[BUFSIZE];
char state[BUFSIZE];
char *ptr = state;
int ret = WM_SUCCESS;
memset(state, 0, BUFSIZE);
/* On receiving led state change notification from cloud, change
* the state of the led on the board in callback function and
* publish updated state on configured topic.
*/
if (led_1_state_prev != led_1_state) {
snprintf(buf_out, BUFSIZE, ",\"%s\":%lu", VAR_LED_1_PROPERTY,
led_1_state);
strcat(state, buf_out);
led_1_state_prev = led_1_state;
}
if (*ptr == ',')
ptr++;
if (strlen(state)) {
snprintf(buf_out, BUFSIZE, "{\"state\": {\"reported\":{%s}}}",
ptr);
wmprintf("Publishing '%s' to AWS\r\n", buf_out);
/* publish incremented value on pushbutton press on
* configured thing */
ret = aws_iot_shadow_update(&mqtt_client,
sp->pMyThingName,
buf_out,
shadow_update_status_cb,
NULL,
10, true);
}
return ret;
}
/* application thread */
static void aws_starter_demo(os_thread_arg_t data)
{
int led_state = 0, ret;
jsonStruct_t led_indicator;
ShadowParameters_t sp;
aws_iot_mqtt_init(&mqtt_client);
ret = aws_starter_load_configuration(&sp);
if (ret != WM_SUCCESS) {
wmprintf("aws shadow configuration failed : %d\r\n", ret);
goto out;
}
ret = aws_iot_shadow_init(&mqtt_client);
if (ret != WM_SUCCESS) {
wmprintf("aws shadow init failed : %d\r\n", ret);
goto out;
}
ret = aws_iot_shadow_connect(&mqtt_client, &sp);
if (ret != WM_SUCCESS) {
wmprintf("aws shadow connect failed : %d\r\n", ret);
goto out;
}
/* indication that device is connected and cloud is started */
led_on(board_led_2());
wmprintf("Cloud Started\r\n");
/* configures property of a thing */
led_indicator.cb = led_indicator_cb;
led_indicator.pData = &led_state;
led_indicator.pKey = "led";
led_indicator.type = SHADOW_JSON_INT8;
/* subscribes to delta topic of the configured thing */
ret = aws_iot_shadow_register_delta(&mqtt_client, &led_indicator);
if (ret != WM_SUCCESS) {
wmprintf("Failed to subscribe to shadow delta %d\r\n", ret);
goto out;
}
while (1) {
/* Implement application logic here */
if (device_state == AWS_RECONNECTED) {
ret = aws_iot_shadow_init(&mqtt_client);
if (ret != WM_SUCCESS) {
wmprintf("aws shadow init failed: "
"%d\r\n", ret);
goto out;
}
ret = aws_iot_shadow_connect(&mqtt_client, &sp);
if (ret != WM_SUCCESS) {
wmprintf("aws shadow reconnect failed: "
"%d\r\n", ret);
goto out;
} else {
device_state = AWS_CONNECTED;
led_on(board_led_2());
ret = aws_iot_shadow_register_delta(
&mqtt_client, &led_indicator);
wmprintf("Reconnected to cloud\r\n");
}
}
aws_iot_shadow_yield(&mqtt_client, 10);
ret = aws_publish_property_state(&sp);
if (ret != WM_SUCCESS)
wmprintf("Sending property failed\r\n");
os_thread_sleep(100);
}
ret = aws_iot_shadow_disconnect(&mqtt_client);
if (NONE_ERROR != ret) {
wmprintf("aws iot shadow error %d\r\n", ret);
}
out:
os_thread_self_complete(NULL);
return;
}
void wlan_event_normal_link_lost(void *data)
{
/* led indication to indicate link loss */
aws_iot_shadow_disconnect(&mqtt_client);
device_state = AWS_DISCONNECTED;
}
void wlan_event_normal_connect_failed(void *data)
{
/* led indication to indicate connect failed */
aws_iot_shadow_disconnect(&mqtt_client);
device_state = AWS_DISCONNECTED;
}
/* This function gets invoked when station interface connects to home AP.
* Network dependent services can be started here.
*/
void wlan_event_normal_connected(void *data)
{
int ret;
/* Default time set to 1 April 2016 */
time_t time = 1459468800;
wmprintf("Connected successfully to the configured network\r\n");
if (!device_state) {
/* set system time */
wmtime_time_set_posix(time);
/* create cloud thread */
...
This file has been truncated, please download it to see its full contents.
crop.jpg?auto=compress%2Cformat&w=40&h=40&fit=min&dpr=2)
crop.jpg?auto=compress%2Cformat&w=60&h=60&fit=min&dpr=2)
Comments