The YZC-133 20Kg Weighing Load Cell Sensor is designed for precise weight measurement in electronic kitchen scales and other medium-weight applications. This load cell converts the applied mechanical force (weight) into an electrical signal, making it suitable for weighing systems that require accurate measurement. Pre-wired with four wires, it can be easily integrated into microcontroller platforms such as Arduino, Raspberry Pi, and other control systems.

Its durable aluminum alloy construction ensures reliability and precision, making it ideal for use in kitchen scales, baggage scales, and similar devices requiring weight measurements up to 20Kg.

Features:

• Accurate weight measurement up to 20Kg
• Pre-wired for easy connection and integration with microcontroller-based systems
• Sturdy aluminum alloy build for long-term use
• Compact and lightweight design
• Wide range of applications including kitchen scales, personal scales, and DIY projects
• Compatible with platforms like Arduino, Raspberry Pi, and more

Specifications:

• Model: YZC-133
• Maximum Load Capacity: 20Kg
• Rated Output: 1.0 ± 0.1mV/V
• Non-linearity: ±0.03% full scale
• Repeatability: ±0.03% full scale
• Creep: ±0.03% (30 minutes)
• Zero Balance: ±0.1mV/V
• Input Resistance: 1050 ± 10Ω
• Output Resistance: 1000 ± 10Ω
• Insulation Resistance: ≥2000MΩ (50V DC)
• Recommended Excitation Voltage: 5-10V DC
• Maximum Excitation Voltage: 15V DC
• Cable Length: 4 wires, approximately 30cm
  • Red: +E (Excitation+)
  • Black: -E (Excitation-)
  • Green: +S (Signal+)
  • White: -S (Signal-)
• Material: Aluminum Alloy
• Working Temperature: -10°C to +40°C
• Dimensions: 80mm x 12.7mm x 12.7mm (L x W x H)
• Weight: Approximately 35g

The YZC-133 20Kg load cell sensor is ideal for precise weight measurements in larger kitchen scales and medium-capacity weighing devices, ensuring reliability and accuracy for a wide range of applications.

How to interface with an Arduino?

Interfacing a load cell with an Arduino involves connecting the load cell to an amplifier (such as the HX711), which then sends the signal to the Arduino. Here’s how you can interface 1Kg, 5Kg, 10Kg, and 20Kg load cells using Arduino:

Components Required:

• Load Cell (1Kg, 5Kg, 10Kg, or 20Kg)
• HX711 Load Cell Amplifier Module
• Arduino (UNO or any compatible board)
• Jumper Wires
• Breadboard
• Power Supply

Steps to Interface Load Cells with Arduino:

1. Wiring the Load Cell to the HX711 Amplifier:

Most load cells, regardless of their capacity (1Kg, 5Kg, 10Kg, or 20Kg), come with four wires:

• Red: +E (Excitation+)
• Black: -E (Excitation-)
• Green: +S (Signal+)
• White: -S (Signal-)

Wire the load cell to the HX711 module as follows:

• Red wire from the load cell to E+ on the HX711.
• Black wire from the load cell to E- on the HX711.
• Green wire from the load cell to A+ on the HX711.
• White wire from the load cell to A- on the HX711.

(Note: If you’re using a load cell with five wires, the extra wire (usually yellow) is for grounding or shielding and can be ignored.)

2. Wiring the HX711 to the Arduino:

Connect the HX711 module to the Arduino as follows:

• VCC on HX711 to 5V on Arduino.
• GND on HX711 to GND on Arduino.
• DT (Data) on HX711 to Pin 3 on Arduino.
• SCK (Clock) on HX711 to Pin 2 on Arduino.

3. Arduino Code:

You'll need the HX711 library to easily read data from the load cell. Install the library via Arduino IDE:

• Go to Sketch → Include Library → Manage Libraries, then search for "HX711" and install the HX711 library by "Bogdan Necula."

Here's a sample code for reading load cell data:

#include "HX711.h"

// HX711 circuit wiring
const int LOADCELL_DOUT_PIN = 3;
const int LOADCELL_SCK_PIN = 2;

HX711 scale;

void setup() {
  Serial.begin(9600);
  scale.begin(LOADCELL_DOUT_PIN, LOADCELL_SCK_PIN);
  Serial.println("Load Cell Setup Ready");
}

void loop() {
  if (scale.is_ready()) {
    long reading = scale.read();  // Read raw data from load cell
    Serial.print("Raw reading: ");
    Serial.println(reading);
    
    // You can add calibration here based on your specific load cell
  } else {
    Serial.println("HX711 not found.");
  }
  delay(1000); // Delay for easier viewing in the Serial Monitor
}

4. Calibrating the Load Cell:

To accurately measure weight, you need to calibrate the load cell. Place a known weight on the load cell, read the raw value, and determine the scaling factor. Modify the code to output the actual weight based on your load cell's calibration factor.

Here’s how you can calibrate:

// Add this part after setting up the load cell in the setup() function
long calibration_factor = 2280; // You will need to adjust this based on your specific load cell
scale.set_scale(calibration_factor); // Set the calibration factor
scale.tare(); // Tare the scale to 0

void loop() {
  Serial.print("Weight: ");
  Serial.print(scale.get_units(), 2); // Print the weight in KG
  Serial.println(" Kg");
  delay(1000);
}

5. Adjusting for Different Load Cells (1Kg, 5Kg, 10Kg, and 20Kg):

• The procedure is the same for different capacities of load cells. The only difference is the calibration factor.
• For each load cell (1Kg, 5Kg, 10Kg, 20Kg), you will need to calibrate using a known weight and adjust the calibration factor accordingly.
  • For example, for a 5Kg load cell, place a 5Kg weight, observe the raw reading, and calculate the calibration factor.

6. Calibration Factor Calculation Example:

• Place a known weight on the load cell, for example, 2Kg.

• Note down the raw reading displayed in the Serial Monitor.

• Use the following formula to calculate the calibration factor:

Calibration Factor = Raw Reading / Known Weight

• Replace calibration_factor in the code with your new value.