pca9555 io port expander hoe 1 enkel uitgang te wijzigen zonder andere te wijzig

i kan wel 256 worden en het zijn 2 bytes. (het is een INT. en geen byte. en wat gebeurt er als available > 2?

shooter: i kan wel 256 worden en het zijn 2 bytes. (het is een INT. en geen byte. en wat gebeurt er als available > 2?

Op zich gaat die write(0 wel goed. Is inderdaad niet juist. Write() schrijft alleen de LSB weg.

Available zou maar 2 bytes moeten teruggeven omdat ik ook om 2 bytes vraag. Maar er is een chip onderweg naar mij dus dan kan ik hier test en die class afmaken en op GITHUB zetten.

Nou het heeft ff geduurd, maar bijgaand de werkende lib:

/**
 * @file    clsPCA9555.cpp
 * @author     Nico Verduin
 * @date      9-8-2015
 *
 * @mainpage  clsPCA9555
 * Class to enable pinMode(), digitalRead() and digitalWrite() functions on PCA9555 IO expanders
 *
 *
 * @par Version Control
 * | Revision     | Author         | Date         |
 * | :-------     | :-----         | :----        |
 * | $Revision$ | $Author$         | $Date$     |
 *
 *
 * @par License info
 *
 * Class to enable the use of single pins on PCA9555 IO Expander using
 * pinMode(), digitalRead() and digitalWrite().
 *
 * Copyright (C) 2015  Nico Verduin
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Program : clsPCA9555  Copyright (C) 2015  Nico Verduin
 * This is free software, and you are welcome to redistribute it.
 *
 */

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#include "clsPCA9555.h"
#include "Wire.h"

/**
 * @name PCA9555 constructor
 * @param address I2C address of the IO Expander
 * Creates the class interface and sets the I2C Address of the port
 */
PCA9555::PCA9555(uint8_t address) {
    _address = address;        // save the address id
    _valueRegister = 0;
    Wire.begin();            // start I2C communication
}

/**
 * @name pinMode
 * @param pin        pin number
 * @param IOMode    mode of pin INPUT or OUTPUT
 * sets the mode of this IO pin
 */
void PCA9555::pinMode(uint8_t pin, uint8_t IOMode) {

    //
    // check if valid pin first
    //
    if (pin <= 15) {
        //
        // now set the correct bit in the configuration register
        //
        if (IOMode == OUTPUT) {
            //
            // mask correct bit to 0 by inverting x so that only
            // the correct bit is LOW. The rest stays HIGH
            //
            _configurationRegister = _configurationRegister & ~(1 << pin);
        } else {
            //
            // or just the required bit to 1
            //
            _configurationRegister = _configurationRegister | (1 << pin);
        }
        //
        // write configuration register to chip
        //
        Wire.beginTransmission(_address);              // setup direction register
        Wire.write(NXP_CONFIG);
        Wire.write(_configurationRegister_low);
        Wire.write(_configurationRegister_high);
        _error = Wire.endTransmission();
    }
}
/**
 * @name digitalRead Reads the high/low value of specified pin
 * @param pin
 * @return value of pin
 */
uint8_t PCA9555::digitalRead(uint8_t pin) {
    uint16_t _inputData = 0;
    //
    // we wil only process pins <= 15
    //
    if (pin <= 15) {
        //
        // read the address input register
        //
        Wire.beginTransmission(_address);          // setup read registers
        Wire.write(NXP_INPUT);
        _error = Wire.endTransmission();
        //
        // ask for 2 bytes to be returned
        //
        Wire.requestFrom((int)_address, 2);
        //
        // wait until they are ready
        //
        while(Wire.available() != 2){};
        //
        // read both bytes
        //
        _inputData = Wire.read();
        _inputData |= Wire.read() << 8;
        //
        // now mask the bit required and see if it is a HIGH
        //
        if ((_inputData & (1 << pin)) > 0){
            //
            // the bit is HIGH otherwise we would return a LOW value
            //
            return HIGH;
        } else {
            return LOW;
        }
    } else {
        //
        // invalid pin. Basically this should never be returned as it shows
        // lack of insight waht you are programming with
        //
        return 255;
    }
}

void PCA9555::digitalWrite(uint8_t pin, uint8_t value) {

    uint16_t valueToSend;

    //
    // check valid pin first
    //
    if (pin <= 15) {
        //
        // next convert the value we want to set to HIGH or LOW
        //
        if (value > 0){
            valueToSend = HIGH;
        } else {
            valueToSend = LOW;
        }
        //
        // next set the bit we want to set
        // if the value is LOW we will and the register value with correct bit set to zero
        // if the value is HIGH we will or the register value with correct bit set to HIGH
        //
        if (valueToSend == HIGH) {
            //
            // this is a High value so we will or it with the value register
            //
            _valueRegister = _valueRegister | (1 << pin);    // and OR bit in register
        } else {
            //
            // this is a LOW value so we have to AND it with 0 into the _valueRegister
            //
            _valueRegister = _valueRegister & ~(1 << pin);    // AND all bits
        }

        //
        // write output register to chip
        //
        Wire.beginTransmission(_address);              // setup direction registers
        Wire.write(NXP_OUTPUT);                              // pointer to configuration register address 0
        Wire.write(_valueRegister_low);              // write config register low byte
        Wire.write(_valueRegister_high);              // write config register high byte
        _error = Wire.endTransmission();
    }
}

en include file

/*
 * clsPCA9555.h
 *
 *  Created on: 27 jul. 2015
 *      Author: Nico
 */

#ifndef CLSPCA9555_H_
#define CLSPCA9555_H_

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#define DEBUG 1

/** enum with names of ports ED0 - ED15 */
enum {
    ED0, ED1, ED2 , ED3 , ED4 , ED5 , ED6 , ED7 ,
    ED8, ED9, ED10, ED11, ED12, ED13, ED14, ED15
};

//
// PCA9555 defines
//
#define NXP_INPUT      0
#define NXP_OUTPUT     2
#define NXP_INVERT     4
#define NXP_CONFIG     6

class PCA9555 {
public:
    PCA9555(uint8_t address);                            // constructor
    void pinMode(uint8_t pin, uint8_t IOMode );            // pinMode
    uint8_t digitalRead(uint8_t pin);                    // digitalRead
    void digitalWrite(uint8_t pin, uint8_t value );        // digitalWrite

private:
    union {
        struct {
            uint8_t _configurationRegister_low;            // low order byte
            uint8_t _configurationRegister_high;        // high order byte
        };
        uint16_t _configurationRegister;                // 16 bits presentation
    };
    union {
        struct {
            uint8_t _valueRegister_low;                    // low order byte
            uint8_t _valueRegister_high;                // high order byte
        };
        uint16_t _valueRegister;
    };
    uint8_t _address;                                    // address of port this class is supporting
    int _error;                                            // error code from I2C
};


#endif /* CLSPCA9555_H_ */

Hier een test programmatje:

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#include "clsPCA9555.h"
#include "Wire.h"

PCA9555 ioport(0x20);

/**
 * @name setup()
 * initialize the program
 */
void setup()
{
    //
    // set first 14 pins to output
    //
    for (uint8_t i = 0; i < 14; i++){
        ioport.pinMode(i, OUTPUT);
    }
    //
    // set pin 15  (=digital 15) to Input
    //
    ioport.pinMode(ED14, INPUT);
}

/**
 * @name loop()
 * main loop of program and runs endlessly
 */
void loop()
{
    //
    // check if button is LOW
    //
    if (ioport.digitalRead(ED14) == LOW) {
        //
        // turn all 14 leds on
        //
        for (uint8_t i = 0; i < 14; i++){
            ioport.digitalWrite(i, HIGH);
            delay(50);
        }
        //
        // turn all 14 leds off
        //
        for (uint8_t i = 0; i < 14; i++){
            ioport.digitalWrite(i, LOW);
            delay(50);
        }
    }
}

Er zullen ongetwijfeld nog ideen zijn, maar vandaag zeker niet. Mij veel te mooi weer. Zal de lib tevens op GITHUB zetten. De versie die er nu staat is nog verkeerd.

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#include "clsPCA9555.h"
#include "Wire.h"

PCA9555 ioport(0x20);

/**
 * @name setup()
 * initialize the program
 */
void setup()
{
    //
    // set first 14 pins to output
    //
    for (uint8_t i = 0; i < 14; i++){
        ioport.pinMode(i, OUTPUT);
    }
    //
    // set pin 15  (=digital 15) to Input
    //
    ioport.pinMode(ED14, INPUT);
}

/**
 * @name loop()
 * main loop of program and runs endlessly
 */
void loop()
{
    //
    // check if button is LOW
    //
    if (ioport.digitalRead(ED14) == LOW) {
        //
        // turn all 14 leds on
        //
        for (uint8_t i = 0; i < 14; i++){
            ioport.digitalWrite(i, HIGH);
            delay(50);
        }
        //
        // turn all 14 leds off
        //
        for (uint8_t i = 0; i < 14; i++){
            ioport.digitalWrite(i, LOW);
            delay(50);
        }
    }
}

Hallo Nico,

ik had niet van je durven denken dat je met dit mooie weer aan het debuggen zou zijn, ik hoop toch wel dat je dit in de tuin hebt gedaan. ( ik in ieder geval wel.)

ik was er namelijk ook mee aan het stoeien. :)

ik heb de code inmiddels getest en ik moet zeggen petje af hoor, gewoon super. Nu heb ik de mogelijkheid om induvidueel uitgangen en ingangen de schakelen en te lezen.

project kan nu echt van start, ik ben namelijk bezig een StellPult ( wisselstraat schakelbord ) via een arduino aan te sluiten en op deze manier de wisselstraten te kunnen schakelen. Mijn probleem was dus het te kort aan in en uitgangen op de arduino.

nu kan ik 8 van deze dingen op de I2C aansluiten en heb dan voldoende in en uitgangen om het geheel te sturen.

hier een foto van het geheelwat ik wil gaan aansturen. https://dyp.im/LXWqNdG1Er

bedankt dat je de moeite hebt genomen om mee te denken, en vooral te debuggen en te ontwikkelen in deze.

ik had programeer technisch dit met de arduino niet kunnen uitdenken.

groetje Adriaan

Adriaan

Graag gedaan. Was weer een goede oefening. Staat inmiddels ook op GITHUB : https://github.com/nicoverduin/PCA9555

Als je die chip terug wil hebben moet je me ff je adres mailen.

Nico

@Nico
Begint er al goed uit te zien, some remarks

        Wire.requestFrom((int)_address, 2);
        //
        // wait until they are ready
        //
        while(Wire.available() != 2){};

De while(Wire.available() != 2){}; kan blocking worden als er al een byte in de buffer staat.
Gevaarlijk en onnodig.

Verder de requestFrom is een blocking call en deze returned het aantal gelezen bytes.
Dus volgende is robuuster:

        if (Wire.requestFrom((int)_address, 2) != 2)
        {
             // handle error
         };
         // geen available check

Wellicht de moeite waard on in de read de low & high byte separate te behandelen, Scheelt toch ~100 usec.

Code hieronder bevat nog extra fout detectie.

uint8_t PCA9555::digitalRead(uint8_t pin) {
    uint16_t _inputData = 0;
    uint8_t reg = NXP_INPUT;
    //
    // handle invalid pin first
    //
    if (pin > 15 ) return 255;
    if (pin > 7) {
        reg++;
        pin -= 8;
    }
    Wire.beginTransmission(_address);          // setup read registers
    Wire.write(reg);
    _error = Wire.endTransmission();
    
    if (_error != 0) return 253; // handle error
    
    if (Wire.requestFrom((int)_address, 1) != 1) {
        return 254; // handle error
    }
    _inputData = Wire.read();
    if ((_inputData & (1 << pin)) > 0) {
        return HIGH;
    } else {
        return LOW;
    }
}

de write rewritten, expliciete test voor pin error,
verder een locale variable verwijderd,

void PCA9555::digitalWrite(uint8_t pin, uint8_t value) {
    //
    // check valid pin first
    //
    if (pin > 15) 
    {
        _error = 255;
        return;
    }

    // next set the bit we want to set
    // if the value is LOW we will and the register value with correct bit set to zero
    // if the value is HIGH we will or the register value with correct bit set to HIGH
    if (value > 0) {
        //
        // this is a High value so we will or it with the value register
        //
        _valueRegister |=  (1 << pin);    // and OR bit in register
    } else {
        //
        // this is a LOW value so we have to AND it with 0 into the _valueRegister
        //
        _valueRegister &=  ~(1 << pin);    // AND all bits
    }
    // write output register to chip
    Wire.beginTransmission(_address);              // setup direction registers
    Wire.write(NXP_OUTPUT);                              // pointer to configuration register address 0
    Wire.write(_valueRegister_low);              // write config register low byte
    Wire.write(_valueRegister_high);              // write config register high byte
    _error = Wire.endTransmission();
}

1 byte versie kan ook hier nog toegevoegd.

Hoi Rob Bedankt voor het commentaar. Ik moet ze ff doorlopen (met name over de kleinere 9554 versie. Meeste zit er al in. Ik zat zelf te denken om het steeds universeler te maken. en dan moet ik ff nadenken hoe dat slim en vooral onderhoudbaar op te lossen. Wordt vervolgt.

Ik zou zelf de Wire calls abstraheren in een low level laag. e.g.

uint8_t I2CGetValue(address, register); void I2CSetValue(address, register, value);

Dan wordt het b.v. makkelijker om de lib voor e.g. ARM te gebruiken waarbij enkel de low level call vervangen hoeft te worden (#ifdef)

Goed punt!!

@rob: volgens mij de meeste punten erin verwerkt. zie: GITHUB

Hey Nico,

complimenten met deze PCA9555 library, ziet er zeer bruikbaar uit en werkt ook op de ESP8266 IDE addOn. De pca9555 werkt ook prima op 3.3 volt dus voor iets meer dan 50 cent (wel in china bestellen) geef je een ESP8266 module zomaar 16 extra IO pinnen.

Maar een onhandigheid maakt het gebruik met de ESP, zeker voor de beginner, nog wat moeilijk. Je hebt in de cpp file de wire.begin opgenomen

/* clsPCA9555.cpp */
50: PCA9555::PCA9555(uint8_t address) {
51:   _address         = address;        // save the address id
52:    _valueRegister   = 0;
53:    Wire.begin();                      // start I2C communication
}

terwijl als je de ESP addOn gebruikt je dit als

Wire.begin(SDA_pin, SCL_pin);

moet declareren anders werkt het niet. Mijn voorkeur gaat er dus naar uit om de Wire.begin uit de cpp file te gooien en dit gewoon in de setup() op te nemen. Dan kun je naar wens voor de AVR_chip of voor de ESP_chip compileren zonder de library te hoeven wijzigen. Hierdoor wordt je library nog universeler en makkelijker bruikbaar

Was is de definitie van de CPU als je met de ESP8266 compileert? Dan maak ik er wel een constructor overload van en een #define. Er zullen nog wel meer processors komen. ARM bijv.

@cartoonist:
wil jij dit 's testen?
,h file

/*
 * clsPCA9555.h
 *
 *  Created on: 27 jul. 2015
 *      Author: Nico Verduin
 */

#ifndef CLSPCA9555_H_
#define CLSPCA9555_H_

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#define DEBUG 1

/** enum with names of ports ED0 - ED15 */
enum {
    ED0, ED1, ED2 , ED3 , ED4 , ED5 , ED6 , ED7 ,
    ED8, ED9, ED10, ED11, ED12, ED13, ED14, ED15
};

//
// PCA9555 defines
//
#define NXP_INPUT      0
#define NXP_OUTPUT     2
#define NXP_INVERT     4
#define NXP_CONFIG     6

class PCA9555 {
public:
    PCA9555(uint8_t address);                            // constructor
    PCA9555(uint8_t address, uint8_t sda, uint8_t scl);  // constructor
    void pinMode(uint8_t pin, uint8_t IOMode );          // pinMode
    uint8_t digitalRead(uint8_t pin);                    // digitalRead
    void digitalWrite(uint8_t pin, uint8_t value );      // digitalWrite

private:
    //
    // low level methods
    //
    uint16_t I2CGetValue(uint8_t address, uint8_t reg);
    void I2CSetValue(uint8_t address, uint8_t reg, uint8_t value);

    union {
        struct {
            uint8_t _configurationRegister_low;          // low order byte
            uint8_t _configurationRegister_high;         // high order byte
        };
        uint16_t _configurationRegister;                 // 16 bits presentation
    };
    union {
        struct {
            uint8_t _valueRegister_low;                  // low order byte
            uint8_t _valueRegister_high;                 // high order byte
        };
        uint16_t _valueRegister;
    };
    uint8_t _address;                                    // address of port this class is supporting
    int _error;                                          // error code from I2C
};


#endif /* CLSPCA9555_H_ */

.cpp file

/**
 * @file    clsPCA9555.cpp
 * @author     Nico Verduin
 * @date      9-8-2015
 *
 * @mainpage  clsPCA9555
 * Class to enable pinMode(), digitalRead() and digitalWrite() functions on PCA9555 IO expanders
 *
 * Additional input received from Rob Tillaart (9-8-2015)
 *
 * @par License info
 *
 * Class to enable the use of single pins on PCA9555 IO Expander using
 * pinMode(), digitalRead() and digitalWrite().
 *
 * Copyright (C) 2015  Nico Verduin
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 * Program : clsPCA9555  Copyright (C) 2015  Nico Verduin
 * This is free software, and you are welcome to redistribute it.
 *
 */

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

#include "clsPCA9555.h"
#include "Wire.h"

/**
 * PCA9555 constructor for ESP8266
 * @param address address of IO chip
 * @param sda    SDA pin
 * @param scl    SCL pin
 * Creates the class interface and sets the I2C Address of the port
 */
PCA9555::PCA9555(uint8_t address, uint8_t sda, uint8_t scl) {
    _address         = address;        // save the address id
    _valueRegister   = 0;
    Wire.begin(sda, scl);                      // start I2C communication
}


/**
 * @name PCA9555 constructor
 * @param address I2C address of the IO Expander
 * Creates the class interface and sets the I2C Address of the port
 */
PCA9555::PCA9555(uint8_t address) {
    _address         = address;        // save the address id
    _valueRegister   = 0;
    Wire.begin();                      // start I2C communication
}

/**
 * @name pinMode
 * @param pin       pin number
 * @param IOMode    mode of pin INPUT or OUTPUT
 * sets the mode of this IO pin
 */
void PCA9555::pinMode(uint8_t pin, uint8_t IOMode) {

    //
    // check if valid pin first
    //
    if (pin <= 15) {
        //
        // now set the correct bit in the configuration register
        //
        if (IOMode == OUTPUT) {
            //
            // mask correct bit to 0 by inverting x so that only
            // the correct bit is LOW. The rest stays HIGH
            //
            _configurationRegister = _configurationRegister & ~(1 << pin);
        } else {
            //
            // or just the required bit to 1
            //
            _configurationRegister = _configurationRegister | (1 << pin);
        }
        //
        // write configuration register to chip
        //
        I2CSetValue(_address, NXP_CONFIG    , _configurationRegister_low);
        I2CSetValue(_address, NXP_CONFIG + 1, _configurationRegister_high);
    }
}
/**
 * @name digitalRead Reads the high/low value of specified pin
 * @param pin
 * @return value of pin
 * Reads the selected pin.
 */
uint8_t PCA9555::digitalRead(uint8_t pin) {
    uint16_t _inputData = 0;
    //
    // we wil only process pins <= 15
    //
    if (pin > 15 ) return 255;
    _inputData  = I2CGetValue(_address, NXP_INPUT);
    _inputData |= I2CGetValue(_address, NXP_INPUT + 1) << 8;
    //
    // now mask the bit required and see if it is a HIGH
    //
    if ((_inputData & (1 << pin)) > 0){
        //
        // the bit is HIGH otherwise we would return a LOW value
        //
        return HIGH;
    } else {
        return LOW;
    }
}

void PCA9555::digitalWrite(uint8_t pin, uint8_t value) {
    //
    // check valid pin first
    //
    if (pin > 15 ){
        _error = 255;            // invalid pin
        return;                  // exit
    }
    //
    // if the value is LOW we will and the register value with correct bit set to zero
    // if the value is HIGH we will or the register value with correct bit set to HIGH
    //
    if (value > 0) {
        //
        // this is a High value so we will or it with the value register
        //
        _valueRegister = _valueRegister | (1 << pin);    // and OR bit in register
    } else {
        //
        // this is a LOW value so we have to AND it with 0 into the _valueRegister
        //
        _valueRegister = _valueRegister & ~(1 << pin);    // AND all bits
    }
    I2CSetValue(_address, NXP_OUTPUT    , _valueRegister_low);
    I2CSetValue(_address, NXP_OUTPUT + 1, _valueRegister_high);
}
//
// low level hardware methods
//

/**
 * @name I2CGetValue
 * @param address Address of I2C chip
 * @param reg    Register to read from
 * @return data in register
 * Reads the data from addressed chip at selected register. \n
 * If the value is above 255, an error is set. \n
 * error codes : \n
 * 256 = either 0 or more than one byte is received from the chip
 */
uint16_t PCA9555::I2CGetValue(uint8_t address, uint8_t reg) {
    uint16_t _inputData;
    //
    // read the address input register
    //
    Wire.beginTransmission(address);          // setup read registers
    Wire.write(reg);
    _error = Wire.endTransmission();
    //
    // ask for 2 bytes to be returned
    //
    if (Wire.requestFrom((int)address, 1) != 1)
    {
        //
        // we are not receing the bytes we need
        //
        return 256;                            // error code is above normal data range
    };
    //
    // read both bytes
    //
    _inputData = Wire.read();
    return _inputData;
}

/**
 * @name I2CSetValue(uint8_t address, uint8_t reg, uint8_t value)
 * @param address Address of I2C chip
 * @param reg    register to write to
 * @param value    value to write to register
 * Write the value given to the register set to selected chip.
 */
void PCA9555::I2CSetValue(uint8_t address, uint8_t reg, uint8_t value){
    //
    // write output register to chip
    //
    Wire.beginTransmission(address);              // setup direction registers
    Wire.write(reg);                              // pointer to configuration register address 0
    Wire.write(value);                            // write config register low byte
    _error = Wire.endTransmission();
}

Was is de definitie van de CPU als je met de ESP8266 compileert? Dan maak ik er wel een constructor overload van en een #define. Er zullen nog wel meer processors komen. ARM bijv.

Hoe de compiler intern onderscheid maakt tussen een AVR , ARM of ESP chip is mij niet bekend.

@cartoonist: wil jij dit 's testen? ,h file

Ik zou dit met alle plezier voor je testen maar ik heb vandaag pas die PCA9555 in china besteld, dus heb ik voorlopig nog niet de mogelijkheid om dit echt te testen. Ik kan wel, zodra ik de gelegenheid en tijd heb, de example sketch op de ESP draaien en met een (Salea) USB logic analyser op de I2C bus kijken.

Nog even het volgende:

Arduino DUE heeft een ARM processor en daar wordt de defenitie Wire.begin() voor de eerste en Wire1.begin() voor de tweede I2C poort gebruikt. Deze twee I2C poorten zijn intern aan vaste pinnummers verbonden. Zoals je de library nu is kun je die dus voor een Arduino DUE alleen met de eerste I2C bus gebruiken omdat in de library_cpp file Wire.begin() staat. Of je moet ook voor de DUE een aparte constructor voor de Wire.begin1() in de de cpp file maken.

Als iemand hem voor de DUE wil hebben mag ie hem forken van GITHUB, aanpassen, testen en een pull request sturen. Ik heb die chip toch niet meer dus ik kan het verder toch niet testen. Dat er in de toekomst veranderingen in komen hangt af van de inzet van andere gebruikers. idem voor een meer generalistische I2C IO Expander. En wie weet in de toekomst......

Is het toch niet eenvoudiger die Wire.begin() uit de cpp file te schrappen ?

Je moet toch ook de Wire.h library includen en als je dan in de doc file van de Wire library kijkt dan staat daar duidelijk dat je in de setup() de regel Wire.begin() moet opnemen.

Door deze regel, die bij de Wire.h hoort, in een andere library te embedden schep je in feite onduidelijkheid voor de recht toe recht aan gebruikers die niet in libraries duiken.

Als ik hem op github zou forken dan gaat enkel die Wire.begin() eruit. :grin:

cartoonist: Is het toch niet eenvoudiger die Wire.begin() uit de cpp file te schrappen ?

Je moet toch ook de Wire.h library includen en als je dan in de doc file van de Wire library kijkt dan staat daar duidelijk dat je in de setup() de regel Wire.begin() moet opnemen.

Door deze regel, die bij de Wire.h hoort, in een andere library te embedden schep je in feite onduidelijkheid voor de recht toe recht aan gebruikers die niet in libraries duiken.

Als ik hem op github zou forken dan gaat enkel die Wire.begin() eruit. :grin:

Dan moet je ook je eigen library creeren :) want dan weiger ik de pull request.