The YZC-133 5Kg Weighing Load Cell Sensor is a highly precise force sensor designed for use in electronic kitchen scales and other lightweight measurement devices. It works by converting the force of weight into an electrical signal, allowing accurate measurements in a range of applications such as kitchen scales, personal scales, and other small weighing platforms. Pre-wired with four wires, it’s easy to integrate into microcontroller-based systems such as Arduino, Raspberry Pi, or other control systems.

The sensor’s durable aluminum alloy build ensures long-lasting performance, while its compact form factor makes it ideal for DIY electronic weighing projects.

Features:

• Precision weight measurement up to 5Kg
• Simple integration with microcontrollers and electronic circuits
• Sturdy aluminum alloy construction for durability
• Pre-wired with color-coded wires for easy setup
• Versatile use in kitchen scales, portable scales, and DIY projects
• Lightweight and compact for easy handling

Specifications:

• Model: YZC-133
• Maximum Load Capacity: 5Kg
• 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 25g

The YZC-133 5Kg load cell sensor is ideal for precise, small-scale weight measurements, providing a reliable and efficient solution for electronic kitchen scales and similar devices.

Interfacing With 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.