ADS1256 24-bit data acquisition module with STM32F103C8T6, 8 channels, RS232, UART

The module combines on the same board the 24-bit ADS1256 analog-to-digital converter and the STM32F103C8T6 microcontroller, being designed as a starting point for your own precision data acquisition, weighing, industrial monitoring or laboratory measurement projects. Unlike a ready-programmed module, this board breaks out all the microcontroller's resources to pins, so you can write your own program for reading the ADS1256 and sending the results to a computer or to another board.

In this tutorial we do the first power-up of the module, check the programming chain through the UART bootloader and the serial connection to an Arduino Uno used as a monitor, before moving on to writing your own driver for the ADS1256.

How it works:

ADS1256 is a 24-bit delta-sigma converter with an integrated programmable gain amplifier (PGA), with adjustable gain between 1 and 64. Clocked by the dedicated 7.68 MHz crystal mounted on the board, the converter can deliver up to 30 kSPS. The result of each conversion is a 24-bit code in two's complement, and the measured voltage is obtained from the formula Voltage = Code x Reference_voltage / (Gain x 2^23). With the 2.5 V reference on the board and gain 1, one step (LSB) means approximately 0.3 uV, and at gain 64 the step drops to approximately 0.0047 uV, which is why high gains are useful for very weak signals, but also require short cables and a clean power supply.

The STM32F103C8T6 microcontroller reads the ADS1256 over its internal bus and sends the results further through UART to the P4 connector (TX, RX, G) or, through the MAX3232 chip, to the DB9 connector for RS232. The board breaks out all the microcontroller's input/output ports to pins, including the P8 and P9 headers, precisely so you can write and load your own data acquisition firmware, the board being designed as a development base and not as an instrument with fixed firmware from the manufacturer.

What you need:

• 1 x ADS1256 24-bit data acquisition module with STM32F103C8T6, 8 channels, RS232, UART
• 1 x Uno R3 development board with ESP8266 Wifi, Arduino compatible
• 1 x UART TTL to USB HID converter, CH9329, 5V
• 1 x 40 Dupont wires, 20cm, Male-Female
• 1 x MiniUSB cable, 30cm

Wiring:

The module's UART signals (P4: TX, RX, G) work in 3.3 V logic, but the STM32F103's USART1 pins are 5 V tolerant, so they can be connected directly to the Arduino Uno without a level converter. The module can be powered either separately at 6 - 9 VDC through the P1 terminal, or directly at 5 VDC through the J2 pins, in which case you can use the Arduino Uno's 5V output, provided you don't power it through P1 at the same time.

Libraries:

The code on the Arduino Uno only uses the SoftwareSerial library, included by default in the Arduino IDE, with no separate installation needed. The firmware loaded on the STM32F103C8T6 doesn't use any external library, only the Serial1 object made available by the STM32 boards package for the Arduino IDE.

The code:

First load the test firmware onto the module, then the program below onto the Arduino Uno, to see on the serial monitor the messages sent by the module.

/*
  Arduino Uno - serial monitor bridge for the
  ADS1256 + STM32F103C8T6 data acquisition module
  Wiring:
  Module P4 TX  -> Arduino Uno pin D2 (SoftwareSerial RX)
  Module P4 RX  -> Arduino Uno pin D3 (SoftwareSerial TX)
  Module P4 G   -> Arduino Uno GND
  Module J2 +5V -> Arduino Uno 5V
  Module J2 GND -> Arduino Uno GND
  Library used: SoftwareSerial, bundled with the Arduino IDE,
  no separate installation needed
*/
#include <SoftwareSerial.h>
const int MODULE_RX_PIN = 2;
const int MODULE_TX_PIN = 3;
const long MODULE_BAUD = 9600;
SoftwareSerial moduleSerial(MODULE_RX_PIN, MODULE_TX_PIN);
void setup() {
  Serial.begin(9600);
  moduleSerial.begin(MODULE_BAUD);
  Serial.println("Listening to the ADS1256 module...");
}
void loop() {
  if (moduleSerial.available()) {
    char c = moduleSerial.read();
    Serial.write(c);
  }
}

How the code works:

The firmware on the STM32F103C8T6 initializes Serial1, that is USART1 on pins PA9 and PA10, exactly the interface also used by the board's UART bootloader, then sends a start message and, in the loop, increments the counter variable and sends it every second through Serial1.println. This firmware doesn't read the ADS1256 yet, it only serves to check the programming and the serial connection, before adding your own acquisition code.

On the Arduino Uno, the moduleSerial object, of type SoftwareSerial, is defined on the MODULE_RX_PIN and MODULE_TX_PIN pins and initialized at the MODULE_BAUD speed. In the loop function, whenever moduleSerial.available() shows that a character has arrived, it is read with moduleSerial.read() and immediately sent to the computer with Serial.write(c), so the serial monitor in the Arduino IDE shows exactly what the module is sending.

Result:

Open the serial monitor in the Arduino IDE at 9600 baud, on the Arduino Uno's COM port. After resetting the module you should see the start message followed by the counter value increasing second by second.

Listening to the ADS1256 module...
ADS1256 module - firmware test
Waiting for your own ADS1256 driver code
Counter: 1
Counter: 2
Counter: 3
Counter: 4
Counter: 5
Counter: 6

Common issues:

Nothing appears on the serial monitor: check that you have correctly crossed the wires, meaning the module's P4 TX goes to D2, not D3, and that the speed in Serial1.begin, in moduleSerial.begin and in the serial monitor is the same, 9600 baud.

STM32CubeProgrammer doesn't detect the board when loading the firmware: make sure the jumpers are set to BOOT0 on 1 and BOOT1 on 0 and that you pressed the RESET button after changing the jumpers, before starting the connection in the program.

After programming the board seems stuck and doesn't send anything anymore: most likely BOOT0 stayed on 1, so the board keeps starting in the bootloader, set the BOOT0 jumper back to 0 and press RESET again to run the loaded program.

The characters on the serial monitor are mixed up or unreadable: the cause is almost always a baud rate mismatch between the two sides, check all three places where the speed is set.

The power LED doesn't turn on and the board seems dead: check the polarity on the P1 terminal or on the J2 pins and use only one power source at a time, never P1 and J2 at the same time.

You're losing characters or the text comes through truncated even though the speeds seem correct: SoftwareSerial on the Arduino Uno isn't stable at high speeds, keep the connection at 9600 baud for consistent results.

Limitations and tips:

This test validates the power supply, the programming through the UART bootloader and the serial connection, not the actual reading of the ADS1256, for which you will need to write your own driver following the commands from the ADS1256 datasheet (RREG, WREG, SELFCAL, RDATA), because the internal connection between the STM32F103C8T6 and the ADS1256 is fixed by the manufacturer on the board and is not accessible from outside.

Keep in mind that increasing the PGA gain improves resolution but reduces the input range and increases sensitivity to noise, while increasing the sampling rate reduces the averaging time of each conversion, so for very weak signals (thermocouples, Wheatstone bridges) choose a high gain together with a lower sampling rate.

For stable measurements use short, shielded cables between the sensor and the I0 - I7 inputs, keep the module away from sources of electromagnetic interference such as relays, motors or switching power supplies, and around high gains make sure the signal ground is common with the power supply ground.