#define STATUS - the same name of constantly was useed on ESP8266/ESP32 in ADS1256.h library

### Basic Infos

This code below works correctly on Arduino UNO/Leonardo but not on ESP8266/ESP32 platform.

#### Hardware
Hardware: ?ESP-12E/ESP32 dev boards/D1 R2 WiFi ESP8266 WeMos

### Settings in IDE

Module: ESP8266
Flash Size: 4MB
CPU Frequency: 80Mhz
Flash Mode: qio
Flash Frequency: 40Mhz?
Upload Using: OTA / SERIAL / USB
Arduino 1.8.1

### Sketch

// Arudino Sample Code to use ADS1256 library
// Read 4 sensor using effiecient input cycling
// Written by Adien Akhmad, August 2015

#include
#include

byte DRDYPIN = 2;
byte CSPIN = 7;

// set pins
//#define SELPIN 7 //
#define DATAOUT 12 // MISO
#define DATAIN 11 // MOSI
#define SPICLOCK 13 //

float clockMHZ = 7.68; // crystal frequency used on ADS1256
int lo = 300;
float myarray[300];

// Define ADS1256 PIN that is connected to Arduino
ADS1256 adc(clockMHZ,DRDYPIN,CSPIN,2.5); // RESETPIN is permanently tied to 3.3v

/* Variable to store sensor reading
sensor1 = connected on AIN0 - AIN1
sensor2 = connected on AIN2 - AIN3
sensor3 = connected on AIN4 - AIN5
sensor4 = connected on AIN6 - AIN7
*/

float sensor1, sensor2, sensor3, sensor4;

void setup()
{
Serial.begin(9600);
delay(10000);
Serial.println("Starting ADC");
delay(1000);
// rozdzielczość
//PGAmulti_1 0.0000005960464832810452 //PGA-1 ±5V /16777215
//PGAmulti_2 0.0000002980232416405226 //PGA-2 ±2.5V /16777215
//PGAmulti_4 0.0000001490116208202613 //PGA-4 ±1.25V /16777215
//PGAmulti_8 0.00000007450581041013064 //PGA-8 ±0.625V /16777215
//PGAmulti_16 0.00000003725290520506532 //PGA-16 ±312.5mV /16777215
//PGAmulti_32 0.00000001862645260253266 //PGA-32 ±156.25mV /16777215
//PGAmulti_64 0.000000009313226301266331 //PGA-64 ±78.125mV /16777215

// start the ADS1256 with data rate of 15 SPS
// other data rates:
// ADS1256_DRATE_30000SPS
// ADS1256_DRATE_15000SPS
// ADS1256_DRATE_7500SPS
// ADS1256_DRATE_3750SPS
// ADS1256_DRATE_2000SPS
// ADS1256_DRATE_1000SPS
// ADS1256_DRATE_500SPS
// ADS1256_DRATE_100SPS
// ADS1256_DRATE_60SPS
// ADS1256_DRATE_50SPS
// ADS1256_DRATE_30SPS
// ADS1256_DRATE_25SPS
// ADS1256_DRATE_15SPS
// ADS1256_DRATE_10SPS
// ADS1256_DRATE_5SPS
// ADS1256_DRATE_2_5SPS
//
// NOTE : Data Rate vary depending on crystal frequency. Data rates listed below assumes the crystal frequency is 7.68Mhz
// for other frequency consult the datasheet.

adc.begin(ADS1256_DRATE_30000SPS,ADS1256_GAIN_1,false);
Serial.println("ADC Started");

// Set MUX Register to AINO and AIN1
adc.switchChannel(0);
}

void loop()
{

for(int i=1; i<=lo; i++){
adc.waitDRDY(); // wait for DRDY to go low before changing multiplexer register
adc.switchChannel(0);
sensor1 = adc.readCurrentChannel(); // DOUT arriving here are from MUX AIN0 and AIN1
//Serial.println(sensor1,10);
myarray[i] = sensor1;
delayMicroseconds(150);
// delay(1);
}

for(int n=1; n<=lo; n++){
sensor1 = myarray[n];
Serial.println(sensor1,10) ;
// Serial.print("\t");
delay(50);
}

//print the result.
//Serial.print("data sensor 1: ");
//Serial.print(sensor1,10);

//Serial.println("");

delay(24000);
}

### LIB

file: ADS1256.cpp

`/*
ADS1256.h - Arduino Library for communication with Texas Instrument
ADS1256 ADC
Written by Adien Akhmad, August 2015
*/

#ifndef ADS1256_h
#define ADS1256_h

// ADS1256 Register
#define STATUS 0x00
#define MUX 0x01
#define ADCON 0x02
#define DRATE 0x03
#define IO 0x04
#define OFC0 0x05
#define OFC1 0x06
#define OFC2 0x07
#define FSC0 0x08
#define FSC1 0x09
#define FSC2 0x0A

// ADS1256 Command
#define WAKEUP 0x00
#define RDATA 0x01
#define RDATAC 0x03
#define SDATAC 0x0f
#define RREG 0x10
#define WREG 0x50
#define SELFCAL 0xF0
#define SELFOCAL 0xF1
#define SELFGCAL 0xF2
#define SYSOCAL 0xF3
#define SYSGCAL 0xF4
#define SYNC 0xFC
#define STANDBY 0xFD
#define RESET 0xFE

// define multiplexer codes
#define ADS1256_MUXP_AIN0 0x00
#define ADS1256_MUXP_AIN1 0x10
#define ADS1256_MUXP_AIN2 0x20
#define ADS1256_MUXP_AIN3 0x30
#define ADS1256_MUXP_AIN4 0x40
#define ADS1256_MUXP_AIN5 0x50
#define ADS1256_MUXP_AIN6 0x60
#define ADS1256_MUXP_AIN7 0x70
#define ADS1256_MUXP_AINCOM 0x80

#define ADS1256_MUXN_AIN0 0x00
#define ADS1256_MUXN_AIN1 0x01
#define ADS1256_MUXN_AIN2 0x02
#define ADS1256_MUXN_AIN3 0x03
#define ADS1256_MUXN_AIN4 0x04
#define ADS1256_MUXN_AIN5 0x05
#define ADS1256_MUXN_AIN6 0x06
#define ADS1256_MUXN_AIN7 0x07
#define ADS1256_MUXN_AINCOM 0x08

// define gain codes
#define ADS1256_GAIN_1 0x00
#define ADS1256_GAIN_2 0x01
#define ADS1256_GAIN_4 0x02
#define ADS1256_GAIN_8 0x03
#define ADS1256_GAIN_16 0x04
#define ADS1256_GAIN_32 0x05
#define ADS1256_GAIN_64 0x06

// define drate codes
/*
NOTE : Data Rate vary depending on crystal frequency. Data rates
listed below assumes the crystal frequency is 7.68Mhz
for other frequency consult the datasheet.
*/

#define ADS1256_DRATE_30000SPS 0xF0
#define ADS1256_DRATE_15000SPS 0xE0
#define ADS1256_DRATE_7500SPS 0xD0
#define ADS1256_DRATE_3750SPS 0xC0
#define ADS1256_DRATE_2000SPS 0xB0
#define ADS1256_DRATE_1000SPS 0xA1
#define ADS1256_DRATE_500SPS 0x92
#define ADS1256_DRATE_100SPS 0x82
#define ADS1256_DRATE_60SPS 0x72
#define ADS1256_DRATE_50SPS 0x63
#define ADS1256_DRATE_30SPS 0x53
#define ADS1256_DRATE_25SPS 0x43
#define ADS1256_DRATE_15SPS 0x33
#define ADS1256_DRATE_10SPS 0x23
#define ADS1256_DRATE_5SPS 0x13
#define ADS1256_DRATE_2_5SPS 0x03

#include "Arduino.h"
#include "SPI.h"

class ADS1256 {
public:
ADS1256(float clockspdMhz, byte DRDY, byte CS, float VREF);
ADS1256(float clockspdMhz, byte DRDY, byte CS, byte RESETPIN, float VREF);
void writeRegister(unsigned char reg, unsigned char wdata);
unsigned char readRegister(unsigned char reg);
void sendCommand(unsigned char reg);
float readCurrentChannel();
void setConversionFactor(float val);
void switchChannel(byte channel);
void switchChannel(byte AIP, byte AIN);
void begin(unsigned char drate, unsigned char gain, bool bufferenable);
void waitDRDY();
void setGain(uint8_t gain);

private:
void CSON();
void CSOFF();
unsigned long read_uint24();
long read_int32();
float read_float32();
int _tscaler;
byte _DRDY;
byte _CS;
byte _RESET;
byte _pga;
float _VREF;
float _conversionFactor;
};

#endif`

file: ADS1256.cpp

`/*
ADS1256.h - Arduino Library for communication with Texas Instrument
ADS1256 ADC
Written by Adien Akhmad, August 2015
*/

#include "ADS1256.h"
#include "Arduino.h"
#include "SPI.h"

// Use this if RESET PIN is connected to one of Arduino Digital pin
ADS1256::ADS1256(float clockspdMhz, byte DRDY, byte CS, byte RESETPIN,
float VREF) {
_tscaler = (clockspdMhz)*10;
pinMode(DRDY, INPUT);
pinMode(CS, OUTPUT);
pinMode(RESETPIN, OUTPUT);
digitalWrite(RESETPIN, HIGH);

_CS = CS;
_VREF = VREF;
_DRDY = DRDY;
_conversionFactor = 1.00;
_RESET = RESETPIN;

SPI.begin();
SPI.beginTransaction(
SPISettings(clockspdMhz / 4 * 1000000, MSBFIRST, SPI_MODE1));
}

// Use this if RESET PIN is permanently tied to HIGH

ADS1256::ADS1256(float clockspdMhz, byte DRDY, byte CS, float VREF) {
_tscaler = (clockspdMhz)*10;
pinMode(DRDY, INPUT);
pinMode(CS, OUTPUT);

_CS = CS;
_VREF = VREF;
_DRDY = DRDY;
_conversionFactor = 1.00;
_RESET = 255; // mark that this PIN is not used

SPI.begin();
SPI.beginTransaction(
SPISettings(clockspdMhz / 4 * 1000000, MSBFIRST, SPI_MODE1));
}

void ADS1256::writeRegister(unsigned char reg, unsigned char wdata) {
CSON();
SPI.transfer(WREG | reg);
SPI.transfer(0);
SPI.transfer(wdata);
delayMicroseconds(4 * 10 / _tscaler +
1); // t11 delay (4*tCLKIN) after WREG command
CSOFF();
}

unsigned char ADS1256::readRegister(unsigned char reg) {
unsigned char readValue;

CSON();
SPI.transfer(RREG | reg);
SPI.transfer(0);
delayMicroseconds(50 * 10 / _tscaler + 1); // t6 delay (50*tCLKIN)
readValue = SPI.transfer(0);
delayMicroseconds(4 * 10 / _tscaler + 1); // t11 delay after RREG command
CSOFF();

return readValue;
}

void ADS1256::sendCommand(unsigned char reg) {
CSON();
waitDRDY();
SPI.transfer(reg);
delayMicroseconds(4 * 10 / _tscaler + 1);
CSOFF();
}

void ADS1256::setConversionFactor(float val) { _conversionFactor = val; }

float ADS1256::readCurrentChannel() {
CSON();
SPI.transfer(RDATA);
delayMicroseconds(50 * 10 / _tscaler + 1); // t6 delay (50*tCLKIN)
float adsCode = read_float32();
CSOFF();
return ((adsCode / 0x800000) * ((2 * _VREF) / (float)_pga)) * _conversionFactor;
}

// Call this ONLY after RDATA command
unsigned long ADS1256::read_uint24() {
unsigned char _highByte, _midByte, _lowByte;
unsigned long value;

_highByte = SPI.transfer(WAKEUP);
_midByte = SPI.transfer(WAKEUP);
_lowByte = SPI.transfer(WAKEUP);

// Combine all 3-bytes to 24-bit data using byte shifting.
value = ((long)_highByte << 16) + ((long)_midByte << 8) + ((long)_lowByte);
return value;
}

// Call this ONLY after RDATA command
long ADS1256::read_int32() {
long value = read_uint24();

if (value & 0x00800000) {
value |= 0xff000000;
}

return value;
}

// Call this ONLY after RDATA command
float ADS1256::read_float32() {
long value = read_int32();
return (float)value;
}

// Channel switching for single ended mode. Negative input channel are
// automatically set to AINCOM
void ADS1256::switchChannel(byte channel) { switchChannel(channel, -1); }

// Channel Switching for differential mode. Use -1 to set input channel to
// AINCOM
void ADS1256::switchChannel(byte AIN_P, byte AIN_N) {
unsigned char MUX_CHANNEL;
unsigned char MUXP;
unsigned char MUXN;

switch (AIN_P) {
case 0:
MUXP = ADS1256_MUXP_AIN0;
break;
case 1:
MUXP = ADS1256_MUXP_AIN1;
break;
case 2:
MUXP = ADS1256_MUXP_AIN2;
break;
case 3:
MUXP = ADS1256_MUXP_AIN3;
break;
case 4:
MUXP = ADS1256_MUXP_AIN4;
break;
case 5:
MUXP = ADS1256_MUXP_AIN5;
break;
case 6:
MUXP = ADS1256_MUXP_AIN6;
break;
case 7:
MUXP = ADS1256_MUXP_AIN7;
break;
default:
MUXP = ADS1256_MUXP_AINCOM;
}

switch (AIN_N) {
case 0:
MUXN = ADS1256_MUXN_AIN0;
break;
case 1:
MUXN = ADS1256_MUXN_AIN1;
break;
case 2:
MUXN = ADS1256_MUXN_AIN2;
break;
case 3:
MUXN = ADS1256_MUXN_AIN3;
break;
case 4:
MUXN = ADS1256_MUXN_AIN4;
break;
case 5:
MUXN = ADS1256_MUXN_AIN5;
break;
case 6:
MUXN = ADS1256_MUXN_AIN6;
break;
case 7:
MUXN = ADS1256_MUXN_AIN7;
break;
default:
MUXN = ADS1256_MUXN_AINCOM;
}

MUX_CHANNEL = MUXP | MUXN;

CSON();
writeRegister(MUX, MUX_CHANNEL);
sendCommand(SYNC);
sendCommand(WAKEUP);
CSOFF();
}

void ADS1256::begin(unsigned char drate, unsigned char gain, bool buffenable) {
_pga = 1 << gain;
sendCommand(
SDATAC); // send out SDATAC command to stop continous reading mode.
writeRegister(DRATE, drate); // write data rate register
uint8_t bytemask = B00000111;
uint8_t adcon = readRegister(ADCON);
uint8_t byte2send = (adcon & ~bytemask) | gain;
writeRegister(ADCON, byte2send);
if(buffenable){
uint8_t status = readRegister(STATUS);
bitSet(status,1);
writeRegister(STATUS, status);
}
sendCommand(SELFCAL); // perform self calibration
while (digitalRead(_DRDY))
; // wait ADS1256 to settle after self calibration
}

void ADS1256::CSON() { digitalWrite(_CS, LOW); }

void ADS1256::CSOFF() { digitalWrite(_CS, HIGH); }

void ADS1256::waitDRDY() {
while (digitalRead(_DRDY))
;
}`

### Debug Messages

```

In file included from C:\Users\kamil\Documents\Arduino\libraries\ADS1256\ADS1256.cpp:7:0:

C:\Users\kamil\Documents\Arduino\libraries\ADS1256\ADS1256.h:11:16: error: expected unqualified-id before numeric constant

#define STATUS 0x00

^

C:\Users\kamil\Documents\Arduino\hardware\espressif\esp32/tools/sdk/include/esp32/rom/ets_sys.h:614:3: note: in expansion of macro 'STATUS'

} STATUS;

^

exit status 1
Error compiling for board ESP32 Dev Module.

```

If I change name of constant in library i i don't have any problems with compilation this code and I can write it to flash.

I succesfully tried to upload this code to many other versions of ESP866 like (D1 R2 WiFi ESP8266 WeMos) , ESP8266 v01 and so on. However my code still is not working on ESP8266 platform.

Please let me know where is the issue.