конфликт с разными устройствами i2c

Я пытаюсь установить связь с двумя компонентами i2c, используя Arduino Nano: некоторые ADS1115 и некоторые датчики расхода i2c подключены к разным < href="https://learn.adafruit.com/adafruit-tca9548a-1-to-8-i2c-multiplexer-breakout/wiring-and-test">мультиплексор i2c, но они кажутся конфликтующими .

Некоторые датчики ADS1115 имеют адреса 0x49, как и все датчики расхода. Полный код работает, включая создание и инициализацию ads1115, но если я затем попытаюсь прочитать их, я не получу почти никаких данных от датчиков потока (они просто считывают 0 или близки к тому, когда они должны считывать около 8192). при нулевом расходе). Любая помощь или предложения высоко ценятся!

Я разместил полный код внизу, так как он довольно длинный, и я все равно продолжаю его изменять, но важные части здесь:

ADS1115:

Adafruit_ADS1115();  //Создаем экземпляр ADS1115 с адресом по умолчанию (0x48)
ads1115.begin();  // Инициализировать ads1115
int16_t readADC_Differential_0_1(void);  //Выполнить дифференциальное аналого-цифровое преобразование напряжения между каналами 0 и 1.

Мультиплексор tca9548a:

#define TCAADDR 0x70

void tcaselect(uint8_t i) {
  if (i > 7) return;

  Wire.beginTransmission(TCAADDR);
  Wire.write(1 << i);
  Wire.endTransmission();  
}

tcaselect(i);

Датчики потока Zephyr:

void getflows (int sensor, float range, float flowreading) {
Wire.requestFrom(0x49, 2);
while (Wire.available())   // ведомое устройство может отправить меньше, чем запрошено
  {
    int flowdata = Wire.read();    // получаем байт как символ
    //Serial.println(flowdata);
    flowdata = flowdata << 8;
    flowdata |= Wire.read();    // получаем байт как символ
    //Serial.println(flowdata);
    flowreading = range * ((flowdata / 16384.0) - 0.5) / 0.4;
    //Serial.print("датчик 3 потока = "); Serial.println (поток3);
    //Серийный.println(); // напечатать символ
    //Серийный.println();
  }
  delay(20);

Полный код:

#include <ModbusRtu.h>
#include <Wire.h>
#include <Adafruit_ADS1015.h>
#include <SPI.h>
#include <PID_v1.h>
#include <math.h>

//модбус
#define ID          1
#define TXEN        2

//контакты клапана TTL и DAC CS - номера соответствуют номерам драйверов клапана в ригбоксе
//Токовые соединения - O2high = 1 = A, CO2 = 2 = B, O2low = 3 = C
#define ATTL       5
#define CTTL       4
#define BTTL       3

#define BCS         7
#define CCS         8
#define ACS         9

#define tempfreq    5
#define tempnum     3
////////////////////////////////////////////
//Диапазоны датчиков - ОПРЕДЕЛЯЕТСЯ ПОЛЬЗОВАТЕЛЕМ
float DACrange = 3500.0; //мл/мин

int POutrange = 2000; //мбар абс.
int PInrange = 2000; //мбар абс.
////////////////////////////////////////////

// мультиплексор АЦП
#define TCAADDR      0x70
#define TCA2ADDR      0x77

//Ввод значений резисторов
float         T1R2  =  2320.0;
float         FPR1  =  3090.0;
float         FPR2  =  12010.0;

//максимальное отклонение от заданного значения перед ПИД-циклом
int maxdif    =  5;
//максимальное отклонение от заданного значения в конце ПИД-цикла
int PIDdif    =  1;

////////////////////////////////////////////
//МАТЕМАТИКА
//масштаб
long FPscale = 10000000;
long flowscale = 10000000;
//vrefs - с примененными коэффициентами масштабирования
float vref   = 2.5; //tмасштабировано
float Tref   = 1.0; //tмасштабировано
long FPref  = 20000000; //FPмасштабируется
//деления - интегрированы в диапазон датчика в длинном формате для расчетов
float FPdiv = (FPR1 + FPR2) / FPR2;
int Vmax = 5;

int Poutfac = (int)((POutrange / Vmax) * FPdiv);
int Pinfac = (int)((PInrange / Vmax) * FPdiv);

//АЦП мВ/бит
float Tbit = 0.00003125;
long FPbit = 625; //- с коэффициентом масштабирования 10 000 000

//константы Штейнхарта датчика температуры
double sA = 0.001462146;
double sB = 0.0002393355;
double sC = 0.0000000963049;

//объявить удерживающие константы
int16_t hT1 = 0;
int16_t hT2 = 0;
int16_t hT3 = 0;
int16_t hT4 = 0;
int16_t hT5 = 0;
int16_t hT6 = 0;
int16_t hT7 = 0;
int16_t hT8 = 0;

int16_t hFP1 = 0;
int16_t hFP2 = 0;
int16_t hFP3 = 0;
int16_t hFP4 = 0;
int16_t hFP5 = 0;
int16_t hFP6 = 0;
int16_t hFP7 = 0;
int16_t hFP8 = 0;

//промежуточные продукты
int i = 0;
int j = 0;
int b[3];
int loopnum = tempfreq;
float tres = 0.0;
double treslog = 0.0;
long lconv = 0;
int16_t O2dif = 0;
int16_t CO2dif = 0;
int16_t N2dif = 0;
int16_t gasdif = 0;
int gasreading = 0;
int hFP = 0;
uint16_t val = 0;
bool truePID;
bool trueAPID = false;
bool trueBPID = false;
bool trueCPID = false;
int (*gasreadfunc)();

int flowdata = 0;
float flow3 = 0.0;
float flow2 = 0.0;
float flow4 = 0.0;
float flow5 = 0.0;
long reading = 0;

uint16_t Setpt;
int CS;
int TTL;

// инициализируем вложенные функции
//аннулировать каждыйPID(int16_t (*)(), int16_t, int, bool);

enum
{
  Error1,    //КАНАЛ 0 //0
  Error2,    //КАНАЛ 1
  FP2a,      //КАНАЛ 2 //1
  FP2b,      //3 КАНАЛ
  T1a,       //КАНАЛ 4 //2
  T1b,       // 5 КАНАЛ
  T2a,       //КАНАЛ 6 //3
  T2b,       //7 КАНАЛ
  T3a,       //КАНАЛ 8 //4
  T3b,       //9 КАНАЛ
  T4a,       //КАНАЛ 10 //5
  T4b,       //11 КАНАЛ
  Flow2a,    //КАНАЛ 12 //6
  Flow2b,    //13 КАНАЛ
  Flow3a,    //КАНАЛ 14 //7
  Flow3b,    // 15 КАНАЛ
  Flow4a,    //КАНАЛ 16 //8
  Flow4b,    //17 КАНАЛ
  Flow5a,    //КАНАЛ 18 //9
  Flow5b,    // 19 КАНАЛ
  A_set,     //КАНАЛ 20
  B_set,     //КАНАЛ 21
  C_set,     //КАНАЛ 22
  HOLDING_REGS_SIZE
};

unsigned int holdingRegs[HOLDING_REGS_SIZE];

/**
    Modbus object declaration
    u8id : node id = 0 for master, = 1..247 for slave
    u8serno : serial port (use 0 for Serial)
    u8txenpin : 0 for RS-232 and USB-FTDI
                 or any pin number > 1 for RS-485
*/
Modbus slave(1, 0, TXEN); // это ведомый @1 и RS-485

//Создаем АЦП по адресам
Adafruit_ADS1115 adcOne(0x48);
Adafruit_ADS1115 adcTwo(0x49);
Adafruit_ADS1115 adcThree(0x4B);
Adafruit_ADS1115 adcFour(0x4A);

// SPI - настраиваем скорость, порядок данных и режим данных
SPISettings settings(4000000, MSBFIRST, SPI_MODE0);

//ПИД
// Определяем переменные, к которым мы будем подключаться
double Output, Setpoint, Input;

//Определяем агрессивные и консервативные параметры настройки
double aggKp = 4, aggKi = 0.2, aggKd = 1;
double consKp = 1, consKi = 0.05, consKd = 0.25;

//Указываем ссылки и параметры начальной настройки
PID myPID(&Input, &Output, &Setpoint, aggKp, aggKi, aggKd, DIRECT);

////////////////////////////////////////////////// /////////////////////////////////////////////
void tcaselect(uint8_t i, int address) {
  if (i > 7) return;

  Wire.beginTransmission(address);
  Wire.write(1 << i);
  Wire.endTransmission();
}

void setup() {
  ////////////////////////////////////////////////// /////////////////////////////////////////////
  // ЦАП
  pinMode (BCS, OUTPUT);
  digitalWrite(BCS, HIGH);
  pinMode (CCS, OUTPUT);
  digitalWrite(CCS, HIGH);
  pinMode (ACS, OUTPUT);
  digitalWrite(ACS, HIGH);

  pinMode (ATTL, OUTPUT);
  digitalWrite(ATTL, LOW);
  pinMode (CTTL, OUTPUT);
  digitalWrite(CTTL, LOW);
  pinMode (BTTL, OUTPUT);
  digitalWrite(BTTL, LOW);
  ////////////////////////////////////////////////// /////////////////////////////////////////////
  //АЦП
  adcOne.begin();
  adcTwo.begin();
  adcThree.begin();
  adcFour.begin();

  // усиление 2/3x +/- 6,144 В 1 бит = 0,1875 мВ (по умолчанию)
  // ads1015.setGain(GAIN_ONE); // 1x усиление +/- 4,096 В 1 бит = 0,125 мВ
  // ads1015.setGain(GAIN_TWO); // 2-кратное усиление +/- 2,048 В 1 бит = 0,0625 мВ
  // ads1015.setGain(GAIN_FOUR); // 4-кратное усиление +/- 1,024 В 1 бит = 0,03125 мВ
  // ads1015.setGain(GAIN_EIGHT); // 8-кратное усиление +/- 0,512 В 1 бит = 0,015625 мВ
  // ads1015.setGain(GAIN_SIXTEEN); // 16-кратное усиление +/- 0,256 В 1 бит = 0,0078125 мВ

  ////////////////////////////////////////////////// /////////////////////////////////////////////
  //Показания серийного номера датчика расхода
  getflows(2, 750.0, flow2);
  getflows(3, 400.0, flow3);
  getflows(4, 50.0, flow4);
  getflows(5, 400.0, flow5);

  ////////////////////////////////////////////////// /////////////////////////////////////////////
  //ПИД
  // инициализируем переменные, с которыми мы связаны
  Input = 0;
  Setpoint = 0;

  //Определяем агрессивные и консервативные параметры настройки
  float aggKp = 4, aggKi = 0.2, aggKd = 1;
  float consKp = 1, consKi = 0.05, consKd = 0.25;

  // включаем PID
  myPID.SetMode(AUTOMATIC);
  ////////////////////////////////////////////////// /////////////////////////////////////////////
  // начинаем связь по Modbus
  slave.begin(115200);

  // инициализируем SPI:
  SPI.begin();

  //Серийный.начало(115200);
  gettemperatures();

  holdingRegs[Error2] = 0;
}

void loop() {
  //каждая tempfreq no циклов, она также считывает датчики температуры
  loopnum++;
  if (loopnum > tempfreq) {
    gettemperatures();
    loopnum = 0;
  }

  holdingRegs[Error1] = 0;//установить 0 для нормальной работы, 65535 = ПИД-управление
  //Serial.print("Ошибка регистрации 1"); Serial.print(holdingRegs[Error1]); Serial.print(",holdRegs[Error2]"); Serial.println(holdingRegs[Error2]);

  //датчики расхода и давления
  tcaselect(0, TCAADDR);
  adcOne.setGain(GAIN_TWO);
  //adcTwo.setGain(GAIN_TWO);
  //adcThree.setGain(GAIN_TWO);
  //adcFour.setGain(GAIN_TWO);

  //hFP1 = adcOne.readADC_Differential_0_1();
  hFP2 = adcOne.readADC_Differential_2_3();
  //hFP3 = adcTwo.readADC_Differential_0_1();
  //hFP4 = adcTwo.readADC_Differential_2_3();
  //hFP5 = adcThree.readADC_Differential_0_1();
  //hFP6 = adcThree.readADC_Differential_2_3();
  //hFP7 = adcFour.readADC_Differential_0_1();
  //hFP8 = adcFour.readADC_Differential_2_3();

  //FPconv(hFP1, &holdingRegs[FP1a], &holdingRegs[FP1b], Pinfac);
  //Serial.print("hFP1: "); Serial.println(hFP1);
  FPconv(hFP2, &holdingRegs[FP2a], &holdingRegs[FP2b], Poutfac);
  //Serial.print("hFP2: "); Serial.println(hFP2);
  //FPconv(hFP3, &holdingRegs[FP3a], &holdingRegs[FP3b], CO2fac);
  //Serial.print("hFP3: "); Serial.println(hFP3);
  //FPconv(hFP4, &holdingRegs[FP4a], &holdingRegs[FP4b], O2fac);
  //Serial.print("hFP4: "); Serial.println(hFP4);
  //FPconv(hFP5, &holdingRegs[FP5a], &holdingRegs[FP5b], Fifac);
  //Serial.print("hFP5: "); Serial.println(hFP5);
  //FPconv(hFP6, &holdingRegs[FP6a], &holdingRegs[FP6b], N2fac);
  //Serial.print("hFP6: "); Serial.println(hFP6);
  //FPconv(hFP7, &holdingRegs[FP7a], &holdingRegs[FP7b], Fifac);
  //Serial.print("hFP7: "); Serial.println(hFP7);
  //FPconv(hFP8, &holdingRegs[FP8a], &holdingRegs[FP8b], Fifac);
  //Serial.print("hFP8: "); Serial.println(hFP8);
  //Серийный.println("");

  getflows(2, 750.0, flow2);
  getflows(3, 400.0, flow3);
  getflows(4, 50.0, flow4);
  getflows(5, 400.0, flow5);

  flowconvert();

  //связь Modbus
  slave.poll( holdingRegs, HOLDING_REGS_SIZE );

  checkgasflow(1);
  checkgasflow(2);
  checkgasflow(3);

  // задержка (1000);
}

void gasread(int gastoread) {
  switch (gastoread) {
    case 1: //O2high
      getflows(3, 400.0, flow3);
      gasreading = flow2;
      Setpt = A_set;
      CS = ACS;
      TTL = ATTL;
      truePID = trueAPID;
      //вернуть показания газа;
      break;
    case 2: //CO2
      getflows(4, 50.0, flow4);
      Setpt = B_set;
      CS = BCS;
      TTL = BTTL;
      truePID = trueBPID;
      //вернуть показания газа;
      break;
    case 3: //O2низкий
      getflows(5, 400.0, flow5);
      Setpt = C_set;
      CS = CCS;
      TTL = CTTL;
      truePID = trueCPID;
      //вернуть показания газа;
      break;
  }
}

void checkgasflow(int gastoread) {
  gasread(gastoread);
  Input = (double)gasreading;
  Setpoint = (double)Setpt;
  gasdif = Input - Setpoint;
  if (abs(gasdif) < PIDdif) {
    truePID = 1;
    return;
  }
  else {
    GasPID();
  }
}

void GasPID() {
  holdingRegs[Error1] = 65535; //установите 0 для нормальной работы, 65535 = ПИД-регулятор

  //связь Modbus
  slave.poll( holdingRegs, HOLDING_REGS_SIZE );

  do {
    eachPID(1);
    eachPID(2);
    eachPID(3);
  } while (!trueAPID || !trueBPID || !trueCPID);

  holdingRegs[Error1] = 0;
}

void eachPID(int gastoread) {
  gasread(gastoread);
  Input = (double)gasreading;
  Setpoint = (double)Setpt;
  gasdif = Input - Setpoint;
  if (abs(gasdif) < PIDdif) {
    truePID = 1;
    return;
  }
  else if (abs(gasdif) < 10)
  { //мы близки к заданному значению, используйте консервативные параметры настройки
    truePID = 0;
    myPID.SetTunings(consKp, consKi, consKd);
  }
  else
  {
    //мы далеки от уставки, используйте агрессивные параметры настройки
    truePID = 0;
    myPID.SetTunings(aggKp, aggKi, aggKd);
  }
  myPID.Compute();
  val = (uint16_t)Output;
  DACspi(CS, val, TTL);
}

void FPconv (int16_t FPin, uint16_t *hRega, uint16_t *hRegb, int FPfac) {
  lconv = (FPfac * (FPref + (long)(FPbit * FPin)));
  memcpy((uint8_t *)hRega, (uint8_t *)&lconv, 2);
  memcpy((uint8_t *)hRegb, (uint8_t *)&lconv + 2, 2);
}

void Flowconv (float FPin, uint16_t *hRega, uint16_t *hRegb) {
  lconv = (long)(FPin*flowscale);
  memcpy((uint8_t *)hRega, (uint8_t *)&lconv, 2);
  memcpy((uint8_t *)hRegb, (uint8_t *)&lconv + 2, 2);
}

void Tconv (int16_t Tin, uint16_t *hRega, uint16_t *hRegb) {
  tres = T1R2 * ((vref / (Tref + (Tbit * Tin))) - 1.0);
  treslog = log(tres);
  lconv = lround(10000000.0 * ((1.0 / (sA + sB * treslog + sC * (pow(treslog, 3.0)))) - 273.15));
  memcpy((uint8_t *)hRega, (uint8_t *)&lconv, 2);
  memcpy((uint8_t *)hRegb, (uint8_t *)&lconv + 2, 2);
}

void DACspi(uint16_t CS, uint16_t val, int TTL) {
  digitalWrite(CS, LOW);
  if (val > 0) {
    digitalWrite(TTL, HIGH);
  }
  else {
    digitalWrite(TTL, LOW);
  }
  SPI.transfer16(val);
  digitalWrite(CS, HIGH);
}

void gettemperatures() {
  tcaselect(6, TCAADDR);
  adcOne.setGain(GAIN_FOUR);
  adcTwo.setGain(GAIN_FOUR);
  adcThree.setGain(GAIN_FOUR);
  adcFour.setGain(GAIN_FOUR);
  //температурные датчики - 2 последовательных показания, чтобы пины сначала прогрелись
  for (i = 0; i < tempnum; i++) {
    hT1 = adcOne.readADC_Differential_0_1();
  }
  for (i = 0; i < tempnum; i++) {
    hT2 = adcOne.readADC_Differential_2_3();;
  }
  for (i = 0; i < tempnum; i++) {
    hT3 = adcTwo.readADC_Differential_0_1();
  }
  for (i = 0; i < tempnum; i++) {
    hT4 = adcTwo.readADC_Differential_2_3();
  }
  //для (i = 0; i < tempnum; i++) {
  // hT5 = adcThree.readADC_Differential_0_1();
 // }
  //для (i = 0; i < tempnum; i++) {
  // hT6 = adcThree.readADC_Differential_2_3();
  //}
  //для (i = 0; i < tempnum; i++) {
  // hT7 = adcFour.readADC_Differential_0_1();
  //}
  //для (i = 0; i < tempnum; i++) {
  // hT8 = adcFour.readADC_Differential_2_3();
  //}

  Tconv(hT1, &holdingRegs[T1a], &holdingRegs[T1b]);
  //Serial.print("hT1: "); Серийный.println(hT1);
  Tconv(hT2, &holdingRegs[T2a], &holdingRegs[T2b]);
  //Serial.print("hT2: "); Серийный.println(hT2);
  Tconv(hT3, &holdingRegs[T3a], &holdingRegs[T3b]);
  //Serial.print("hT3: "); Серийный.println(hT3);
  Tconv(hT4, &holdingRegs[T4a], &holdingRegs[T4b]);
  //Serial.print("hT4: "); Серийный.println(hT4);
  //Tconv(hT5, &holdingRegs[T5a], &holdingRegs[T5b]);
  //Serial.print("hT5: "); Серийный.println(hT5);
  //Tconv(hT6, &holdingRegs[T6a], &holdingRegs[T6b]);
  //Serial.print("hT6: "); Серийный.println(hT6);
  //Tconv(hT7, &holdingRegs[T7a], &holdingRegs[T7b]);
  //Serial.print("hT7: "); Серийный.println(hT7);
  //Tconv(hT8, &holdingRegs[T8a], &holdingRegs[T8b]);
  //Serial.print("hT8: "); Серийный.println(hT8);
}

void getflows (int sensor, float range, float flowreading) {
  tcaselect(sensor, TCA2ADDR);
  Wire.requestFrom(0x49, 2);

  while (Wire.available())   // ведомое устройство может отправить меньше, чем запрошено
  {
    int flowdata = Wire.read();    // получаем байт как символ
    //Serial.println(flowdata);
    flowdata = flowdata << 8;
    flowdata |= Wire.read();    // получаем байт как символ
    //Serial.println(flowdata);
    flowreading = range * ((flowdata / 16384.0) - 0.5) / 0.4;
    //Serial.print("датчик 3 потока = "); Serial.println (поток3);
    //Серийный.println(); // напечатать символ
    //Серийный.println();
  }
  delay(20);
}

void flowconvert (){

  Flowconv(flow2, &holdingRegs[Flow2a], &holdingRegs[Flow2b]);
  //Serial.print("hFP1: "); Serial.println(hFP1);
  Flowconv(flow3, &holdingRegs[Flow3a], &holdingRegs[Flow3b]);
  //Serial.print("hFP1: "); Serial.println(hFP1);
  Flowconv(flow4, &holdingRegs[Flow4a], &holdingRegs[Flow4b]);
  //Serial.print("hFP1: "); Serial.println(hFP1);
  Flowconv(flow5, &holdingRegs[Flow5a], &holdingRegs[Flow5b]);
  //Serial.print("hFP1: "); Serial.println(hFP1);
}

/*void FPconv (int16_t FPin, uint16_t *hRega, uint16_t *hRegb, int FPfac, long FPcal) {
  lconv = (FPfac * (FPcal + FPref + (long)(FPbit * FPin)));
  memcpy((uint8_t *)hRega, (uint8_t *)&lconv, 2);
  memcpy((uint8_t *)hRegb, (uint8_t *)&lconv + 2, 2);
  }*/

/*void GasPID() {
  holdingRegs[Error1] = 65535; //установите 0 для нормальной работы, 65535 = ПИД-регулятор

  //связь Modbus
  slave.poll( holdingRegs, HOLDING_REGS_SIZE );

  tcaselect(0);

  do {
    eachPID(O2read, O2_set, BCS, trueAPID);
    eachPID(CO2read, CO2_set, CCS, trueBPID);
    eachPID(N2read, N2_set, ACS, trueCPID);
  } while (!trueAPID || !trueBPID || !trueCPID);

  trueAPID = !trueAPID;
  trueBPID = !trueBPID;
  trueCPID = !trueCPID;
  }*/

/*
  void eachPID(int16_t gasReadfunc(), int16_t Setpt, int CS, bool truePID, int TTL) {
  Setpoint = (double)Setpt;

  for (i = 0; i < 3; i++) {
    hFP = (*gasreadfunc)();
  }
  Input = (double)hFP;
  gasdif = Input - Setpoint;
  if (abs(gasdif) < PIDdif) {
    truePID = 1;
    return;
  }
  else if (abs(gasdif) < 10)
  { //мы близки к заданному значению, используйте консервативные параметры настройки
    myPID.SetTunings(consKp, consKi, consKd);
  }
  else
  {
    //мы далеки от уставки, используйте агрессивные параметры настройки
    myPID.SetTunings(aggKp, aggKi, aggKd);
  }
  myPID.Compute();
  val = (uint16_t)Output;
  DACspi(CS, val, TTL);
  }*/

/*//Соединения
  int16_t O2read() {
  gasread = adcOne.readADC_Differential_0_1();
  return gasread;
  }
  int16_t CO2read() {
  gasread = adcOne.readADC_Differential_2_3();
  return gasread;
  }
  int16_t N2read() {
  gasread = adcTwo.readADC_Differential_0_1();
  return gasread;
  }*/

/*// Связь SPI с ЦАП
  DACspi(BCS, holdingRegs[CO2_set], BTTL); //контроллер СО2
  DACspi(CCS, holdingRegs[N2_set], CTTL); //Контроллер N2
  DACspi(ACS, holdingRegs[O2_set], ATTL); //Контроллер O2*/