dani/CommandStation-EX
1
0
Fork 0
mirror of https://github.com/DCC-EX/CommandStation-EX.git synced 2024-11-22 15:46:14 +01:00
Code Releases Activity

revert last 3 commits

Browse Source
This commit is contained in:
Harald Barth 2024-10-06 08:00:07 +02:00
parent ea2e5ab8e9
commit ece2ac3ccf
2 changed files with 10 additions and 479 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

424
IO_EXSensorCAM.h
View File

@ -1,424 +0,0 @@
/* 2024/08/14
* © 2024, Barry Daniel ESP32-CAM revision
*
* This file is part of EX-CommandStation
*
* This 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.
*
* It 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 CommandStation. If not, see <https://www.gnu.org/licenses/>.
*/
#define driverVer 305
// v305 less debug & alpha ordered switch
// v304 static oldb0; t(##[,%%];
// v303 zipped with CS 5.2.76 and uploaded to repo (with debug)
// v302 SEND=StringFormatter::send, remove Sp(), add 'q', memcpy( .8) -> .7);
// v301 improved 'f','p'&'q' code and driver version calc. Correct bsNo calc. for 'a'
// v300 stripped & revised without expander functionality. Needs sensorCAM.h v300 AND CamParser.cpp
// v222 uses '@'for EXIORDD read. handles <NB $> and <NN $ ##>
// v216 includes 'j' command and uses CamParser rather than myFilter.h Incompatible with v203 senorCAM
// v203 added pvtThreshold to 'i' output
// v201 deleted code for compatibility with CAM pre v171. Needs CAM ver201 with o06 only
// v200 rewrite reduces need for double reads of ESP32 slave CAM. Deleted ESP32CAP.
// Inompatible with pre-v170 sensorCAM, unless set S06 to 0 and S07 to 1 (o06 & l07 say)
/*
* The IO_EXSensorCAM.h device driver can integrate with the sensorCAM device.
* It is modelled on the IO_EXIOExpander.h device driver to include specific needs of the ESP32 sensorCAM
* This device driver will configure the device on startup, along with CamParser.cpp
* interacting with the sensorCAM device for all input/output duties.
*
* #include "CamParser.h" in DCCEXParser.cpp
* #include "IO_EXSensorCAM.h" in IODevice.h
* To create EX-SensorCAM devices, define them in myHal.cpp: with
* EXSensorCAM::create(baseVpin,num_vpins,i2c_address) or
♠ * alternatively use HAL(baseVpin,numpins,i2c_address) in myAutomation.h
* also #define SENSORCAM_VPIN baseVpin in config.h
*
* void halSetup() {
* // EXSensorCAM::create(vpin, num_vpins, i2c_address);
* EXSensorCAM::create(700, 80, 0x11);
* }
*
* I2C packet size of 32 bytes (in the Wire library).
*/
# define DIGITALREFRESH 20000UL // min uSec delay between digital reads of digitalInputStates
#ifndef IO_EX_EXSENSORCAM_H
#define IO_EX_EXSENSORCAM_H
#define SEND StringFormatter::send
#include "IODevice.h"
#include "I2CManager.h"
#include "DIAG.h"
#include "FSH.h"
#include "CamParser.h"
/////////////////////////////////////////////////////////////////////////////////////////////////////
/*
* IODevice subclass for EX-SensorCAM.
*/
class EXSensorCAM : public IODevice {
public:
static void create(VPIN vpin, int nPins, I2CAddress i2cAddress) {
if (checkNoOverlap(vpin, nPins, i2cAddress))
new EXSensorCAM(vpin, nPins, i2cAddress);
}
static VPIN CAMBaseVpin;
private:
// Constructor
EXSensorCAM(VPIN firstVpin, int nPins, I2CAddress i2cAddress) {
_firstVpin = firstVpin;
// Number of pins cannot exceed 255 (1 byte) because of I2C message structure.
if (nPins > 80) nPins = 80;
_nPins = nPins;
_I2CAddress = i2cAddress;
addDevice(this);
}
//*************************
void _begin() {
uint8_t status;
// Initialise EX-SensorCAM device
I2CManager.begin();
if (!I2CManager.exists(_I2CAddress)) {
DIAG(F("EX-SensorCAM I2C:%s device not found"), _I2CAddress.toString());
_deviceState = DEVSTATE_FAILED;
return;
}else {
uint8_t commandBuffer[4]={EXIOINIT,(uint8_t)_nPins,(uint8_t)(_firstVpin & 0xFF),(uint8_t)(_firstVpin>>8)};
status = I2CManager.read(_I2CAddress,_inputBuf,sizeof(_inputBuf),commandBuffer,sizeof(commandBuffer));
//EXIOINIT needed to trigger and send firstVpin to CAM
if (status == I2C_STATUS_OK) {
// Attempt to get version, non-blocking results in poor placement of response. Can be blocking here!
commandBuffer[0] = '^'; //new version code
status = I2CManager.read(_I2CAddress, _inputBuf, sizeof(_inputBuf), commandBuffer, 1);
// for ESP32 CAM, read again for good immediate response version data
status = I2CManager.read(_I2CAddress, _inputBuf, sizeof(_inputBuf), commandBuffer, 1);
if (status == I2C_STATUS_OK) {
_majorVer= _inputBuf[1]/10;
_minorVer= _inputBuf[1]%10;
_patchVer= _inputBuf[2];
DIAG(F("EX-SensorCAM device found, I2C:%s, Version v%d.%d.%d"),
_I2CAddress.toString(),_majorVer, _minorVer,_patchVer);
}
}
if (status != I2C_STATUS_OK)
reportError(status);
}
}
//*************************
// Digital input pin configuration, used to enable on EX-IOExpander device and set pullups if requested.
// Configuration isn't done frequently so we can use blocking I2C calls here, and so buffers can
// be allocated from the stack to reduce RAM allocation.
bool _configure(VPIN vpin, ConfigTypeEnum configType, int paramCount, int params[]) override {
if(_verPrint) DIAG(F("_configure() driver IO_EXSensorCAM v0.%d.%d vpin: %d "), driverVer/100,driverVer%100,vpin);
_verPrint=false; //only give driver versions once
if (paramCount != 1) return false;
return true; //at least confirm that CAM is (always) configured (no vpin check!)
}
//*************************
// Analogue input pin configuration, used to enable an EX-IOExpander device.
int _configureAnalogIn(VPIN vpin) override {
DIAG(F("_configureAnalogIn() IO_EXSensorCAM vpin %d"),vpin);
return true; // NOTE: use of EXRAIL IFGTE() etc use "analog" reads.
}
//*************************
// Main loop, collect both digital and "analog" pin states continuously (faster sensor/input reads)
void _loop(unsigned long currentMicros) override {
if (_deviceState == DEVSTATE_FAILED) return;
// Request block is used for "analogue" (cmd. data) and digital reads from the sensorCAM, which
// are performed on a cyclic basis. Writes are performed synchronously as and when requested.
if (_readState != RDS_IDLE) { //expecting a return packet
if (_i2crb.isBusy()) return; // If I2C operation still in progress, return
uint8_t status = _i2crb.status;
if (status == I2C_STATUS_OK) { // If device request ok, read input data
//apparently the above checks do not guarantee a good packet! error rate about 1 pkt per 1000
//there should be a packet in _CAMresponseBuff[32]
if ((_CAMresponseBuff[0] & 0x60) >= 0x60) { //Buff[0] seems to have ascii cmd header (bit6 high) (o06)
int error = processIncomingPkt( _CAMresponseBuff, _CAMresponseBuff[0]); // '~' 'i' 'm' 'n' 't' etc
if (error>0) DIAG(F("CAM packet header(0x%x) not recognised"),_CAMresponseBuff[0]);
}else{ // Header not valid - typically replaced by bank 0 data! To avoid any bad responses set S06 to 0
// Versions of sensorCAM.h after v300 should return header for '@' of '`'(0x60) (not 0xE6)
// followed by digitalInputStates sensor state array
}
}else reportError(status, false); // report i2c eror but don't go offline.
_readState = RDS_IDLE;
}
// If we're not doing anything now, check to see if a new state table transfer, or for 't' repeat, is due.
if (_readState == RDS_IDLE) { //check if time for digitalRefresh
if ( currentMicros - _lastDigitalRead > _digitalRefresh) {
// Issue new read request for digital states.
_readCommandBuffer[0] = '@'; //start new read of digitalInputStates Table // non-blocking read
I2CManager.read(_I2CAddress,_CAMresponseBuff, 32,_readCommandBuffer, 1, &_i2crb);
_lastDigitalRead = currentMicros;
_readState = RDS_DIGITAL;
}else{ //slip in a repeat <NT n> if pending
if (currentMicros - _lasttStateRead > _tStateRefresh) // Delay for "analog" command repetitions
if (_savedCmd[2]>1) { //repeat a 't' command
for (int i=0;i<7;i++) _readCommandBuffer[i] =_savedCmd[i];
int errors = ioESP32(_I2CAddress, _CAMresponseBuff, 32, _readCommandBuffer, 7);
_lasttStateRead = currentMicros;
_savedCmd[2] -= 1; //decrement repeats
if (errors==0) return;
DIAG(F("ioESP32 error %d header 0x%x"),errors,_CAMresponseBuff[0]);
_readState = RDS_TSTATE; //this should stop further cmd requests until packet read (or timeout)
}
} //end repeat 't'
}
}
//*************************
// Obtain the bank of 8 sensors as an "analog" value
// can be used to track the position through a sequential sensor bank
int _readAnalogue(VPIN vpin) override {
if (_deviceState == DEVSTATE_FAILED) return 0;
return _digitalInputStates[(vpin - _firstVpin) / 8];
}
//*************************
// Obtain the correct digital sensor input value
int _read(VPIN vpin) override {
if (_deviceState == DEVSTATE_FAILED) return 0;
int pin = vpin - _firstVpin;
return bitRead(_digitalInputStates[pin / 8], pin % 8);
}
//*************************
// Write digital value.
void _write(VPIN vpin, int value) override {
DIAG(F("**_write() vpin %d = %d"),vpin,value);
return ;
}
//*************************
// i2cAddr of ESP32 CAM
// rBuf buffer for return packet
// inbytes number of bytes to request from CAM
// outBuff holds outbytes to be sent to CAM
int ioESP32(uint8_t i2cAddr,uint8_t *rBuf,int inbytes,uint8_t *outBuff,int outbytes) {
uint8_t status = _i2crb.status;
while( _i2crb.status != I2C_STATUS_OK){status = _i2crb.status;} //wait until bus free
status = I2CManager.read(i2cAddr, rBuf, inbytes, outBuff, outbytes);
if (status != I2C_STATUS_OK){
DIAG(F("EX-SensorCAM I2C:%s Error:%d %S"), _I2CAddress.toString(), status, I2CManager.getErrorMessage(status));
reportError(status); return status;
}
return 0; // 0 for no error != 0 for error number.
}
//*************************
//function to interpret packet from sensorCAM.ino
//i2cAddr to identify CAM# (if # >1)
//rBuf contains packet of up to 32 bytes usually with (ascii) cmd header in rBuf[0]
//sensorCmd command header byte from CAM (in rBuf[0]?)
int processIncomingPkt(uint8_t *rBuf,uint8_t sensorCmd) {
//static uint8_t oldb0; //for debug only
int k;
int b;
char str[] = "11111111";
// if (sensorCmd <= '~') DIAG(F("processIncomingPkt %c %d %d %d"),rBuf[0],rBuf[1],rBuf[2],rBuf[3]);
switch (sensorCmd){
case '`': //response to request for digitalInputStates[] table '@'=>'`'
memcpy(_digitalInputStates, rBuf+1, digitalBytesNeeded);
// if ( _digitalInputStates[0]!=oldb0) { oldb0=_digitalInputStates[0]; //debug
// for (k=0;k<5;k++) {Serial.print(" ");Serial.print(_digitalInputStates[k],HEX);}
// }
break;
case EXIORDY: //some commands give back acknowledgement only
break;
case CAMERR: //cmd format error code from CAM
DIAG(F("CAM cmd error 0xFE 0x%x"),rBuf[1]);
break;
case '~': //information from '^' version request <N v[er]>
DIAG(F("EX-SensorCAM device found, I2C:%s,CAM Version v%d.%d.%d vpins %u-%u"),
_I2CAddress.toString(), rBuf[1]/10, rBuf[1]%10, rBuf[2],(int) _firstVpin, (int) _firstVpin +_nPins-1);
DIAG(F("IO_EXSensorCAM driver v0.%d.%d vpin: %d "), driverVer/100,driverVer%100,_firstVpin);
break;
case 'f':
DIAG(F("(f %%%%) frame header 'f' for bsNo %d/%d - showing Quarter sample (1 row) only"), rBuf[1]/8,rBuf[1]%8);
SEND(&USB_SERIAL,F("<n row: %d Ref bytes: "),rBuf[2]);
for(k=3;k<15;k++)
SEND(&USB_SERIAL,F("%x%x%s"), rBuf[k]>>4, rBuf[k]&15, k%3==2 ? " " : " ");
Serial.print(" latest grab: ");
for(k=16;k<28;k++)
SEND(&USB_SERIAL,F("%x%x%s"), rBuf[k]>>4, rBuf[k]&15, (k%3==0) ? " " : " ");
Serial.print(" n>\n");
break;
case 'i': //information from i%%
k=256*rBuf[5]+rBuf[4];
DIAG(F("(i%%%%[,$$]) Info: Sensor 0%o(%d) enabled:%d status:%d row=%d x=%d Twin=0%o pvtThreshold=%d A~%d")
,rBuf[1],rBuf[1],rBuf[3],rBuf[2],rBuf[6],k,rBuf[7],rBuf[9],int(rBuf[8])*16);
break;
case 'm':
DIAG(F("(m$[,##]) Min/max: $ frames min2flip (trip) %d, maxSensors 0%o, minSensors 0%o, nLED %d,"
" threshold %d, TWOIMAGE_MAXBS 0%o"),rBuf[1],rBuf[3],rBuf[2],rBuf[4],rBuf[5],rBuf[6]);
break;
case 'n':
DIAG(F("(n$[,##]) Nominate: $ nLED %d, ## minSensors 0%o (maxSensors 0%o threshold %d)")
,rBuf[4],rBuf[2],rBuf[3],rBuf[5]);
break;
case 'p':
b=rBuf[1]-2;
if(b<4) { Serial.print("<n (p%%) Bank empty n>\n"); break; }
SEND(&USB_SERIAL,F("<n (p%%) Bank: %d "),(0x7F&rBuf[2])/8);
for (int j=2; j<b; j+=3)
SEND(&USB_SERIAL,F(" S[%d%d]: r=%d x=%d"),0x7F&rBuf[j]/8,0x7F&rBuf[j]%8,rBuf[j+1],rBuf[j+2]+2*(rBuf[j]&0x80));
Serial.print(" n>\n");
break;
case 'q':
for (int i =0; i<8; i++) str[i] = ((rBuf[2] << i) & 0x80 ? '1' : '0');
DIAG(F("(q $) Query bank %c ENABLED sensors(S%c7-%c0): %s "), rBuf[1], rBuf[1], rBuf[1], str);
break;
case 't': //threshold etc. from t## //bad pkt if 't' FF's
if(rBuf[1]==0xFF) {Serial.println("<n bad CAM 't' packet: 74 FF n>");_savedCmd[2] +=1; return 0;}
SEND(&USB_SERIAL,F("<n (t[##[,%%%%]]) Threshold:%d sensor S00:-%d"),rBuf[1],min(rBuf[2]&0x7F,99));
if(rBuf[2]>127) Serial.print("##* ");
else{
if(rBuf[2]>rBuf[1]) Serial.print("-?* ");
else Serial.print("--* ");
}
for(int i=3;i<31;i+=2){
uint8_t valu=rBuf[i]; //get bsn
if(valu==80) break; //80 = end flag
else{
SEND(&USB_SERIAL,F("%d%d:"), (valu&0x7F)/8,(valu&0x7F)%8);
if(valu>=128) Serial.print("?-");
else {if(rBuf[i+1]>=128) Serial.print("oo");else Serial.print("--");}
valu=rBuf[i+1];
SEND(&USB_SERIAL,F("%d%s"),min(valu&0x7F,99),(valu<128) ? "--* ":"##* ");
}
}
Serial.print(" >\n");
break;
default: //header not a recognised cmd character
DIAG(F("CAM packet header not valid (0x%x) (0x%x) (0x%x)"),rBuf[0],rBuf[1],rBuf[2]);
return 1;
}
return 0;
}
//*************************
// Write (analogue) 8bit (command) values. Write the parameters to the sensorCAM
void _writeAnalogue(VPIN vpin, int param1, uint8_t camop, uint16_t param3) override {
uint8_t outputBuffer[7];
int errors=0;
outputBuffer[0] = camop;
int pin = vpin - _firstVpin;
if(camop >= 0x80) { //case "a" (4p) also (3p) e.g. <N 713 210 310>
camop=param1; //put row (0-236) in expected place
param1=param3; //put column in expected place
outputBuffer[0] = 'A';
pin = (pin/8)*10 + pin%8; //restore bsNo. as integer
}
if (_deviceState == DEVSTATE_FAILED) return;
outputBuffer[1] = pin; //vpin => bsn
outputBuffer[2] = param1 & 0xFF;
outputBuffer[3] = param1 >> 8;
outputBuffer[4] = camop; //command code
outputBuffer[5] = param3 & 0xFF;
outputBuffer[6] = param3 >> 8;
int count=param1+1;
if(camop=='Q'){
if(param3<=10) {count=param3; camop='B';}
//if(param1<10) outputBuffer[2] = param1*10;
}
if(camop=='B'){ //then 'b'(b%) cmd - can totally deal with that here. (but can't do b%,# (brightSF))
if(param1>97) return;
if(param1>9) param1 = param1/10; //accept a bsNo
for(int bnk=param1;bnk<count;bnk++) {
uint8_t b=_digitalInputStates[bnk];
char str[] = "11111111";
for (int i=0;i<8;i++) if(((b<<i)&0x80) == 0) str[i]='0';
DIAG(F("(b $) Bank: %d activated byte: 0x%x%x (sensors S%d7->%d0) %s"), bnk,b>>4,b&15,bnk,bnk,str );
}
return;
}
if (outputBuffer[4]=='T') { //then 't' cmd
if(param1<31) { //repeated calls if param < 31
//for (int i=0;i<7;i++) _savedCmd[i]=outputBuffer[i];
memcpy( _savedCmd, outputBuffer, 7);
}else _savedCmd[2] = 0; //no repeats if ##>30
}else _savedCmd[2] = 0; //no repeats unless 't'
_lasttStateRead = micros(); //don't repeat until _tStateRefresh mSec
errors = ioESP32(_I2CAddress, _CAMresponseBuff, 32 , outputBuffer, 7); //send to esp32-CAM
if (errors==0) return;
else { // if (_CAMresponseBuff[0] != EXIORDY) //can't be sure what is inBuff[0] !
DIAG(F("ioESP32 i2c error %d header 0x%x"),errors,_CAMresponseBuff[0]);
}
}
//*************************
// Display device information and status.
void _display() override {
DIAG(F("EX-SensorCAM I2C:%s v%d.%d.%d Vpins %u-%u %S"),
_I2CAddress.toString(), _majorVer, _minorVer, _patchVer,
(int)_firstVpin, (int)_firstVpin+_nPins-1,
_deviceState == DEVSTATE_FAILED ? F("OFFLINE") : F(""));
}
//*************************
// Helper function for error handling
void reportError(uint8_t status, bool fail=true) {
DIAG(F("EX-SensorCAM I2C:%s Error:%d (%S)"), _I2CAddress.toString(),
status, I2CManager.getErrorMessage(status));
if (fail) _deviceState = DEVSTATE_FAILED;
}
//*************************
uint8_t _numDigitalPins = 80;
size_t digitalBytesNeeded=10;
uint8_t _CAMresponseBuff[34];
uint8_t _majorVer = 0;
uint8_t _minorVer = 0;
uint8_t _patchVer = 0;
uint8_t _digitalInputStates[10];
I2CRB _i2crb;
uint8_t _inputBuf[12];
byte _outputBuffer[8];
bool _verPrint=true;
uint8_t _readCommandBuffer[8];
uint8_t _savedCmd[8]; //for repeat 't' command
//uint8_t _digitalPinBytes = 10; // Size of allocated memory buffer (may be longer than needed)
enum {RDS_IDLE, RDS_DIGITAL, RDS_TSTATE}; // Read operation states
uint8_t _readState = RDS_IDLE;
//uint8_t cmdBuffer[7]={0,0,0,0,0,0,0};
unsigned long _lastDigitalRead = 0;
unsigned long _lasttStateRead = 0;
unsigned long _digitalRefresh = DIGITALREFRESH; // Delay refreshing digital inputs for 10ms
const unsigned long _tStateRefresh = 120000UL; // Delay refreshing repeat "tState" inputs
enum {
EXIOINIT = 0xE0, // Flag to initialise setup procedure
EXIORDY = 0xE1, // Flag we have completed setup procedure, also for EX-IO to ACK setup
CAMERR = 0xFE
};
};
#endif

65
myHal.cpp_example.txt
View File

@ -18,15 +18,13 @@
// Include devices you need.
#include "IODevice.h"
//#include "IO_HALDisplay.h" // Auxiliary display devices (LCD/OLED)
//#include "IO_HCSR04.h" // Ultrasonic range sensor
//#include "IO_VL53L0X.h" // Laser time-of-flight sensor
//#include "IO_DFPlayer.h" // MP3 sound player
//#include "IO_HCSR04.h" // Ultrasonic range sensor
//#include "IO_VL53L0X.h" // Laser time-of-flight sensor
//#include "IO_DFPlayer.h" // MP3 sound player
//#include "IO_TouchKeypad.h // Touch keypad with 16 keys
//#include "IO_EXTurntable.h" // Turntable-EX turntable controller
//#include "IO_EXFastClock.h" // FastClock driver
//#include "IO_EXTurntable.h" // Turntable-EX turntable controller
//#include "IO_EXFastClock.h" // FastClock driver
//#include "IO_PCA9555.h" // 16-bit I/O expander (NXP & Texas Instruments).
//#include "IO_I2CDFPlayer.h" // DFPlayer over I2C
#include "IO_EXSensorCAM.h" // sensorCAM driver
//==========================================================================
// The function halSetup() is invoked from CS if it exists within the build.
@ -36,8 +34,6 @@
void halSetup() {
// I2CManager.setClock(100000); //to set i2c bus clock rate
//=======================================================================
// The following directives define auxiliary display devices.
// These can be defined in addition to the system display (display
@ -238,31 +234,6 @@ void halSetup() {
// DFPlayer::create(10000, 10, Serial1);
//=======================================================================
// Play mp3 files from a Micro-SD card, using a DFPlayer MP3 Module on a SC16IS750/SC16IS752 I2C UART
//=======================================================================
// DFPlayer via NXP SC16IS752 I2C Dual UART.
// I2C address range 0x48 - 0x57
//
// Generic format:
// I2CDFPlayer::create(1st vPin, vPins, I2C address, xtal);
// Parameters:
// 1st vPin : First virtual pin that EX-Rail can control to play a sound, use PLAYSOUND command (alias of ANOUT)
// vPins : Total number of virtual pins allocated (1 vPin is supported currently)
// 1st vPin for UART 0
// I2C Address : I2C address of the serial controller, in 0x format
// xtal : 0 for 1.8432Mhz, 1 for 14.7456Mhz
//
// The vPin is also a pin that can be read with the WAITFOR(vPin) command indicating if the DFPlayer has finished playing a track
//
// I2CDFPlayer::create(10000, 1, 0x48, 1);
//
// Configuration example on a multiplexer
// I2CDFPlayer::create(10000, 1, {I2CMux_0, SubBus_0, 0x48}, 1);
//=======================================================================
// 16-pad capacitative touch key pad based on TP229 IC.
//=======================================================================
@ -314,13 +285,12 @@ void halSetup() {
//=======================================================================
// The parameters are:
// firstVpin = First available Vpin to allocate
// numPins= Number of Vpins to allocate, can be either 1 to 3
// i2cAddress = Available I2C address (default 0x67)
// numPins= Number of Vpins to allocate, can be either 1 or 2
// i2cAddress = Available I2C address (default 0x70)
//RotaryEncoder::create(firstVpin, numPins, i2cAddress);
//RotaryEncoder::create(700, 1, 0x67);
//RotaryEncoder::create(700, 2, 0x67);
//RotaryEncoder::create(700, 3, 0x67);
//RotaryEncoder::create(700, 1, 0x70);
//RotaryEncoder::create(701, 2, 0x71);
//=======================================================================
// The following directive defines an EX-FastClock instance.
@ -335,22 +305,7 @@ void halSetup() {
// EXFastClock::create(0x55);
//=======================================================================
// The following directive defines an ESP32-CAM instance.
//=======================================================================
// EXSensorCAM::create(VPIN, Number of VPINs, I2C Address)
//
// The parameters are:
// VPIN=an available Vpin as start of block of consecutive sensors (up to 80)
// #define SENSORCAM_VPIN0 #00 in config.h if not using 700.
// Number of VPINs=pin count (must not exceed 80)
// I2C address=an available I2C address (default 0x11)
//
// EXSensorCAM::create(700, 80, 0x11); //preference is now to use HAL(700 80 0x11) in myAutomation.h
//EXSensorCAM::create(600, 80, 0x12); //alternate or second CAM device address creation
//preference is now to use HAL(EXSensorCAM 700 80 0x11) in myAutomation.h rather than :create
}
}
#endif