I2CSlave_Demo.cpp

Use an easy I2CSlave class to imitate an I2C slave with address 42

cmake_minimum_required(VERSION 3.12)
find_package(PropWare REQUIRED)
 
project(I2CSlave_Demo)
 
create_simple_executable(${PROJECT_NAME} I2CSlave_Demo.cpp)

 
#include <PropWare/hmi/output/printer.h>
#include <PropWare/serial/i2c/i2cslave.h>
#include <PropWare/serial/i2c/i2cmaster.h>
#include <PropWare/utility/collection/queue.h>
#include <PropWare/gpio/simpleport.h>
 
using PropWare::Queue;
using PropWare::I2CMaster;
using PropWare::I2CSlave;
using PropWare::SimplePort;
using PropWare::Port;
using PropWare::Pin;
using PropWare::Runnable;
 
class MyI2CSlave: public I2CSlave {
    public:
        static const int ADDRESS         = 42;
        static const int SHIFTED_ADDRESS = ADDRESS << 1;
 
    public:
        template<size_t I2C_BUFFER_SIZE, size_t STACK_SIZE, size_t QUEUE_BUFFER_SIZE>
        MyI2CSlave (uint8_t (&buffer)[I2C_BUFFER_SIZE], const uint32_t (&stack)[STACK_SIZE],
                    uint8_t (&queueBuffer)[QUEUE_BUFFER_SIZE])
            : I2CSlave(ADDRESS, buffer, stack),
              m_queue(queueBuffer),
              m_sum(0) {
        }
 
    private:
        void on_request () {
            while (!this->m_queue.is_empty())
                this->m_sum += this->m_queue.dequeue();
            this->write(this->m_sum);
        }
 
        void on_receive () {
            int result;
            while (-1 != (result = this->read()))
                this->m_queue.insert(static_cast<uint8_t>(result));
        }
 
    private:
        Queue<uint8_t> m_queue;
        uint8_t        m_sum;
};
 
int main () {
    uint8_t    buffer[32];
    uint32_t   stack[128];
    uint8_t    queueBuffer[32];
    MyI2CSlave slave(buffer, stack, queueBuffer);
 
    // Start a new cog to monitor the I2C bus and respond to events
    Runnable::invoke(slave);
 
    // Run the master
    I2CMaster master;
 
    // Set the master to a very low frequency. The on_request() and on_receive() methods in this sample are not
    // optimized for high speed communications, and extreme optimizations may be necessary in order to run a synchronous
    // serial bus like I2C in slave mode. Those types of optimizations are beyond the scope of this demo, so we will
    // simply set the frequency low enough that they are unnecessary.
    master.set_frequency(1000);
 
    if (master.ping(MyI2CSlave::SHIFTED_ADDRESS)) {
        pwOut << "ACK received!\n";
 
        pwOut << "Expecting  0: " << master.get(MyI2CSlave::SHIFTED_ADDRESS, static_cast<uint8_t>(0)) << '\n';
        pwOut << "Expecting  1: " << master.get(MyI2CSlave::SHIFTED_ADDRESS, static_cast<uint8_t>(1)) << '\n';
        pwOut << "Expecting  3: " << master.get(MyI2CSlave::SHIFTED_ADDRESS, static_cast<uint8_t>(2)) << '\n';
        pwOut << "Expecting  6: " << master.get(MyI2CSlave::SHIFTED_ADDRESS, static_cast<uint8_t>(3)) << '\n';
        pwOut << "Expecting 10: " << master.get(MyI2CSlave::SHIFTED_ADDRESS, static_cast<uint8_t>(4)) << '\n';
        pwOut << "Expecting 80: " << master.get(MyI2CSlave::SHIFTED_ADDRESS, static_cast<uint16_t>(0x1234)) << '\n';
    } else
        pwOut << "No ack! :(\n I guess we're done.\n";
}