Tutorial Penggunaan HX711 dan Loadcell / Load Cell dengan Arduino UNO

GAMBARAN UMUM
Kita semua telah menggunakan skala untuk menentukan bobot sesuatu pada suatu saat dalam kehidupan kita.

Menggunakan sensor Load Cell atau Weight Anda dapat menambahkan kemampuan ini untuk proyek Arduino Anda.

Dalam tutorial ini kita akan melihat bagaimana menghubungkan, mengkalibrasi dan menampilkan berat pada layar OLED kecil, dan dengan menggunakan rotary encoder kita akan dapat mengubah unit dari: gram, kg atau pound.

Kami akan menggunakan papan konverter HX711 ADC untuk memperkuat sinyal yang diterima dari sensor berat. Amplifier ini memungkinkan Arduino untuk mendeteksi perubahan resistansi dari load cell.

Load Cell and HX711

Jadi apa itu Load Cell?

Mereka banyak jenis Load Cell, tetapi hari ini kita akan menggunakan tipe bar lurus.

Ketika tekanan atau beban diterapkan, hambatan listrik akan berubah sebagai respons terhadap tekanan yang diterapkan ini dan dengan mengambil informasi ini dan setelah beberapa kalibrasi kita dapat menentukan bobot yang tepat.

Load cell seperti ini datang dalam batas berat yang berbeda, yang akan kita gunakan hari ini diberi peringkat hingga 1KG, tetapi Anda bisa mendapatkan yang lain yang akan mendukung lebih banyak berat jika diperlukan.

Bagaimana dengan HX711 ini?

Perubahan resistansi listrik yang disediakan oleh Load Cell perlu diperkuat sehingga dapat dibaca oleh Arduino.

Itulah yang dilakukan board HX711. Itu membaca informasi dari Load Cell, memperkuat sinyal dan kemudian mengirimkannya ke Arduino untuk diproses.

Load Cell pada umumnya memiliki empat kabel untuk menghubungkan HX711 ke mikrokontroler seperti Arduino.

• Merah (VCC)
• Hitam (GND)
• Data
• Clock

Untuk menghubungkan HX711 ke Arduino, Anda hanya perlu 2 pin (Clock dan Data).

Di sisi yang berlawanan Anda dapat melihat koneksi untuk Load cell.

Kami akan menggunakan pustaka Arduino sederhana untuk berkomunikasi dengan HX711 yang menyediakan fitur kalibrasi dan Tare (reset) untuk dengan mudah menentukan berat suatu objek.

LOAD CELL SETUP
Jenis batang yang kami gunakan memiliki lubang sekrup yang berbeda di bagian bawah dan atas.

Untuk itu sebagai skala, Anda pasang lubang sekrup kiri bawah atau kanan ke meja atau objek stabil, dan kemudian pasang sepotong platic atau bahan lain untuk dijadikan skala untuk meletakkan benda, ke lubang sekrup yang berlawanan atas .

* Setiap jenis batang memiliki panah yang menunjukkan arah defleksi dan harus diposisikan dengan cara yang benar untuk proyek Anda.

Anda dapat melihat pengaturan sederhana di sini:

Pengaturan ini untuk menggunakan Load Cell memiliki skala sederhana, tetapi Anda juga bisa menghubungkannya dengan mendeteksi defleksi antara dua objek jika Anda mau.

CONNECTIONS

Koneksi untuk tutorial ini sangat mudah:

5V dan GND dari UNO terhubung ke setiap modul VCC dan GND.

Karena layar OLED menggunakan I2C kami menggunakan pin A4 (SDA), A5 (SCL) pada UNO untuk menghubungkannya.

Rotary encoder terhubung ke pin ini: CLK ke pin 2, DT ke pin 3 dan SW ke pin 4.

HX711 terhubung ke: DATA ke pin 4 dan CLOCK ke pin 5.

Tergantung pada HX711 pembelian Anda mungkin memiliki koneksi yang berbeda: Jika memiliki penunjukan warna, kemudian hubungkan kabel yang sesuai dari Load Cell ke HX711.

Dalam kasus saya HX711 saya memiliki koneksi ini:

E +: Terhubung ke RED dari Load Cell
E-: Terhubung ke BLACK

A-: Terhubung ke GREEN
A +: Terhubung ke WHITE

B-: tidak ada koneksi
B +: tidak ada koneksi

KODE PROGRAM

Kami menggunakan perpustakaan yang ditulis untuk HX711 untuk berkomunikasi dengan Arduino, Anda dapat menemukan tautan untuk mengunduh perpustakaan di bagian bawah halaman ini.

Kode pertama digunakan untuk mendapatkan faktor kalibrasi untuk sel Load tertentu, ini harus dijalankan untuk setiap Load Cell yang Anda miliki, karena masing-masing sedikit berbeda.

Kode kedua menggunakan faktor kalibrasi untuk mencetak bobot yang benar pada layar OLED.

/* Calibration sketch for HX711 */
 
#include "HX711.h"  // Library needed to communicate with HX711 https://github.com/bogde/HX711
 
#define DOUT  6  // Arduino pin 6 connect to HX711 DOUT
#define CLK  5  //  Arduino pin 5 connect to HX711 CLK
 
HX711 scale(DOUT, CLK);  // Init of library

void setup() {
  Serial.begin(9600);
  scale.set_scale();  // Start scale
  scale.tare();       // Reset scale to zero
}

void loop() {
  float current_weight=scale.get_units(20);  // get average of 20 scale readings
  float scale_factor=(current_weight/0.145);  // divide the result by a known weight
  Serial.println(scale_factor);  // Print the scale factor to use
}

/* Arduino Scale using HX711 and Load Cell
 
NN-Digital
*/


#include "U8glib.h"   // Library for Oled display https://github.com/olikraus/u8glib/
#include "HX711.h"    // Library for Load Cell amplifier board

volatile boolean TurnDetected;  // variable used to detect rotation of Rotary encoder
volatile int Rotary_Flag=0;     // flag to indicate rotation as occured

// Rotary Encoder Module connections
#define RotaryCLK 2   // Rotary encoder CLK pin connected to pin 2 of Arduino
#define RotaryDT 3    // Rotary encoder DT pin connected to pin 3
#define RotarySW 4    // Rotary encoder Switch pin connected to pin 4

// HX711 Module connections
#define CLK 5   // CLK of HX711 connected to pin 5 of Arduino
#define DOUT 6  // DOUT of HX711 connected to pin 6 of Arduino

int reset_screen_counter=0;      // Variable used to decide what to display on Oled
volatile int current_units=0;    // Used to select which measuring unit to use (KG,Grams,Pounds)
float unit_conversion;           // Used to convert between measuring units
int decimal_place;               // how many decimal number to display

HX711 scale(DOUT, CLK);  // Init of the HX711

U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_FAST); // Init of the OLED


// Interrupt routine runs if Rotation detected from Rotary encoder
void rotarydetect ()  {
Rotary_Flag=1; // Set Rotary flag from 0 to 1
delay(500);
}


// Used to change the measurement units (0=grams, 1=KG, 2=pounds)
void change_units ()  { 
  if (current_units == 0) current_units=1;
  else if (current_units == 1) current_units=2;
  else if (current_units == 2) current_units=0;
}


// Run at Startup and when Resetting with Rotary encoder switch
void startupscreen(void) {
  u8g.setFont(u8g_font_unifont);
  u8g.firstPage(); 
  do {
    u8g.drawStr( 0, 10, "Clear Scale");
    u8g.drawStr( 0, 28, "Click to zero...");
  } while( u8g.nextPage() );
}

// Reset Scale to zero
void tare_scale(void) {
  scale.set_scale(-1073000);  //Calibration Factor obtained from calibration sketch
  scale.tare();             //Reset the scale to 0  
}


// Start Displaying information on OLED
void start_scale(void) {
  char temp_current_units[15];  // Needed to store String to Char conversion
  String KG="KG";
  String GRAMS="GRAMS";
  String LBS="POUNDS";
  
  if (current_units == 0) {                     // 0 = grams
    GRAMS.toCharArray(temp_current_units, 15);  // Convert String to Char for OLED display
    unit_conversion=1000;                        // conversion value for grams
    decimal_place=0;                            // how many decimal place numbers to display
  } else if (current_units == 1) {              // 1 = Kilograms
    KG.toCharArray(temp_current_units, 15);
    unit_conversion=1;
    decimal_place=3;
  } else {                                      // else 2 = Pounds
    LBS.toCharArray(temp_current_units, 15);
    unit_conversion=2.2046226218;
    decimal_place=3;
  }
  
    u8g.setFont(u8g_font_unifont);
    u8g.firstPage(); 
      do {
        u8g.drawStr( 0, 10, temp_current_units);  // Display the current measurement unit
        u8g.setPrintPos(38, 28);
        u8g.print(scale.get_units(3)*unit_conversion, decimal_place);  // Display the average of 3 scale value reading
      } while( u8g.nextPage() );
}



void setup(void) {
  
  // Set pinmode for Rotary encoder pins
  pinMode(RotarySW,INPUT_PULLUP);
  pinMode(RotaryCLK,INPUT_PULLUP);
  pinMode(RotaryDT,INPUT_PULLUP);  

  // Attach interrupt 0 (Pin 2 on UNO) to the Rotary Encoder
  attachInterrupt (0,rotarydetect,RISING);   // interrupt 0 always connected to pin 2 on Arduino UNO

  // Rotate screen 180 degrees on OLED, if required
  u8g.setRot180();

  // Set color of OLED to Monochrome
  u8g.setColorIndex(1);

  // Select font to use
  u8g.setFont(u8g_font_unifont);

  String start_count_string="Starting up....";  // Message to display at Startup
  char start_count[15];  // Used to String to Char conversion
  
  // Loop to display counting dots
  for (int x=12; x < 16; x++) {  // Select the first 12 to 16 character of String
    start_count_string.toCharArray(start_count, x);
    u8g.firstPage(); 
    do {
      u8g.drawStr( 0, 10, "ARDUINO SCALE");
      u8g.drawStr( 0, 28, start_count);
    } while( u8g.nextPage() );
    delay(500);  // Delay between dots
  }
}


void loop(void) {
  
// If Switch is pressed on Rotary Encoder
  if (!digitalRead(RotarySW)) {       // Check to see which action to take
    if(reset_screen_counter == 1) {   
      tare_scale();                   // 1 = zero and start scale
      reset_screen_counter=2;
      delay(500);
    } else {
      if(reset_screen_counter == 2) { // 2 = Scale already started so restart from begining
        reset_screen_counter=0;
        delay(500); 
      }
    }
  }

// If Rotation was detected
  if (Rotary_Flag == 1) {
    change_units();  // change the measuring units
    Rotary_Flag=0;   // reset flag to zero
  }

// If system was just started display intro screen  
  if (reset_screen_counter == 0) {    
    startupscreen();
  reset_screen_counter=1;  // set to 1 and wait for Rotary click to zero scale
  }
 
// if zero (tare) of scale as occured start display of weight
  if (reset_screen_counter == 2) {
          start_scale();
  }
}

+++++++ Terima kasih, semoga bermanfaat +++++++