マイコンを活用したリーズナブルなお花の自動水やり機

#ifndef MAIN_XTASKSENSOR_H_
#define MAIN_XTASKSENSOR_H_
void xTaskSensor(void *pvParameters);
#endif /* MAIN_XTASKSENSOR_H_ */

#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include <math.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include <driver/spi_master.h>
#include <driver/gpio.h>
#include "esp_log.h"
#include "xtask_sensor.h"
#include "driver/gpio.h"
#include "driver/adc.h"
#include "shadow_demo_helpers.h"
#include "core_mqtt.h"

#include "xtask_pump.h"
#define TAG "xTaskSensor"

static MQTTPublishInfo_t publishInfo = {0};

static uint16_t GetMoisture()
{
       uint16_t moisture = adc1_get_raw(ADC1_CHANNEL_4); // GROVE端子を使用 GP32
    return moisture;
}

static void PublishMoisuture(uint16_t moisture)
{
    MQTTContext_t *pMqttContext;
    MQTTStatus_t status;
    uint16_t packetId;
    static char payload[50];
    memset(payload, 0x00, sizeof(payload));
    
    // This context is assumed to be initialized and connected.
    pMqttContext = GetMqttContext();
    LogInfo( ( "publishPumpState pContext(4): %p", pMqttContext) );    
    LogInfo( ( "publishPumpState pContext->getTime(4): %p", pMqttContext->getTime ) );

    // QoS of publish.
    publishInfo.qos = MQTTQoS0;
    publishInfo.pTopicName = "watering-machine/state";
    publishInfo.topicNameLength = strlen(publishInfo.pTopicName);
    sprintf(payload, "{\"moisture\":%d}", moisture);
    publishInfo.pPayload = payload;
    publishInfo.payloadLength = strlen(payload);

    // Packet ID is needed for QoS > 0.
    packetId = MQTT_GetPacketId(pMqttContext);
    LogInfo(("PublishMoisuture Packet ID: %u !!", packetId));

    status = MQTT_Publish(pMqttContext, &publishInfo, packetId);
    LogInfo(("Publish Result: %u.", status));
}

void xTaskSensor(void *pvParameters)
{
    uint16_t moisture = 0;

    while (1)
    {
        ESP_LOGI(TAG, "xTaskSensor is running...");
        moisture = GetMoisture();
        ESP_LOGI(TAG, "Moisture: %u", moisture);

        PublishMoisuture(moisture);
        vTaskDelay(5000 / portTICK_PERIOD_MS);
    }
}

#ifndef MAIN_XTASKPUMP_H_
#define MAIN_XTASKPUMP_H_
#include "core_mqtt.h"
void xTaskPump(void *pvParameters);
void eventCallback( MQTTContext_t * pMqttContext,
                    MQTTPacketInfo_t * pPacketInfo,
                    MQTTDeserializedInfo_t * pDeserializedInfo );
#define PUMP_ON     1
#define PUMP_OFF    0
#endif /* MAIN_XTASKPUMP_H_ */

#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include <math.h>

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#include <driver/gpio.h>
#include "esp_log.h"
#include "shadow_demo_helpers.h"
#include "shadow.h"
#include "core_json.h"

#include "xtask_pump.h"

#define TAG "xTaskPump"

extern gpio_num_t PUMP_GPIO;
static uint8_t desiredPumpState = PUMP_OFF;
static MQTTPublishInfo_t publishInfo = {0};
static MQTTSubscribeInfo_t pSubscriptionList[1];

static void ControlPump(uint8_t pump_state)
{
    gpio_set_level(PUMP_GPIO, pump_state);
}

static void updateDeltaHandler(MQTTPublishInfo_t *pPublishInfo)
{
    char *outValue = NULL;
    uint32_t outValueLength = 0U;
    JSONStatus_t result = JSONSuccess;

    assert(pPublishInfo != NULL);
    assert(pPublishInfo->pPayload != NULL);

    LogInfo(("/update/delta json payload:%s.", (const char *)pPublishInfo->pPayload));

    /* Make sure the payload is a valid json document. */
    result = JSON_Validate((const char *)pPublishInfo->pPayload,
                           pPublishInfo->payloadLength);

    if (result == JSONSuccess)
    {
        /* Get powerOn state from json documents. */
        result = JSON_Search((char *)pPublishInfo->pPayload,
                             pPublishInfo->payloadLength,
                             "state.pumpOn",
                             sizeof("state.pumpOn") - 1,
                             &outValue,
                             (size_t *)&outValueLength);
    }
    else
    {
        LogError(("The json document is invalid!!"));
    }

    if (result == JSONSuccess)
    {
        /* Convert the powerOn state value to an unsigned integer value. */
        desiredPumpState = (uint8_t)strtoul(outValue, NULL, 10);
        LogInfo(("The new pumpOn state desiredPumpState:%" PRIu8 " \r\n",
                 desiredPumpState));
    }
    else
    {
        LogError(("pumpOn value does not exist in the message."));
    }
}

void eventCallback(MQTTContext_t *pMqttContext,
                          MQTTPacketInfo_t *pPacketInfo,
                          MQTTDeserializedInfo_t *pDeserializedInfo)
{
    LogInfo(("eventCallback is running"));

    ShadowMessageType_t messageType = ShadowMessageTypeMaxNum;
    const char *pThingName = NULL;
    uint8_t thingNameLength = 0U;
    const char *pShadowName = NULL;
    uint8_t shadowNameLength = 0U;

    (void)pMqttContext;

    assert(pDeserializedInfo != NULL);
    assert(pMqttContext != NULL);
    assert(pPacketInfo != NULL);

    if ((pPacketInfo->type & 0xF0U) == MQTT_PACKET_TYPE_PUBLISH)
    {
        assert(pDeserializedInfo->pPublishInfo != NULL);
        LogInfo(("pPublishInfo->pTopicName:%s.", pDeserializedInfo->pPublishInfo->pTopicName));

        /* Let the Device Shadow library tell us whether this is a device shadow message. */
        if (SHADOW_SUCCESS == Shadow_MatchTopicString(pDeserializedInfo->pPublishInfo->pTopicName,
                                                      pDeserializedInfo->pPublishInfo->topicNameLength,
                                                      &messageType,
                                                      &pThingName,
                                                      &thingNameLength,
                                                      &pShadowName,
                                                      &shadowNameLength))
        {
            /* Upon successful return, the messageType has been filled in. */
            if (messageType == ShadowMessageTypeUpdateDelta)
            {
                /* Handler function to process payload. */
                updateDeltaHandler(pDeserializedInfo->pPublishInfo);
            }
            else
            {
                LogInfo(("Other Shadow message type:%d !!", messageType));
            }
        }
        else
        {
            LogError(("Shadow_MatchTopicString parse failed:%s !!", (const char *)pDeserializedInfo->pPublishInfo->pTopicName));
        }
    }
    else
    {
        LogInfo(("Other MQTT message type:%d !!", pPacketInfo->type));
    }
}

static void PublishPumpState(uint8_t pump_state)
{
    MQTTContext_t *pMqttContext;
    MQTTStatus_t status;
    uint16_t packetId;
    static char payload[50];
    memset(payload, 0x00, sizeof(payload));

    pMqttContext = GetMqttContext();
    publishInfo.qos = MQTTQoS0;
    publishInfo.pTopicName = "$aws/things/m5stickc-plus/shadow/update";
    publishInfo.topicNameLength = strlen(publishInfo.pTopicName);
    sprintf(payload, "{\"state\":{\"reported\": {\"pumpOn\": %d}}}", pump_state);
    publishInfo.pPayload = payload;
    publishInfo.payloadLength = strlen(payload);

    packetId = MQTT_GetPacketId(pMqttContext);
    status = MQTT_Publish(pMqttContext, &publishInfo, packetId);
    LogInfo(("Publish Result: %u.", status));
}

static MQTTStatus_t SubscribePumpDelta(void)
{
    MQTTContext_t *pMqttContext;
    MQTTStatus_t mqttStatus;
    uint16_t subscribePacketId;
    const char *TopicFilter = "$aws/things/m5stickc-plus/shadow/update/delta";
    uint16_t topicFilterLength = strlen(TopicFilter);

    pMqttContext = GetMqttContext();

    pSubscriptionList[0].qos = MQTTQoS0;
    pSubscriptionList[0].pTopicFilter = TopicFilter;
    pSubscriptionList[0].topicFilterLength = topicFilterLength;

    /* Generate packet identifier for the SUBSCRIBE packet. */
    subscribePacketId = MQTT_GetPacketId(pMqttContext);

    /* Send SUBSCRIBE packet. */
    mqttStatus = MQTT_Subscribe(pMqttContext,
                                pSubscriptionList,
                                sizeof(pSubscriptionList) / sizeof(MQTTSubscribeInfo_t),
                                subscribePacketId);
    return mqttStatus;
}

void xTaskPump(void *pvParameters)
{
    uint8_t pump_state = PUMP_OFF;
    MQTTStatus_t mqttStatus;
    MQTTContext_t *pMqttContext;

    /* 初期設定はポンプ OFF */
    ControlPump(pump_state);

    /* Shadow の Delta を Subscribe */
    mqttStatus = SubscribePumpDelta();

    /* MQTTのContextを取得 */
    pMqttContext = GetMqttContext();
    /* ポンプの初期状態を Shadow に Report */
    PublishPumpState(pump_state);

    while (1)
    {
        vTaskDelay(500 / portTICK_PERIOD_MS);

        mqttStatus = MQTT_ReceiveLoop(pMqttContext);
        ESP_LOGI(TAG, "xTaskPump: MQTT_ReceiveLoop status is %s \r\n", MQTT_Status_strerror(mqttStatus));

        if (pump_state != desiredPumpState)
        {
            pump_state = desiredPumpState;
            ControlPump(pump_state);
            PublishPumpState(pump_state);
        }
    }
}

examples/thing_shadow/main/app_main.c

void app_main()
{
    
    /* 省略 */
    
    /* 下記の関数呼び出しをコメントアウトし、それ以降のコードを追記 */
    /* aws_iot_demo_main(0,NULL); */
    
    int returnStatus = EXIT_SUCCESS;

    /* GPIOの設定関数を呼び出し */
    SetupGpio();
    
    do 
    {
        /* MQTTセッションを確立 */
        returnStatus = EstablishMqttSession(eventCallback);

        if(returnStatus == EXIT_FAILURE)
        {
            LogError( ( "Failed to connect to MQTT broker." ) );
        }
        else
        {
            /* 2つのタスクを作成する */
            xTaskCreate(xTaskPump, "TaskPump", 1024*6, NULL, 2, NULL);
            xTaskCreate(xTaskSensor, "TaskSensor", 1024*6, NULL, 2, NULL);
        }
    } while(returnStatus != EXIT_SUCCESS);
}