alex/GY-63_MS5611
1
0
Fork 0
mirror of https://github.com/RobTillaart/Arduino.git synced 2024-10-03 18:09:02 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity

0.2.0 MCP23S08

Browse Source
This commit is contained in:
Rob Tillaart 2023-08-21 14:31:38 +02:00
parent 1e91fd7d38
commit 7e1e45dfb1
12 changed files with 383 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libraries/MCP23S08/.github/workflows/arduino-lint.yml vendored
View File

@ -11,3 +11,5 @@ jobs:
with:
library-manager: update
compliance: strict
verbose: false

11
libraries/MCP23S08/CHANGELOG.md
View File

@ -6,12 +6,21 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/)
and this project adheres to [Semantic Versioning](http://semver.org/).
## [0.2.0] - 2023-08-19
- add ESP32 support
- sync with MCP23S17
- add **getAddress()**
- add **MCP23S08_registers.h**
- update readme.md
- update examples
- minor edits
## [0.1.3] - 2023-02-04
- UPDATE README.MD
- update GitHub actions
- update license 2023
## [0.1.2] - 2022-11-17
- add RP2040 in build-CI
- add changelog.md

191
libraries/MCP23S08/MCP23S08.cpp
View File

@ -1,38 +1,19 @@
//
// FILE: MCP23S08.cpp
// AUTHOR: Rob Tillaart
// VERSION: 0.1.3
// VERSION: 0.2.0
// PURPOSE: Arduino library for SPI MCP23S08 8 channel port expander
// DATE: 2022-01-10
// URL: https://github.com/RobTillaart/MCP23S08
#include "Arduino.h"
#include "MCP23S08.h"
// Registers // description datasheet P9
#define MCP23S08_DDR_A 0x00 // Data Direction Register A P 10
#define MCP23S08_POL_A 0x01 // Input Polarity A P 11
#define MCP23S08_GPINTEN_A 0x02 // NOT USED interrupt enable P 12
#define MCP23S08_DEFVAL_A 0x03 // NOT USED interrupt def P 13
#define MCP23S08_INTCON_A 0x04 // NOT USED interrupt control P 14
#define MCP23S08_IOCR 0x05 // IO control register P 15
#define MCP23S08_PUR_A 0x06 // Pull Up Resistors A P 16
#define MCP23S08_INTF_A 0x07 // NOT USED interrupt flag P 17
#define MCP23S08_INTCAP_A 0x08 // NOT USED interrupt capture P 18
#define MCP23S08_GPIO_A 0x09 // General Purpose IO A P 19
#define MCP23S08_OLAT_A 0x0A // NOT USED output latch P 20
// low level read / write masks
#define MCP23S08_WRITE_REG 0x40
#define MCP23S08_READ_REG 0x41
// SOFTWARE SPI
MCP23S08::MCP23S08(uint8_t select, uint8_t dataIn, uint8_t dataOut, uint8_t clock, uint8_t address)
{
_address = address;
_address = (address << 1);
_select = select;
_dataIn = dataIn;
_dataOut = dataOut;
@ -42,11 +23,20 @@ MCP23S08::MCP23S08(uint8_t select, uint8_t dataIn, uint8_t dataOut, uint8_t cloc
}
MCP23S08::MCP23S08(uint8_t select, uint8_t address)
// HARDWARE SPI
MCP23S08::MCP23S08(uint8_t select, SPIClass* spi)
{
_address = address;
MCP23S08(select, 0x00, spi);
}
// HARDWARE SPI
MCP23S08::MCP23S08(uint8_t select, uint8_t address, SPIClass* spi)
{
_address = (address << 1);
_select = select;
_error = MCP23S08_OK;
_mySPI = spi;
_hwSPI = true;
}
@ -61,10 +51,24 @@ bool MCP23S08::begin()
if (_hwSPI)
{
// TODO - ESP32 specific support - see MCP_ADC.
mySPI = &SPI;
mySPI->end();
mySPI->begin();
#if defined(ESP32)
if (_useHSPI) // HSPI
{
_mySPI = new SPIClass(HSPI);
_mySPI->end();
_mySPI->begin(14, 12, 13, _select); // CLK=14 MISO=12 MOSI=13
}
else // VSPI
{
_mySPI = new SPIClass(VSPI);
_mySPI->end();
_mySPI->begin(18, 19, 23, _select); // CLK=18 MISO=19 MOSI=23
}
#else // generic hardware SPI
_mySPI = &SPI;
_mySPI->end();
_mySPI->begin();
#endif
}
else
{
@ -78,10 +82,14 @@ bool MCP23S08::begin()
// check connected
if (! isConnected()) return false;
// disable address increment (datasheet)
if (! writeReg(MCP23S08_IOCR, 0b00100000)) return false; // TODO MAGIC NR
// disable address increment (datasheet P20
// SEQOP: Sequential Operation mode bit
// 1 = Sequential operation disabled, address pointer does not increment.
// 0 = Sequential operation enabled, address pointer increments.
if (! writeReg(MCP23S08_IOCR, MCP23S08_IOCR_SEQOP)) return false;
// Force INPUT_PULLUP
if (! writeReg(MCP23S08_PUR_A, 0xFF)) return false;
if (! writeReg(MCP23S08_PUR_A, 0xFF)) return false; // 0xFF == all UP
return true;
}
@ -93,7 +101,16 @@ bool MCP23S08::isConnected()
}
uint8_t MCP23S08::getAddress()
{
return (_address >> 1);
}
///////////////////////////////////////////////////////////////////
//
// single pin interface
//
// pin = 0..7
// mode = INPUT, OUTPUT, INPUT_PULLUP (= same as INPUT)
bool MCP23S08::pinMode(uint8_t pin, uint8_t mode)
@ -151,6 +168,7 @@ bool MCP23S08::digitalWrite(uint8_t pin, uint8_t value)
{
return false;
}
uint8_t mask = 1 << pin;
if (value)
{
@ -160,6 +178,7 @@ bool MCP23S08::digitalWrite(uint8_t pin, uint8_t value)
{
val &= ~mask;
}
// only write when changed.
if (pre != val)
{
writeReg(IOR, val);
@ -302,10 +321,10 @@ void MCP23S08::setSPIspeed(uint32_t speed)
};
///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////
//
// 8 pins interface
//
// whole register at once
// value = 0..0xFF bit pattern
bool MCP23S08::pinMode8(uint8_t value)
@ -385,11 +404,89 @@ int MCP23S08::lastError()
}
void MCP23S08::enableControlRegister(uint8_t mask)
{
uint8_t reg = readReg(MCP23S08_IOCR);
reg |= mask;
writeReg(MCP23S08_IOCR, reg);
}
void MCP23S08::disableControlRegister(uint8_t mask)
{
uint8_t reg = readReg(MCP23S08_IOCR);
reg &= ~mask;
writeReg(MCP23S08_IOCR, reg);
}
void MCP23S08::enableHardwareAddress()
{
enableControlRegister(MCP23S08_IOCR_HAEN);
}
void MCP23S08::disableHardwareAddress()
{
disableControlRegister(MCP23S08_IOCR_HAEN);
}
#if defined(ESP32)
void MCP23S08::selectHSPI()
{
_useHSPI = true;
}
void MCP23S08::selectVSPI()
{
_useHSPI = false;
}
bool MCP23S08::usesHSPI()
{
return _useHSPI;
}
bool MCP23S08::usesVSPI()
{
return !_useHSPI;
}
void MCP23S08::setGPIOpins(uint8_t clk, uint8_t miso, uint8_t mosi, uint8_t select)
{
_clock = clk;
_dataOut = mosi;
_dataIn = miso;
_select = select;
pinMode(_select, OUTPUT);
digitalWrite(_select, HIGH);
_mySPI->end(); // disable old SPI
_mySPI->begin(clk, miso, mosi, select); // enable new pins
}
#endif
////////////////////////////////////////////////////
//
// PRIVATE
//
// low level read / write masks
#define MCP23S08_WRITE_REG 0x40
#define MCP23S08_READ_REG 0x41
bool MCP23S08::writeReg(uint8_t reg, uint8_t value)
{
_error = MCP23S08_OK;
@ -402,15 +499,17 @@ bool MCP23S08::writeReg(uint8_t reg, uint8_t value)
::digitalWrite(_select, LOW);
if (_hwSPI)
{
mySPI->beginTransaction(_spi_settings);
mySPI->transfer(MCP23S08_WRITE_REG | (_address << 1) );
mySPI->transfer(reg);
mySPI->transfer(value);
mySPI->endTransaction();
_mySPI->beginTransaction(_spi_settings);
// _address already shifted
_mySPI->transfer(MCP23S08_WRITE_REG | _address );
_mySPI->transfer(reg);
_mySPI->transfer(value);
_mySPI->endTransaction();
}
else
{
swSPI_transfer(MCP23S08_WRITE_REG | (_address << 1) );
// _address already shifted
swSPI_transfer(MCP23S08_WRITE_REG | _address );
swSPI_transfer(reg);
swSPI_transfer(value);
}
@ -434,15 +533,17 @@ uint8_t MCP23S08::readReg(uint8_t reg)
::digitalWrite(_select, LOW);
if (_hwSPI)
{
mySPI->beginTransaction(_spi_settings);
mySPI->transfer(MCP23S08_READ_REG | (_address << 1) ); // TODO OPTIMIZE n times
mySPI->transfer(reg);
rv = mySPI->transfer(0xFF);
mySPI->endTransaction();
_mySPI->beginTransaction(_spi_settings);
// _address already shifted
_mySPI->transfer(MCP23S08_READ_REG | _address ); // TODO OPTIMIZE n times
_mySPI->transfer(reg);
rv = _mySPI->transfer(0xFF);
_mySPI->endTransaction();
}
else
{
swSPI_transfer(MCP23S08_READ_REG | (_address << 1) );
// _address already shifted
swSPI_transfer(MCP23S08_READ_REG | _address );
swSPI_transfer(reg);
rv = swSPI_transfer(0xFF);
}

59
libraries/MCP23S08/MCP23S08.h
View File

@ -2,7 +2,7 @@
//
// FILE: MCP23S08.h
// AUTHOR: Rob Tillaart
// VERSION: 0.1.3
// VERSION: 0.2.0
// PURPOSE: Arduino library for SPI MCP23S08 8 channel port expander
// DATE: 2022-01-10
// URL: https://github.com/RobTillaart/MCP23S08
@ -10,10 +10,12 @@
#include "Arduino.h"
#include "SPI.h"
#include "MCP23S08_registers.h"
#define MCP23S08_LIB_VERSION (F("0.1.3"))
#define MCP23S08_LIB_VERSION (F("0.2.0"))
// ERROR CODES
#define MCP23S08_OK 0x00
#define MCP23S08_PIN_ERROR 0x81
#define MCP23S08_SPI_ERROR 0x82
@ -24,20 +26,26 @@
#define MCP23S08_INVALID_READ -100
const uint32_t MCP23S08_TYP_SPI_SPEED = 8000000;
const uint32_t MCP23S08_MAX_SPI_SPEED = 10000000;
class MCP23S08
{
public:
// SOFTWARE SPI
MCP23S08(uint8_t select, uint8_t dataIn, uint8_t dataOut, uint8_t clock, uint8_t address = 0x00);
// HARDWARE SPI
MCP23S08(uint8_t select, uint8_t address = 0x00);
MCP23S08(uint8_t select, SPIClass* spi);
MCP23S08(uint8_t select, uint8_t address = 0x00, SPIClass* spi = &SPI);
bool begin();
bool isConnected(); // needed ?
bool isConnected();
uint8_t getAddress();
// single pin interface
// mode = INPUT, OUTPUT or INPUT_PULLUP (==INPUT)
// mode: 0 = OUTPUT, 1 = INPUT, 1 = INPUT_PULLUP (==INPUT)
bool pinMode(uint8_t pin, uint8_t mode);
bool digitalWrite(uint8_t pin, uint8_t value);
uint8_t digitalRead(uint8_t pin);
@ -49,7 +57,6 @@ public:
// 8 pins interface
// port = 0..1
// value = bit pattern
bool pinMode8(uint8_t value);
bool write8(uint8_t value);
@ -69,7 +76,30 @@ public:
bool usesHWSPI() { return _hwSPI; };
int lastError();
// set/clear IOCR bit fields (0.2.0 experimental)
void enableControlRegister(uint8_t mask);
void disableControlRegister(uint8_t mask);
// 0.2.0 experimental
void enableHardwareAddress();
void disableHardwareAddress();
// ESP32 specific
#if defined(ESP32)
void selectHSPI();
void selectVSPI();
bool usesHSPI();
bool usesVSPI();
// to overrule the ESP32s default hardware pins
void setGPIOpins(uint8_t clk, uint8_t miso, uint8_t mosi, uint8_t select);
#endif
private:
// access to low level registers (just make these two functions public).
// USE WITH CARE !!!
bool writeReg(uint8_t reg, uint8_t value);
uint8_t readReg(uint8_t reg);
@ -80,15 +110,20 @@ private:
uint8_t _clock = 0;
uint8_t _error = MCP23S08_OK;
bool _hwSPI = false;
// 1 MHz is a safe value TODO CHECK datasheet
uint32_t _SPIspeed = 8000000UL;
SPIClass * mySPI;
bool _hwSPI = false;
// 10 MHz is maximum, 8 is a better clock divider on AVR.
uint32_t _SPIspeed = MCP23S08_TYP_SPI_SPEED;
SPIClass * _mySPI;
SPISettings _spi_settings;
uint8_t swSPI_transfer(uint8_t val);
#if defined(ESP32)
bool _useHSPI = true;
#endif
};
// -- END OF FILE --
// -- END OF FILE --

33
libraries/MCP23S08/MCP23S08_registers.h Normal file
View File

@ -0,0 +1,33 @@
#pragma once
//
// FILE: MCP23S08_registers.h
// AUTHOR: Rob Tillaart
// PURPOSE: MCP23S08 register file
// URL: https://github.com/RobTillaart/MCP23S08
// Registers // description datasheet P9
#define MCP23S08_DDR_A 0x00 // Data Direction Register A P 10
#define MCP23S08_POL_A 0x01 // Input Polarity A P 11
#define MCP23S08_GPINTEN_A 0x02 // NOT USED interrupt enable P 12
#define MCP23S08_DEFVAL_A 0x03 // NOT USED interrupt def P 13
#define MCP23S08_INTCON_A 0x04 // NOT USED interrupt control P 14
#define MCP23S08_IOCR 0x05 // IO control register P 15
#define MCP23S08_PUR_A 0x06 // Pull Up Resistors A P 16
#define MCP23S08_INTF_A 0x07 // NOT USED interrupt flag P 17
#define MCP23S08_INTCAP_A 0x08 // NOT USED interrupt capture P 18
#define MCP23S08_GPIO_A 0x09 // General Purpose IO A P 19
#define MCP23S08_OLAT_A 0x0A // NOT USED output latch P 20
// IOCR = IO CONTROL REGISTER bit masks - details datasheet P15
#define MCP23S08_IOCR_SEQOP 0x20 // Sequential Operation mode bit.
#define MCP23S08_IOCR_DISSLW 0x10 // Slew Rate control bit for SDA output.
#define MCP23S08_IOCR_HAEN 0x08 // Hardware Address Enable bit (MCP23S17 only).
#define MCP23S08_IOCR_ODR 0x04 // Configures the INT pin as an open-drain output.
#define MCP23S08_IOCR_INTPOL 0x02 // This bit sets the polarity of the INT output pin.
#define MCP23S08_IOCR_NI 0x01 // Not implemented.
// -- END OF FILE --

84
libraries/MCP23S08/README.md
View File

@ -46,15 +46,53 @@ If a pin is not changed it will not be written again to save time.
### Constructor
- **MCP23S08(uint8_t select, uint8_t data, uint8_t clock)** constructor SW SPI.
- **MCP23S08(uint8_t select)** constructor HW SPI.
- **MCP23S08(uint8_t select, uint8_t dataIn, uint8_t dataOut, uint8_t clock, uint8_t address = 0x00)** constructor SOFTWARE SPI.
- **MCP23S08(uint8_t select, SPIClass\* spi)** constructor HARDWARE SPI with explicit SPI interface selected.
- **MCP23S08(uint8_t select, uint8_t address = 0x00, SPIClass\* spi = &SPI)** constructor HARDWARE SPI with optional address pins and SPI interface.
- **bool begin()** returns true if successful.
- **bool isConnected()** returns true if connected, false otherwise. (dummy)
- **bool isConnected()** returns true if connected, false otherwise. (dummy for compatibility reasons)
- **uint8_t getAddress()** returns the address set in the constructor.
Default = 0, range = 0..3.
The two hardware constructors allow to call 4 different constructors.
```cpp
- MCP23S08(10); // select pin only
- MCP23S08(10, 7); // select pin + address pins
- MCP23S08(10, 7, &SPI2); // select pin + address pins + SPI port
- MCP23S08(10, &SPI2); // select pin + SPI port
```
#### Sharing SELECT lines
(verified in MCP23S17 issue 19)
Technically two chips could use the same SELECT pin and a different address.
Since 0.2.0 the constructors allow to setup such a configuration.
The added value is that one can use up to 4 devices (= 32 IO lines) with only
four lines (MISO, MOSI, CLOCK, SELECT).
I assume that this configuration is less used and IMHO not recommended.
NB it is more difficult to detect which device is selected when debugging.
To use the hardware addresses the Hardware Address ENable register must be set.
See datasheet 1.6.6 ADDRESSING SPI DEVICES, need to set IOCON.HAEN.
The library supports two ways:
```cpp
MCP.enableControlRegister(MCP23S08_IOCR_HAEN); // or 0x08
or
MCP.enableHardwareAddress(); // 0.2.0 version and up
```
See also **IO Control Register** section below.
### Single pin interface
- **bool pinMode(uint8_t pin, uint8_t mode)** pin = 0..7, mode = INPUT, OUTPUT.
mode: 0 = OUTPUT, 1 = INPUT, 1 = INPUT_PULLUP (==INPUT)
- **bool pinMode(uint8_t pin, uint8_t mode)** pin = 0..7.
Returns true if successful.
- **bool digitalWrite(uint8_t pin, uint8_t value)** pin = 0..7, value = LOW(0) HIGH (!0).
Returns true if successful.
@ -84,6 +122,39 @@ Returns true if successful.
Returns true if successful.
### Other
- **void setSPIspeed(uint32_t speed)** set hardware speed (8Mb default).
- **uint32_t getSPIspeed()** returns set speed.
### Debugging
- **bool usesHWSPI()** returns true = hardware SPI, false = software SPI.
- **int lastError()** idem.
### ControlRegister
Since 0.2.0
- **void enableControlRegister(uint8_t mask)** set IOCR bit fields
- **void disableControlRegister(uint8_t mask)** clear IOCR bit fields
- **void enableHardwareAddress()** specific for HAEN field.
- **void disableHardwareAddress()** specific for HAEN field.
### ESP32
Since 0.2.0
- **void selectHSPI()** idem
- **void selectVSPI()** idem
- **bool usesHSPI()** idem
- **bool usesVSPI()** idem
- **void setGPIOpins(uint8_t clk, uint8_t miso, uint8_t mosi, uint8_t select)** overrule the ESP32s default hardware pins.
### Error codes
If one of the above functions return false, there might be an error.
@ -118,10 +189,7 @@ See examples.
#### Could
- MCP23S17 sync
- add enableIO controlRegister functions
- add registers.h file
- ESP32 example code
#### Wont

3
libraries/MCP23S08/examples/MCP23S08_digitalRead/MCP23S08_digitalRead.ino
View File

@ -17,8 +17,9 @@ void setup()
{
Serial.begin(115200);
Serial.println();
Serial.print("MCP23S08_test version: ");
Serial.print("MCP23S08_LIB_VERSION: ");
Serial.println(MCP23S08_LIB_VERSION);
Serial.println();
delay(100);
SPI.begin();

3
libraries/MCP23S08/examples/MCP23S08_digitalWrite/MCP23S08_digitalWrite.ino
View File

@ -15,8 +15,9 @@ void setup()
{
Serial.begin(115200);
Serial.println();
Serial.print("MCP23S08_test version: ");
Serial.print("MCP23S08_LIB_VERSION: ");
Serial.println(MCP23S08_LIB_VERSION);
Serial.println();
delay(100);
SPI.begin();

2
libraries/MCP23S08/examples/MCP23S08_performance/MCP23S08_performance.ino
View File

@ -18,7 +18,7 @@ void setup()
{
Serial.begin(115200);
Serial.println();
Serial.print("MCP23S08_test version: ");
Serial.print("MCP23S08_LIB_VERSION: ");
Serial.println(MCP23S08_LIB_VERSION);
Serial.println();
delay(100);

62
libraries/MCP23S08/keywords.txt Normal file
View File

@ -0,0 +1,62 @@
# Syntax Colouring Map For MCP23S08
# Data types (KEYWORD1)
MCP23S08 KEYWORD1
# Methods and Functions (KEYWORD2)
begin KEYWORD2
isConnected KEYWORD2
getAddress KEYWORD2
pinMode KEYWORD2
digitalWrite KEYWORD2
digitalRead KEYWORD2
setPolarity KEYWORD2
getPolarity KEYWORD2
setPullup KEYWORD2
getPullup KEYWORD2
pinMode8 KEYWORD2
write8 KEYWORD2
read8 KEYWORD2
setPolarity8 KEYWORD2
getPolarity8 KEYWORD2
setPullup8 KEYWORD2
getPullup8 KEYWORD2
setSPIspeed KEYWORD2
getSPIspeed KEYWORD2
usesHWSPI KEYWORD2
lastError KEYWORD2
enableControlRegister KEYWORD2
disableControlRegister KEYWORD2
enableHardwareAddress KEYWORD2
disableHardwareAddress KEYWORD2
selectHSPI KEYWORD2
selectVSPI KEYWORD2
usesHSPI KEYWORD2
usesVSPI KEYWORD2
setGPIOpins KEYWORD2
# Instances (KEYWORD2)
# Constants (LITERAL1)
MCP23S08_LIB_VERSION LITERAL1
MCP23S08_OK LITERAL1
MCP23S08_PIN_ERROR LITERAL1
MCP23S08_I2C_ERROR LITERAL1
MCP23S08_VALUE_ERROR LITERAL1
MCP23S08_PORT_ERROR LITERAL1
MCP23S08_REGISTER_ERROR LITERAL1
MCP23S08_INVALID_READ LITERAL1

2
libraries/MCP23S08/library.json
View File

@ -15,7 +15,7 @@
"type": "git",
"url": "https://github.com/RobTillaart/MCP23S08.git"
},
"version": "0.1.3",
"version": "0.2.0",
"license": "MIT",
"frameworks": "arduino",
"platforms": "*",

2
libraries/MCP23S08/library.properties
View File

@ -1,5 +1,5 @@
name=MCP23S08
version=0.1.3
version=0.2.0
author=Rob Tillaart <rob.tillaart@gmail.com>
maintainer=Rob Tillaart <rob.tillaart@gmail.com>
sentence=Arduino library for SPI MCP23S08 8 channel port expander 8 IO-lines