CSC Beispiel mit Bluetoe

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Hallo,
nach dem Bluetoe (Beitrag "Open Source Bluetooth LE GATT Server") jetzt so 
weit ist, dass man damit funktionierende Bluetooth LE peripherals auf 
nrf51422s implementieren kann, habe ich mal das Cycling Speed and 
Cadence Profil als Library Funktionalität umgesetzt und damit ein 
kleines Beispiel gebastelt:

#include <bluetoe/bindings/nrf51.hpp>
#include <bluetoe/services/csc.hpp>
#include <bluetoe/server.hpp>
#include <bluetoe/sensor_location.hpp>
#include <nrf.h>

struct handler {

    /*
     * Functions required by the bluetoe CSC implementation to support wheel and crank revolutions
     */
    std::pair< std::uint32_t, std::uint16_t > cumulative_wheel_revolutions_and_time()
    {
        return std::make_pair( wheel_revolutions_, last_wheel_event_time_ );
    }

    std::pair< std::uint16_t, std::uint16_t > cumulative_crank_revolutions_and_time()
    {
        return std::make_pair( crank_revolutions_, last_crank_event_time_ );
    }

    void set_cumulative_wheel_revolutions( std::uint32_t new_value );

    volatile std::uint32_t wheel_revolutions_;
    volatile std::uint16_t last_wheel_event_time_;

    volatile std::uint32_t crank_revolutions_;
    volatile std::uint16_t last_crank_event_time_;
};

static constexpr char server_name[] = "Gruener Blitz";

using bicycle = bluetoe::server<
    bluetoe::server_name< server_name >,
    bluetoe::appearance::cycling_speed_and_cadence_sensor,
    bluetoe::cycling_speed_and_cadence<
        bluetoe::sensor_location::hip,
        bluetoe::csc::wheel_revolution_data_supported,
        bluetoe::csc::crank_revolution_data_supported,
        bluetoe::csc::handler< handler >
    >
>;

bicycle gatt;

void handler::set_cumulative_wheel_revolutions( std::uint32_t new_value )
{
    wheel_revolutions_ = new_value;
    gatt.confirm_cumulative_wheel_revolutions( gatt );
}

bluetoe::nrf51< bicycle > server;

void init_bike_hardware();

int main()
{
    init_bike_hardware();

    for ( ;; )
        server.run( gatt );
}
// ab hier kommt der nrf51 hardware-Teil: https://github.com/TorstenRobitzki/bluetoe/blob/master/examples/nrf51/cycling_speed_and_cadence.cpp

Die Definition des Servers steckt in dem Typen bicycle. Meinungen?

mfg Torsten

[Torsten R. (Firma: Torrox.de) (torstenrobitzki)]

Und hier ein noch kleineres Beispiel, mit dem man einfach eine LED via 
Bluetooth an und aus schalten kann:

#include <bluetoe/server.hpp>
#include <bluetoe/bindings/nrf51.hpp>
#include <nrf.h>

using namespace bluetoe;

static constexpr int io_pin = 19;

static std::uint8_t io_pin_write_handler( bool state )
{
    NRF_GPIO->OUT = state
        ? NRF_GPIO->OUT | ( 1 << io_pin )
        : NRF_GPIO->OUT & ~( 1 << io_pin );

    return error_codes::success;
}

typedef server<
    service<
        service_uuid< 0xC11169E1, 0x6252, 0x4450, 0x931C, 0x1B43A318783B >,
        characteristic<
            free_write_handler< bool, io_pin_write_handler >
        >
    >
> blinky_server;

blinky_server gatt;

nrf51< blinky_server > gatt_srv;

int main()
{
    // Init GPIO pin
    NRF_GPIO->PIN_CNF[ io_pin ] =
        ( GPIO_PIN_CNF_DRIVE_S0H1 << GPIO_PIN_CNF_DRIVE_Pos ) |
        ( GPIO_PIN_CNF_DIR_Output << GPIO_PIN_CNF_DIR_Pos );

    for ( ;; )
        gatt_srv.run( gatt );
}