File content as of revision 9:01dfe4fe7d21:

#include "mbed.h"
#include "rtos.h"
#include "ExioMcp23s17.h"
#include "ExioMcp23s17DigitalIn.h"
#include "ExioMcp23s17PinDetect.h"
#include "ExioMcp23s17RotaryEncoder.h"
#include "ExioMcp23s17Keypad4x4.h"

SPI Spi(PC_12, PC_11, PC_10); // SPI3: mosi, miso, sclk
//SPI Spi(PA_7, PA_6, PA_5); // SPI1:  mosi, miso, sclk

// MExioMcp23s17(int hardwareaddress, SPI& spi, PinName nCs, PinName nReset);
ExioMcp23s17 Exio(0x00, Spi, PD_2, PA_13);

/*
void ExioMcp23s17Test()
{
    printf("\r\n\n*** ExioMcp23s17 ***\r\n");

    // Reset MCP23S17
    Exio.reset();
    
    // PORTA output
    Exio.ioDirection(ExioPortA, 0x00);

    // PORTB input
    Exio.ioDirection(ExioPortB, 0xFF);
    // PORTB pull-up
    Exio.ioPullup(ExioPortB, 0xFF);
    // PORTB invert polarity
    Exio.ioPolarity(ExioPortB, 0xFF);
    
    // LED Check (PortA)
    for (int i = 0; i < 8; i++) {
        Exio.writePort(ExioPortA, 1 << i);
        wait(0.1);
    }
    Exio.writePort(ExioPortA, 0x00);
    
    while (true) {
        uint8_t data = Exio.readPort(ExioPortB);
        wait_us(1);
        Exio.writePort(ExioPortA, data);
    }
}
*/
/*
void ExioMcp23s17RevTest()
{
    printf("\r\n\n*** ExioMcp23s17 Rev ***\r\n");

    // Reset MCP23S17
    Exio.reset();
    
    // PORTB output
    Exio.ioDirection(ExioPortB, 0x00);

    // PORTA input
    Exio.ioDirection(ExioPortA, 0xFF);
    // PORTB pull-up
    Exio.ioPullup(ExioPortA, 0xFF);
    // PORTB invert polarity
    Exio.ioPolarity(ExioPortA, 0xFF);
    
    // LED Check (PortB)
    for (int i = 0; i < 8; i++) {
        Exio.writePort(ExioPortB, 1 << i);
        wait(0.1);
    }
    Exio.writePort(ExioPortB, 0x00);
    
    while (true) {
        uint8_t data = Exio.readPort(ExioPortA);
        wait_us(1);
        Exio.writePort(ExioPortB, data);
    }
}
*/
/*
void ExioMcp23s17DigitalInTest()
{
    printf("\r\n\n*** ExioMcp23s17DigitalIn test ***\r\n");
    
    Exio.reset();
    
    // set PORTA as output
    Exio.ioDirection(ExioPortA, 0x00);
    
    // set PORTB as input via ExioDigitalIn
    ExioMcp23s17DigitalIn inB0(Exio, ExioPortB, 0);
    ExioMcp23s17DigitalIn inB1(Exio, ExioPortB, 1);
    ExioMcp23s17DigitalIn inB2(Exio, ExioPortB, 2);
    ExioMcp23s17DigitalIn inB3(Exio, ExioPortB, 3);
    ExioMcp23s17DigitalIn inB4(Exio, ExioPortB, 4);
    ExioMcp23s17DigitalIn inB5(Exio, ExioPortB, 5);
    ExioMcp23s17DigitalIn inB6(Exio, ExioPortB, 6);
    ExioMcp23s17DigitalIn inB7(Exio, ExioPortB, 7);

    inB0.mode(PullUp);
    inB1.mode(PullUp);
    inB2.mode(PullUp);
    inB3.mode(PullUp);
    inB4.mode(PullUp);
    inB5.mode(PullUp);
    inB6.mode(PullUp);
    inB7.mode(PullUp);
    
    // LED Check (PortA)
    for (int i = 0; i < 8; i++) {
        Exio.writePort(ExioPortA, 1 << i);
        wait(0.1);
    }
    Exio.writePort(ExioPortA, 0x00);
    
    while (true) {
        
        // read PORTB via ExioMcp23s17DigitalIn
        uint8_t data = 0;
        data |= inB0.read();
        data |= inB1.read() << 1;
        data |= inB2.read() << 2;
        data |= inB3.read() << 3;
        data |= inB4.read() << 4;
        data |= inB5.read() << 5;
        data |= inB6.read() << 6;
        data |= inB7.read() << 7;

        // write PORTA
        Exio.writePort(ExioPortA, data);
    }
}
*/

/*
// トグル動作
bool pb0state = false;
void pb0Falled() {
    uint8_t data = Exio.readPort(ExioPortA);
    pb0state = !pb0state;
    if (pb0state) {
        data |= (1 << 0);
    } else {
        data &= ~(1 << 0);
    } 
    Exio.writePort(ExioPortA, data);
}

void pb1Falled() {
    Exio.writePort(ExioPortA, (1 << 1));
}

void pb2Falled() {
    Exio.writePort(ExioPortA, (1 << 2));
}

void pb3Falled() {
    Exio.writePort(ExioPortA, (1 << 3));
}

void pb4Falled() {
    Exio.writePort(ExioPortA, (1 << 4));
}

void pb5Falled() {
    Exio.writePort(ExioPortA, (1 << 5));
}

void pb6Falled() {
    Exio.writePort(ExioPortA, (1 << 6));
}

void pb7Falled() {
    Exio.writePort(ExioPortA, (1 << 7));
}
*/

/*
void ExioMcp23s17PinDetectTest()
{
    printf("\r\n\n*** ExioMcp23s17PinDetect test ***\r\n");
    
    Exio.reset();
    
    // set PORTA as output
    Exio.ioDirection(ExioPortA, 0x00);
    
    // create PORTB pins as inputs via ExioMcp23s17PinDetect
    ExioMcp23s17PinDetect PinB0(Exio, ExioPortB, 0);
    ExioMcp23s17PinDetect PinB1(Exio, ExioPortB, 1);
    ExioMcp23s17PinDetect PinB2(Exio, ExioPortB, 2);
    ExioMcp23s17PinDetect PinB3(Exio, ExioPortB, 3);
    ExioMcp23s17PinDetect PinB4(Exio, ExioPortB, 4);
    ExioMcp23s17PinDetect PinB5(Exio, ExioPortB, 5);
    ExioMcp23s17PinDetect PinB6(Exio, ExioPortB, 6);
    ExioMcp23s17PinDetect PinB7(Exio, ExioPortB, 7);

    // assign callback functions
    PinB0.attach_asserted(&pb0Falled);
    PinB0.setAssertValue(0);
    PinB0.setSampleFrequency();
    
    PinB1.attach_asserted(&pb1Falled);
    PinB1.setAssertValue(0);
    PinB1.setSampleFrequency();
    
    PinB2.attach_asserted(&pb2Falled);
    PinB2.setAssertValue(0);
    PinB2.setSampleFrequency();
    
    PinB3.attach_asserted(&pb3Falled);
    PinB3.setAssertValue(0);
    PinB3.setSampleFrequency();
    
    PinB4.attach_asserted(&pb4Falled);
    PinB4.setAssertValue(0);
    PinB4.setSampleFrequency();
    
    PinB5.attach_asserted(&pb5Falled);
    PinB5.setAssertValue(0);
    PinB5.setSampleFrequency();
    
    PinB6.attach_asserted(&pb6Falled);
    PinB6.setAssertValue(0);
    PinB6.setSampleFrequency();
    
    PinB7.attach_asserted(&pb7Falled);
    PinB7.setAssertValue(0);
    PinB7.setSampleFrequency();
    

    // LED Check (PortA)
    for (int i = 0; i < 8; i++) {
        Exio.writePort(ExioPortA, 1 << i);
        wait(0.1);
    }
    Exio.writePort(ExioPortA, 0x00);
    
    while (true) {
    }
}
*/

/*
void ExioMcp23s17PinDetectPullModeTest()
{
    printf("\r\n\n*** ExioMcp23s17PinDetect PullMode test ***\r\n");
    
    Exio.reset();
    
    // set PORTA as output
    Exio.ioDirection(ExioPortA, 0x00);
    
    // create PORTB pins as inputs via ExioMcp23s17PinDetect
    ExioMcp23s17PinDetect PinB0(Exio, ExioPortB, 0, PullUp);
    ExioMcp23s17PinDetect PinB1(Exio, ExioPortB, 1, PullNone);
    ExioMcp23s17PinDetect PinB2(Exio, ExioPortB, 2, PullUp);
    ExioMcp23s17PinDetect PinB3(Exio, ExioPortB, 3, PullNone);
    ExioMcp23s17PinDetect PinB4(Exio, ExioPortB, 4, PullUp);
    ExioMcp23s17PinDetect PinB5(Exio, ExioPortB, 5, PullNone);
    ExioMcp23s17PinDetect PinB6(Exio, ExioPortB, 6, PullUp);
    ExioMcp23s17PinDetect PinB7(Exio, ExioPortB, 7, PullNone);
    
    PinB1.mode(PullUp);
    PinB3.mode(PullUp);
    PinB5.mode(PullUp);
    PinB7.mode(PullUp);

    //PinB7.mode(PullDown);

    // assign callback functions
    PinB0.attach_asserted(&pb0Falled);
    PinB0.setAssertValue(0);
    PinB0.setSampleFrequency();
    
    PinB1.attach_asserted(&pb1Falled);
    PinB1.setAssertValue(0);
    PinB1.setSampleFrequency();
    
    PinB2.attach_asserted(&pb2Falled);
    PinB2.setAssertValue(0);
    PinB2.setSampleFrequency();
    
    PinB3.attach_asserted(&pb3Falled);
    PinB3.setAssertValue(0);
    PinB3.setSampleFrequency();
    
    PinB4.attach_asserted(&pb4Falled);
    PinB4.setAssertValue(0);
    PinB4.setSampleFrequency();
    
    PinB5.attach_asserted(&pb5Falled);
    PinB5.setAssertValue(0);
    PinB5.setSampleFrequency();
    
    PinB6.attach_asserted(&pb6Falled);
    PinB6.setAssertValue(0);
    PinB6.setSampleFrequency();
    
    PinB7.attach_asserted(&pb7Falled);
    PinB7.setAssertValue(0);
    PinB7.setSampleFrequency();
    

    // LED Check (PortA)
    for (int i = 0; i < 8; i++) {
        Exio.writePort(ExioPortA, 1 << i);
        wait(0.1);
    }
    Exio.writePort(ExioPortA, 0x00);
    
    while (true) {
    }
}
*/
/*
void ExioMcp23s17RotaryEncoderTest()
{
    printf("\r\n\n*** ExioMcp23s17RotaryEncoder test ***\r\n");
    
    Exio.reset();
    
    // set PORTA as output
    Exio.ioDirection(ExioPortA, 0x00);
    
    // LED Check (PortA)
    for (int i = 0; i < 8; i++) {
        Exio.writePort(ExioPortA, 1 << i);
        wait(0.2);
    }
    Exio.writePort(ExioPortA, 0x00);

    // set PORTB[0..1] as RotaryEncoder
    
    //    ExioMcp23s17RotaryEncoder(
    //    ExioMcp23s17& device, ExioPort port, int pin1, int pin2,
    //    int min = 0, int max = 100, int val = 50
    //);
    
    ExioMcp23s17RotaryEncoder RotEnc1(Exio, ExioPortB, 0, 1, 0, 0x0f, 0);
    
    // set PORTB[2..3] as RotaryEncoder
    //RotaryEncoder::RotaryEncoder(ExioMcp23s17DigitalIn& _pin1, ExioMcp23s17DigitalIn& _pin2, int min, int max, int val)
    ExioMcp23s17RotaryEncoder RotEnc2(Exio, ExioPortB, 2, 3, 0, 0x0f, 0);
    
    while (true) {
        int v1 = RotEnc1.getVal();
        int v2 = RotEnc2.getVal();
        uint8_t data = ((uint8_t)v2 << 4) | (uint8_t)v1;
        //Exio.writePort(ExioPortA, data);
        printf("%d %d\r\n", v1, v2);
        Thread::wait(10);
    }
}
*/

void ExioMcp23s17Keypad4x4Test()
{
    printf("\r\n\n*** ExioMcp23s17Keypad4x4 test ***\r\n");
    
    Exio.reset();
    
    // set PORTB as output
    Exio.ioDirection(ExioPortB, 0x00);
    
    // LED Check (PortB)
    for (int i = 0; i < 8; i++) {
        Exio.writePort(ExioPortB, 1 << i);
        wait(0.2);
    }
    Exio.writePort(ExioPortB, 0x00);
    
    // set PORTA as Keypad 4x4
    ExioMcp23s17Keypad4x4 keypad(Exio, ExioPortA);
    
    while (true) {
        int v = keypad.keyScan();
        //printf("%d\r\n", v);
        if (v != -1) {
            Exio.writePort(ExioPortB, v);
        }
    }
}

int main()
{
    //ExioMcp23s17Test();
    //ExioMcp23s17RevTest();
    //ExioMcp23s17DigitalInTest();
    //ExioMcp23s17PinDetectTest();
    //ExioMcp23s17PinDetectPullModeTest();
    //ExioMcp23s17RotaryEncoderTest();
    ExioMcp23s17Keypad4x4Test();
}