pimoroni-pico/examples/pico_wireless/cheerlights.cpp

#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/uart.h"
#include "hardware/gpio.h"
#include "hardware/spi.h"
#include "pico_wireless.hpp"
#include "secrets.h"

#include <vector>
#include <algorithm>

#define HTTP_PORT 80
#define HTTP_REQUEST_BUF_SIZE 2048

#define DNS_CLOUDFLARE IPAddress(1, 1, 1, 1)
#define DNS_GOOGLE IPAddress(8, 8, 8, 8)
#define USE_DNS DNS_CLOUDFLARE

#define HTTP_REQUEST_DELAY 30  // Seconds between requests
#define HTTP_REQUEST_HOST "api.thingspeak.com"
#define HTTP_REQUEST_PATH "/channels/1417/field/2/last.txt"
#define HTTP_RESPONSE_BUF_SIZE 1024

using namespace pimoroni;

PicoWireless wireless;
uint8_t r, g, b;
uint8_t response_buf[HTTP_RESPONSE_BUF_SIZE];
typedef void(*http_handler)(unsigned int status_code, std::vector<std::string_view> response_head, std::vector<std::string_view> esponse_body);

enum HTTP_REQUEST_STATUS {
    HTTP_REQUEST_OK = 0,
    HTTP_REQUEST_TIMEOUT,
    HTTP_REQUEST_RESPONSE_INVALID,
    HTTP_REQUEST_RESPONSE_UNHANDLED,
    HTTP_REQUEST_CONNECTION_FAILED,
    HTTP_REQUEST_RESPONSE_OVERFLOW,
    HTTP_REQUEST_NO_RESPONSE
};

std::vector<std::string_view> split(std::string_view str, std::string delim="\r\n") {
    std::vector<std::string_view> result;
    size_t offset = 0;
    while (offset < str.size()) {
        const auto pos = str.find_first_of(delim, offset);
        // Emit an empty view even if two adjacent delimiters are found
        // this ensurs the HTTP "blank line" start of content is found
        result.emplace_back(str.substr(offset, pos - offset));
        if (pos == std::string_view::npos) break;
        offset = pos + delim.length();
    }
    return result;
}

uint32_t millis() {
    return to_us_since_boot(get_absolute_time()) / 1000;
}

bool wifi_connect(std::string network, std::string password, IPAddress dns_server, uint32_t timeout=10000) {
    printf("Connecting to %s...\n", network.c_str());
    wireless.wifi_set_passphrase(network, password);

    uint32_t t_start = millis();

    while(millis() - t_start < timeout) {
        if(wireless.get_connection_status() == WL_CONNECTED) {
            printf("Connected!\n");
            wireless.set_dns(1, dns_server, 0);
            return true;
        }
        wireless.set_led(255, 0, 0);
        sleep_ms(500);
        wireless.set_led(0, 0, 0);
        sleep_ms(500);
        printf("...\n");
    }

    return false;
}

/* Basic function to connect to a client IP:PORT and poll for an established connection */
bool connect(IPAddress host_address, uint16_t port, uint8_t client_sock, uint32_t timeout = 1000) {
    wireless.start_client(host_address, port, client_sock, TCP_MODE);

    uint32_t t_start = millis();

    while(millis() - t_start < timeout) {
        uint8_t state = wireless.get_client_state(client_sock);
        if(state == ESTABLISHED) return true;
        sleep_ms(100);
    }

    return false;
}

/* Basic DNS lookup */
IPAddress dns_lookup(std::string request_host) {
    IPAddress host_address(0, 0, 0, 0);
    printf("DNS lookup for: %s\n", request_host.c_str());
    if(!wireless.get_host_by_name(request_host.c_str(), host_address)) {
        printf("DNS lookup failed!\n");
    }
    return host_address;
}

/* This is pretty much the simplest HTTP request function I could get away with.
   It accepts a client socket ID, IP address, hostname, request path and handler function,
   and calls the handler with the status code (only 200 & 404 at the moment), head
   and body as `std::vector<std::string_view>` into the underlying buffer.
 */
HTTP_REQUEST_STATUS http_request(uint8_t client_sock, IPAddress host_address, uint16_t port, std::string request_host, std::string request_path, http_handler handler, uint32_t timeout = 1000) {
    if(!connect(host_address, port, client_sock)) {
        printf("Connection failed!\n");
        return HTTP_REQUEST_CONNECTION_FAILED;
    }

    // HTTP request to grab our API endpoint
    const std::string http_request = "GET " + request_path + " HTTP/1.1\r\n\
Host: " + request_host + "\r\n\
Connection: close\r\n\r\n";

    // Clear the response buffer
    memset(response_buf, 0, HTTP_RESPONSE_BUF_SIZE);

    wireless.send_data(client_sock, (const uint8_t *)http_request.data(), http_request.length());

    uint16_t response_length = 0;
    uint16_t avail_length = 0;
    uint32_t t_start = millis();

    // Keep receiving data until our designated timeout
    // There's no guarantee that `wireless.avail_data` will have the *whole* response in one shot
    // and I *really* don't want to parse the HTTP response for a `Content-Length` header.
    while(millis() - t_start < timeout) {
        sleep_ms(50);
        avail_length = wireless.avail_data(client_sock);
        if(avail_length > 0) break;
    }

    // Read the full response
    // Sometimes the bytes read is less than the bytes we request, so loop until we get the data we expect
    while(response_length < avail_length) {
        uint16_t read_length = avail_length; // Request the full buffer
        wireless.get_data_buf(client_sock, response_buf + response_length, &read_length);
        response_length += read_length; // Increment the response_length by the amount we actually read

        // Also check for timeouts here, too
        if(millis() - t_start >= timeout) break;
    }

    // Explicitly stop our client, and don't leave it dangling!
    wireless.stop_client(client_sock);

    // Bail if we timed out.
    if(millis() - t_start >= timeout) return HTTP_REQUEST_TIMEOUT;

    if(response_length > 0) {
        std::vector<std::string_view> response = split(std::string_view((char *)response_buf, response_length));
        std::vector<std::string_view> response_body;
        uint32_t status_code = 0;

        // Bail early on an invalid HTTP request
        if(response[0].compare(0, 8, "HTTP/1.1") != 0) return HTTP_REQUEST_RESPONSE_INVALID;

        // Scan for the blank line indicating content start
        auto body_start = std::find(response.begin(), response.end(), "");

        // Split the body from the head (ow!)
        if(body_start != response.end()) {
            response_body = std::vector<std::string_view>(body_start + 1, response.end());
            response = std::vector<std::string_view>(response.begin(), body_start);
        }

        // Parse out the HTTP status code
        status_code = std::stoul(std::string(response[0].substr(9, 12)), nullptr);

        if(status_code != 0) {
            handler(status_code, response, response_body);
            return HTTP_REQUEST_OK;
        }

        return HTTP_REQUEST_RESPONSE_UNHANDLED;
    }

    return HTTP_REQUEST_NO_RESPONSE;
}

/* As above, but does DNS resolving for us, probably don't use this... */
int http_request(uint8_t client_sock, std::string request_host, uint16_t port, std::string request_path, http_handler handler, uint32_t timeout = 1000) {
    IPAddress host_address = dns_lookup(request_host);
    return http_request(client_sock, host_address, port, request_host, request_path, handler, timeout);
}

int main() {
    stdio_init_all(); 

    wireless.init();
    sleep_ms(500);

    printf("Firmware version Nina %s\n", wireless.get_fw_version());

    if(!wifi_connect(NETWORK, PASSWORD, USE_DNS)) {
        return 0;
    }

    g = 255;
    wireless.set_led(r, g, b);

    // Get a free client socket
    uint8_t client_sock = wireless.get_socket();

    // Be a good DNS citizen and cache our lookup
    IPAddress host_address = dns_lookup(HTTP_REQUEST_HOST);

    while(1) {
        printf("Requesting: %s\n", HTTP_REQUEST_PATH);

        HTTP_REQUEST_STATUS status = http_request(client_sock, host_address, HTTP_PORT, HTTP_REQUEST_HOST, HTTP_REQUEST_PATH, []( 
            unsigned int status_code,
            std::vector<std::string_view> response_head,
            std::vector<std::string_view> response_body) {
            // Check for valid status
            if(status_code != 200) return;
            // Check for empty body
            if(response_body.size() == 0) return;
            // Check for our 7 chars "#000000"
            if(response_body[0].length() != 7) return;
            // Check for at least a *hopefully* valid hex colour
            if(response_body[0].compare(0, 1, "#") != 0) return;

            // Convert the hex colour to an unsigned int
            uint32_t rgb = std::stoul(std::string(response_body[0].substr(1)), nullptr, 16);

            // Unpack to RGB
            r = (rgb >> 16) & 0xff;
            g = (rgb >> 8) & 0xff;
            b = (rgb >> 0) & 0xff;
            printf("RGB: %i %i %i\n", r, g, b);
            wireless.set_led(r, g, b);
        });

        if(status == HTTP_REQUEST_NO_RESPONSE) {
            printf("No response :(\n");
        }

        if(status == HTTP_REQUEST_TIMEOUT) {
            printf("Request timed out :(\n");
        }

        if(status == HTTP_REQUEST_RESPONSE_UNHANDLED) {
            // Something unexpected happened!
        }

        sleep_ms(HTTP_REQUEST_DELAY * 1000); // Sensible delay
    }

    return 0;
}