Skip to content

Commit f7e3817

Browse files
RobTillaartRobTillaart
committed
0.1.1 MAX14661
1 parent eb26267 commit f7e3817

File tree

8 files changed

+366
-42
lines changed

8 files changed

+366
-42
lines changed

‎libraries/MAX14661/.github/workflows/arduino_test_runner.yml‎

Lines changed: 7 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,14 @@ name: Arduino CI
44
on: [push, pull_request]
55

66
jobs:
7-
arduino_ci:
7+
runTest:
88
runs-on: ubuntu-latest
99

1010
steps:
1111
- uses: actions/checkout@v2
12-
- uses: Arduino-CI/action@master
13-
# Arduino-CI/[email protected]
12+
- uses: ruby/setup-ruby@v1
13+
with:
14+
ruby-version: 2.6
15+
- run: |
16+
gem install arduino_ci
17+
arduino_ci.rb

‎libraries/MAX14661/MAX14661.cpp‎

Lines changed: 158 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,14 @@
22
// FILE: MAX14661.cpp
33
// AUTHOR: Rob Tillaart
44
// DATE: 2021-01-29
5-
// VERSION: 0.1.0
5+
// VERSION: 0.1.1
66
// PURPOSE: Arduino library for MAX14661 16 channel I2C multiplexer
77
// URL: https://github.com/RobTillaart/MAX14661
88
//
99
// HISTORY:
10-
// 0.1.00 2021-01-29 initial version
11-
//
10+
// 0.1.0 2021-01-29 initial version
11+
// 0.1.1 2021-08-30 add shadow interface - experimental
12+
1213

1314
#include "MAX14661.h"
1415

@@ -19,13 +20,14 @@
1920
#define MAX14661_DIR2 0x02
2021
#define MAX14661_DIR3 0x03
2122
#define MAX14661_SHDW0 0x10
22-
#define MAX14661_SHDw1 0x11
23-
#define MAX14661_SHDw2 0x12
24-
#define MAX14661_SHDw3 0x13
23+
#define MAX14661_SHDW1 0x11
24+
#define MAX14661_SHDW2 0x12
25+
#define MAX14661_SHDW3 0x13
2526
#define MAX14661_CMD_A 0x14
2627
#define MAX14661_CMD_B 0x15
2728

2829

30+
2931
MAX14661::MAX14661(const uint8_t deviceAddress, TwoWire *wire)
3032
{
3133
_address = deviceAddress;
@@ -160,9 +162,157 @@ uint16_t MAX14661::getChannels()
160162

161163
/////////////////////////////////////////////////////////
162164
//
163-
// MUX INTERFACE
165+
// SHADOW INTERFACE
164166
//
167+
void MAX14661::shadowClear()
168+
{
169+
setShadowChannelMaskA(0x0000);
170+
setShadowChannelMaskB(0x0000);
171+
}
172+
173+
174+
void MAX14661::activateShadow()
175+
{
176+
writeRegister(MAX14661_CMD_A, 0x11);
177+
writeRegister(MAX14661_CMD_B, 0x11);
178+
}
179+
180+
////////////////////////////////////////////////////////////
181+
182+
void MAX14661::setShadowChannelMaskA(uint16_t mask)
183+
{
184+
writeRegister(MAX14661_SHDW0, mask & 0xFF);
185+
writeRegister(MAX14661_SHDW1, mask >> 8);
186+
}
187+
188+
189+
uint16_t MAX14661::getShadowChannelMaskA()
190+
{
191+
uint16_t mask = readRegister(MAX14661_SHDW1) << 8;
192+
mask |= readRegister(MAX14661_SHDW0);
193+
return mask;
194+
}
195+
196+
197+
void MAX14661::setShadowChannelMaskB(uint16_t mask)
198+
{
199+
writeRegister(MAX14661_SHDW2, mask & 0xFF);
200+
writeRegister(MAX14661_SHDW3, mask >> 8);
201+
}
202+
203+
204+
uint16_t MAX14661::getShadowChannelMaskB()
205+
{
206+
uint16_t mask = readRegister(MAX14661_SHDW3) << 8;
207+
mask |= readRegister(MAX14661_SHDW2);
208+
return mask;
209+
}
210+
211+
////////////////////////////////////////////////////////////
212+
213+
bool MAX14661::openShadowChannelA(uint8_t channel)
214+
{
215+
if (channel > 15) return false;
216+
uint8_t ch = channel;
217+
uint8_t reg = MAX14661_SHDW0;
218+
if (ch > 7)
219+
{
220+
reg = MAX14661_SHDW1;
221+
ch -= 8;
222+
}
223+
uint8_t mask = readRegister(reg);
224+
mask |= (1 << ch);
225+
writeRegister(reg, mask);
226+
return true;
227+
}
228+
229+
230+
bool MAX14661::closeShadowChannelA(uint8_t channel)
231+
{
232+
if (channel > 15) return false;
233+
uint8_t ch = channel;
234+
uint8_t reg = MAX14661_SHDW0;
235+
if (ch > 7)
236+
{
237+
reg = MAX14661_SHDW1;
238+
ch -= 8;
239+
}
240+
uint8_t mask = readRegister(reg);
241+
mask &= ~(1 << ch);
242+
writeRegister(reg, mask);
243+
return true;
244+
}
245+
246+
247+
bool MAX14661::isOpenShadowChannelA(uint8_t channel)
248+
{
249+
if (channel > 15) return false;
250+
uint8_t ch = channel;
251+
uint8_t reg = MAX14661_SHDW0;
252+
if (ch > 7)
253+
{
254+
reg = MAX14661_SHDW1;
255+
ch -= 8;
256+
}
257+
uint8_t mask = readRegister(reg);
258+
return (mask & (1 << ch)) > 0;
259+
}
260+
261+
262+
bool MAX14661::openShadowChannelB(uint8_t channel)
263+
{
264+
if (channel > 15) return false;
265+
uint8_t ch = channel;
266+
uint8_t reg = MAX14661_SHDW0;
267+
if (ch > 7)
268+
{
269+
reg = MAX14661_SHDW1;
270+
ch -= 8;
271+
}
272+
uint8_t mask = readRegister(reg);
273+
mask |= (1 << ch);
274+
writeRegister(reg, mask);
275+
return true;
276+
}
277+
278+
279+
bool MAX14661::closeShadowChannelB(uint8_t channel)
280+
{
281+
if (channel > 15) return false;
282+
uint8_t ch = channel;
283+
uint8_t reg = MAX14661_SHDW2;
284+
if (ch > 7)
285+
{
286+
reg = MAX14661_SHDW3;
287+
ch -= 8;
288+
}
289+
uint8_t mask = readRegister(reg);
290+
mask &= ~(1 << ch);
291+
writeRegister(reg, mask);
292+
return true;
293+
}
294+
295+
296+
bool MAX14661::isOpenShadowChannelB(uint8_t channel)
297+
{
298+
if (channel > 15) return false;
299+
uint8_t ch = channel;
300+
uint8_t reg = MAX14661_SHDW2;
301+
if (ch > 7)
302+
{
303+
reg = MAX14661_SHDW3;
304+
ch -= 8;
305+
}
306+
uint8_t mask = readRegister(reg);
307+
return (mask & (1 << ch)) > 0;
308+
}
309+
165310

311+
312+
/////////////////////////////////////////////////////////
313+
//
314+
// MUX INTERFACE
315+
//
166316
void MAX14661::MUXA(uint8_t channel)
167317
{
168318
uint8_t ch = channel;
@@ -306,4 +456,4 @@ int MAX14661::lastError()
306456

307457

308458

309-
// -- END OF FILE --
459+
// -- END OF FILE --

‎libraries/MAX14661/MAX14661.h‎

Lines changed: 37 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -3,20 +3,17 @@
33
// FILE: MAX14661.h
44
// AUTHOR: Rob Tillaart
55
// DATE: 2021-01-29
6-
// VERSION: 0.1.0
6+
// VERSION: 0.1.1
77
// PURPOSE: Arduino library for MAX14661 16 channel I2C multiplexer
88
// URL: https://github.com/RobTillaart/MAX14661
99
//
1010

11-
// - initial version has only support for opening and closing channels
12-
// by means of the direct access register.
13-
// - no support for shadow registers
14-
1511

1612
#include "Arduino.h"
1713
#include "Wire.h"
1814

19-
#define MAX14661_LIB_VERSION (F("0.1.0"))
15+
16+
#define MAX14661_LIB_VERSION (F("0.1.1"))
2017

2118

2219
class MAX14661
@@ -31,15 +28,15 @@ class MAX14661
3128
bool isConnected();
3229

3330
//
34-
// PAIR INTERFACE
35-
// - keeps A and B line in sync, ideal for an I2C bus
31+
// PAIR INTERFACE
32+
// - keeps A and B line in sync, ideal for an I2C bus or Serial.
3633
// - returns false if channel nr > 15
3734
//
3835
// open ==> connect
3936
bool openChannel(uint8_t channel);
4037
// close ==> disconnect
4138
bool closeChannel(uint8_t channel);
42-
// returns true if channel is opened
39+
// returns true if channel is opened
4340
bool isOpenChannel(uint8_t channel);
4441

4542
// open A and B lines of all channels
@@ -51,28 +48,41 @@ class MAX14661
5148
void setChannels(uint16_t mask);
5249
// returns channel state as bit mask
5350
uint16_t getChannels();
54-
//
5551

5652

5753
//
5854
// SHADOW INTERFACE
55+
// - experimental - not tested.
56+
// - prepares channels to be set in one activateShadow().
5957
//
60-
// TODO reg 0x10 ..0x13
61-
//
62-
// openShadow(channel)
63-
// closeShadow(channel)
64-
// sync () - reg 14 / 15 10001
58+
void shadowClear();
59+
void activateShadow(); // should we have activateShadowA() and activateShadowB() ?
60+
61+
void setShadowChannelMaskA(uint16_t mask);
62+
uint16_t getShadowChannelMaskA();
63+
void setShadowChannelMaskB(uint16_t mask);
64+
uint16_t getShadowChannelMaskB();
65+
66+
bool openShadowChannelA(uint8_t channel);
67+
bool closeShadowChannelA(uint8_t channel);
68+
bool isOpenShadowChannelA(uint8_t channel);
69+
70+
bool openShadowChannelB(uint8_t channel);
71+
bool closeShadowChannelB(uint8_t channel);
72+
bool isOpenShadowChannelB(uint8_t channel);
6573

6674

6775
//
6876
// MUX INTERFACE
69-
// - allows only one channel simultaneously
77+
// - allows only one channel simultaneously open
78+
// - opening a channel closes any other.
7079
//
7180
void MUXA(uint8_t channel); // 0..15, else ==> off
7281
uint8_t getMUXA();
7382
void MUXB(uint8_t channel); // 0..15, else ==> off
7483
uint8_t getMUXB();
7584

85+
7686
//
7787
// FULL CONTROL PER A B LINE
7888
// - selective open and close A and B
@@ -83,24 +93,32 @@ class MAX14661
8393
bool closeA(uint8_t channel);
8494
bool closeB(uint8_t channel);
8595

96+
8697
// LOW LEVEL CONTROL
98+
// optional optimizations.
99+
// uint8_t getRegister(uint8_t reg, uint8_t bit);
100+
// uint8_t setRegister(uint8_t reg, uint8_t bit);
101+
// uint8_t clrRegister(uint8_t reg, uint8_t bit);
102+
// uint16_t readRegister2(uint8_t reg); // 2 bytes
103+
// int writeRegister2(uint8_t reg, uint16_t value); // 2 bytes
104+
87105
uint8_t readRegister(uint8_t reg);
88106
int writeRegister(uint8_t reg, uint8_t value);
89107
int lastError();
90108

91109
private:
92110
uint8_t _address;
93111
TwoWire* _wire;
94-
112+
95113
int _error;
96114

97115

98-
116+
99117
// cache direct registers?
100118
};
101119

102120

103121

104122

105123

106-
// -- END OF FILE --
124+
// -- END OF FILE --

0 commit comments

Comments
 (0)