Cirkit Designer Logo
Cirkit Designer
Your all-in-one circuit design IDE
Home / 
Component Documentation

How to Use openScale_v04: Examples, Pinouts, and Specs

Image of openScale_v04
Cirkit Designer LogoDesign with openScale_v04 in Cirkit Designer

Introduction

The openScale v04 is a versatile and user-friendly load cell amplifier and data logger module designed to measure weight or force with high precision. It is commonly used in applications such as digital scales, industrial systems, and experimental force measurement setups. The openScale simplifies the process of integrating a load cell into your projects by providing both analog and digital outputs, making it suitable for a wide range of applications from hobbyist projects to professional data logging.

Explore Projects Built with openScale_v04

Use Cirkit Designer to design, explore, and prototype these projects online. Some projects support real-time simulation. Click "Open Project" to start designing instantly!
Arduino UNO Based Oscilloscope with OLED Display and Adjustable Time/Voltage Scales
Image of 1: A project utilizing openScale_v04 in a practical application
This circuit features an Arduino UNO connected to a 0.96" OLED display for visual output, with a rotary potentiometer providing analog input to the Arduino. Two pushbuttons are included, each with a pull-up resistor, to allow the user to adjust time base and voltage scale settings for the display. The Arduino runs a sketch to read the potentiometer value, adjust settings with the pushbuttons, and display a scaled waveform on the OLED screen.
Cirkit Designer LogoOpen Project in Cirkit Designer
Arduino UNO and ESP8266 Wi-Fi Enabled Load Cell Weight Measurement System
Image of Scale Project: A project utilizing openScale_v04 in a practical application
This circuit is a digital weighing scale system that uses an Arduino UNO to read data from a load cell via an HX711 interface, display the weight on an LCD, and send the data over WiFi using an ESP8266 module when a specific key on a 4x4 membrane keypad is pressed. The system integrates multiple components to measure, display, and transmit weight data.
Cirkit Designer LogoOpen Project in Cirkit Designer
Arduino UNO and DS3231 RTC Based Digital Weighing Scale with 7-Segment Display
Image of display: A project utilizing openScale_v04 in a practical application
This circuit is a digital weighing scale system that uses four 50kg load sensors connected to an Arduino UNO for weight measurement. The Arduino UNO interfaces with a DS3231 RTC module for timekeeping and a 4-digit 7-segment display for showing the measured weight. Multiple resistors are used for current limiting and signal conditioning.
Cirkit Designer LogoOpen Project in Cirkit Designer
ESP32-Based Smart Weighing Scale with Wi-Fi and Environmental Monitoring
Image of timbangan: A project utilizing openScale_v04 in a practical application
This circuit is a smart weighing scale system that uses an ESP32 microcontroller to read data from a load cell via an HX711 interface and a DHT22 sensor for temperature and humidity. The data is displayed on a 20x4 I2C LCD and sent to a Blynk server for remote monitoring.
Cirkit Designer LogoOpen Project in Cirkit Designer

Explore Projects Built with openScale_v04

Use Cirkit Designer to design, explore, and prototype these projects online. Some projects support real-time simulation. Click "Open Project" to start designing instantly!
Image of 1: A project utilizing openScale_v04 in a practical application
Arduino UNO Based Oscilloscope with OLED Display and Adjustable Time/Voltage Scales
This circuit features an Arduino UNO connected to a 0.96" OLED display for visual output, with a rotary potentiometer providing analog input to the Arduino. Two pushbuttons are included, each with a pull-up resistor, to allow the user to adjust time base and voltage scale settings for the display. The Arduino runs a sketch to read the potentiometer value, adjust settings with the pushbuttons, and display a scaled waveform on the OLED screen.
Cirkit Designer LogoOpen Project in Cirkit Designer
Image of Scale Project: A project utilizing openScale_v04 in a practical application
Arduino UNO and ESP8266 Wi-Fi Enabled Load Cell Weight Measurement System
This circuit is a digital weighing scale system that uses an Arduino UNO to read data from a load cell via an HX711 interface, display the weight on an LCD, and send the data over WiFi using an ESP8266 module when a specific key on a 4x4 membrane keypad is pressed. The system integrates multiple components to measure, display, and transmit weight data.
Cirkit Designer LogoOpen Project in Cirkit Designer
Image of display: A project utilizing openScale_v04 in a practical application
Arduino UNO and DS3231 RTC Based Digital Weighing Scale with 7-Segment Display
This circuit is a digital weighing scale system that uses four 50kg load sensors connected to an Arduino UNO for weight measurement. The Arduino UNO interfaces with a DS3231 RTC module for timekeeping and a 4-digit 7-segment display for showing the measured weight. Multiple resistors are used for current limiting and signal conditioning.
Cirkit Designer LogoOpen Project in Cirkit Designer
Image of timbangan: A project utilizing openScale_v04 in a practical application
ESP32-Based Smart Weighing Scale with Wi-Fi and Environmental Monitoring
This circuit is a smart weighing scale system that uses an ESP32 microcontroller to read data from a load cell via an HX711 interface and a DHT22 sensor for temperature and humidity. The data is displayed on a 20x4 I2C LCD and sent to a Blynk server for remote monitoring.
Cirkit Designer LogoOpen Project in Cirkit Designer

Technical Specifications

Key Technical Details

  • Supply Voltage: 3.3V to 5V DC
  • Current Consumption: Typically 10mA (excluding load cell)
  • Load Cell Excitation Voltage: 5V
  • Analog Output: 0-3V (proportional to load)
  • Digital Output: UART (serial) at 9600 bps
  • Maximum Load Cell Capacity: Depends on the load cell used (commonly up to 50kg)
  • Resolution: 24-bit ADC
  • Data Logging Rate: Configurable
  • Dimensions: 44.5mm x 20.3mm

Pin Configuration and Descriptions

Pin Number Name Description
1 GND Ground connection
2 VCC Power supply (3.3V to 5V DC)
3 TX UART Transmit (to microcontroller RX)
4 RX UART Receive (from microcontroller TX)
5 DAT Load cell data output
6 CLK Load cell clock input
7 SCL I2C clock (for future use)
8 SDA I2C data (for future use)

Usage Instructions

Integrating with a Circuit

  1. Powering the Module: Connect the VCC pin to a 3.3V or 5V power supply and the GND pin to the ground.
  2. Connecting a Load Cell: Attach the load cell wires to the DAT and CLK pins. Ensure correct polarity and secure connections.
  3. Serial Communication: Connect the TX pin to the RX pin on your microcontroller (e.g., Arduino UNO) and the RX pin to the TX pin on the microcontroller for UART communication.
  4. Calibration: Before using the openScale, calibrate it with known weights to ensure accurate readings.

Important Considerations and Best Practices

  • Power Supply: Ensure that the power supply is stable and within the specified voltage range to prevent damage to the module.
  • Load Cell Selection: Choose a load cell with an appropriate capacity for your application. The openScale can handle various load cell types, but the capacity should match your requirements.
  • Shielding: Load cell signals can be susceptible to noise. Use shielded cables and keep signal wires away from high-current carrying conductors.
  • Environment: Avoid using the openScale in environments with high humidity or corrosive gases, which can affect the accuracy and longevity of the module.

Example Code for Arduino UNO

#include <HX711.h>

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 5;
const int LOADCELL_SCK_PIN = 6;

HX711 scale;

void setup() {
  Serial.begin(9600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
}

void loop() {
  if (scale.is_ready()) {
    long reading = scale.read();
    Serial.print("Weight measurement: ");
    Serial.println(reading);
  } else {
    Serial.println("Load cell not detected.");
  }
  delay(500);
}

Troubleshooting and FAQs

Common Issues

  • Inaccurate Readings: Ensure the openScale is calibrated correctly. Check the load cell connections and verify that the load cell is not damaged.
  • No Readings: Check the power supply and wiring. Ensure the TX and RX pins are connected to the correct pins on the microcontroller.
  • Unstable Readings: Use shielded cables for the load cell and keep the openScale away from electromagnetic interference.

Solutions and Tips

  • Calibration: Use a known weight to calibrate the openScale. Follow the calibration procedure outlined in the openScale documentation.
  • Wiring: Double-check all connections, especially the load cell wiring, to ensure they are secure and correct.
  • Environment: Operate the openScale in a stable environment, away from vibrations and temperature fluctuations.

FAQs

Q: Can I use multiple load cells with one openScale? A: Yes, the openScale can support multiple load cells in certain configurations. Refer to the openScale documentation for details on connecting multiple load cells.

Q: What is the maximum data logging rate? A: The data logging rate is configurable. For high-speed applications, the openScale can log at intervals as short as a few milliseconds.

Q: How do I connect the openScale to a computer for data logging? A: The openScale can be connected to a computer via the UART interface. Use a USB-to-serial adapter if necessary and capture the data with serial communication software.

Remember to always refer to the latest version of the openScale documentation for the most accurate and detailed information.