Menghitung rerata (rata-rata) berdasarkan data yang masuk

Jika datanya tak terhingga dan terus menerus masuk, Anda perlu menggunakan pendekatan yang berkelanjutan untuk menghitung rata-rata secara real-time. Kita dapat menggunakan konsep moving average atau rata-rata bergerak untuk menangani situasi seperti ini. Moving average adalah teknik yang digunakan untuk menghitung rata-rata dari sejumlah data terbaru, dan data yang lebih lama akan terus digantikan oleh data yang baru.

Berikut adalah contoh implementasi rata-rata bergerak (moving average) menggunakan Arduino untuk menghitung rata-rata dari data sensor yang masuk terus menerus:

1. const int sensorPin = A0;   // Pin tempat sensor terhubung
2. const int jumlahData = 10;  // Jumlah data yang akan dihitung rata-ratanya
3. int data[jumlahData];       // Array untuk menyimpan data
4. int indeks = 0;             // Indeks saat ini dalam array data
5. float rataRata = 0;         // Variabel untuk menyimpan rata-rata
6. 
   
7. void setup() {
8.   Serial.begin(9600);  // Inisialisasi komunikasi serial
9.   for (int i = 0; i < jumlahData; i++) {
10.     data[i] = 0;  // Inisialisasi data dengan nilai 0
11.   }
12. }
13. 
    
14. void loop() {
15.   // Baca nilai dari sensor A0
16.   int nilaiSensor = analogRead(sensorPin);
17. 
    
18.   // Update nilai dalam array data
19.   data[indeks] = nilaiSensor;
20. 
    
21.   // Hitung rata-rata dari data dalam array
22.   rataRata = hitungRataBergerak(data, jumlahData);
23. 
    
24.   // Tampilkan nilai sensor dan rata-rata di monitor serial
25.   Serial.print("Nilai Sensor: ");
26.   Serial.print(nilaiSensor);
27.   Serial.print(" Rata-rata: ");
28.   Serial.println(rataRata);
29. 
    
30.   // Pindah ke indeks berikutnya dalam array data
31.   indeks = (indeks + 1) % jumlahData;
32. 
    
33.   // Tunda sebentar sebelum membaca data sensor berikutnya
34.   delay(1000);  // Tunggu 1 detik
35. }
36. 
    
37. float hitungRataBergerak(int data[], int jumlahData) {
38.   int total = 0;
39.   for (int i = 0; i < jumlahData; i++) {
40.     total += data[i];
41.   }
42.   return (float)total / jumlahData;
43. }

Dalam contoh ini, kita menggunakan array untuk menyimpan sejumlah data terbaru dari sensor. Saat data baru masuk, data yang paling lama akan digantikan oleh data yang baru. Ini memungkinkan perhitungan rata-rata bergerak yang terus diperbarui secara real-time.

Bagaimana cara memperbaiki hasil pengukuran yang berbeda dari hasil pengukuran alat ukur standar. Sehingga hasil pengukuran akan mendekati dari hasil alat ukur standar, contoh dan rumusnya dalam excel

Memperbaiki hasil pengukuran yang berbeda dari hasil pengukuran alat ukur standar dapat dilakukan dengan menggunakan metode regresi linier. Anda dapat melakukan kalibrasi dengan merumuskan hubungan antara hasil pengukuran dari alat yang ingin diperbaiki dengan hasil pengukuran dari alat ukur standar, dan kemudian menggunakan persamaan regresi ini untuk mengoreksi hasil pengukuran yang tidak akurat.

Berikut ini adalah contoh data dan langkah-langkah untuk memperbaiki hasil pengukuran menggunakan regresi linier dalam Excel:

Contoh Data:

Langkah-langkah penerapan pada Excel:

1. Buka lembar kerja baru di Excel.
2. Isi data seperti di atas, dengan hasil pengukuran dari alat standar (X) dan hasil pengukuran dari alat yang ingin diperbaiki (Y).
3. Hitung koefisien regresi menggunakan fungsi SLOPE dan INTERCEPT:

• Di sel C2: =SLOPE(B2:B6, A2:A6) - Koefisien kemiringan regresi.
• Di sel D2: =INTERCEPT(B2:B6, A2:A6) - Intercept regresi.

1. Di kolom E, hitung hasil prediksi dari alat yang ingin diperbaiki menggunakan persamaan regresi: =D2 + C2 * A2.
2. Hitung selisih antara hasil prediksi (kolom E) dengan hasil pengukuran awal alat yang ingin diperbaiki (kolom B): Di sel F2, masukkan rumus: =E2 - B2.
3. Pada kolom G, hitung hasil pengukuran yang diperbaiki dengan menambahkan selisih (kolom F) pada hasil pengukuran awal: =B2 + F2.
4. Sekarang Anda memiliki hasil pengukuran yang diperbaiki (kolom G). Anda dapat menggunakan kolom G untuk mendapatkan hasil pengukuran yang lebih mendekati hasil dari alat ukur standar.

Dalam langkah-langkah di atas, kita menggunakan regresi linier untuk menghitung koefisien kemiringan (slope) dan intercept. Kemudian, kita menggunakan persamaan regresi untuk memprediksi hasil pengukuran yang diperbaiki. Selisih antara hasil prediksi dan hasil pengukuran awal digunakan untuk koreksi. Hasil pengukuran yang diperbaiki diperoleh dengan menambahkan koreksi pada hasil pengukuran awal.

Pastikan untuk selalu melakukan validasi dan pengujian tambahan untuk memastikan bahwa metode ini cocok dan memberikan hasil yang akurat sesuai dengan kondisi dan kebutuhan Anda.

Hasil Excel:

Cara Kalibrasi Sensor Warna TCS 3200 di Arduino

Untuk mengkalibrasi sensor warna TCS3200, Anda dapat mengikuti langkah-langkah berikut:

1. Pertama-tama, sambungkan sensor TCS3200 ke papan Arduino dan pasang kode program dasar yang akan membaca warna dari sensor dan menampilkannya di serial monitor.
2. Letakkan sensor di atas permukaan putih, kemudian baca nilai warna RGB pada serial monitor. Pastikan nilai RGB pada putih adalah sekitar (255,255,255). Jika tidak, Anda dapat menyesuaikan nilai gain pada sensor untuk mengoptimalkan pembacaan warna.
3. Setelah mengatur gain, letakkan sensor di atas permukaan hitam dan baca nilai warna RGB pada serial monitor. Pastikan nilai RGB pada hitam adalah sekitar (0,0,0).
4. Setelah menyesuaikan putih dan hitam, Anda dapat menggunakan warna lain untuk dijadikan referensi seperti merah, hijau, biru atau warna lainnya. Pastikan nilai RGB yang dihasilkan sesuai dengan ekspektasi.
5. Terakhir, Anda dapat menyesuaikan waktu integrasi (INTEG) pada sensor untuk mengoptimalkan pembacaan warna. Semakin lama waktu integrasi, semakin akurat hasil pembacaan warna, namun semakin lambat juga kecepatan pemrosesan data. Anda dapat mencoba mengatur waktu integrasi mulai dari 2,4,8,16, dan 32 siklus clock.

Berikut adalah contoh kode program dasar untuk membaca nilai RGB pada sensor warna TCS3200:

#include <Adafruit_TCS3200.h>

Adafruit_TCS3200 colorSensor(TCS3200_S2, TCS3200_S3, TCS3200_OUT);

void setup() {

  Serial.begin(9600);

  colorSensor.begin();

}

void loop() {

  colorSensor.setResolution(TCS3200_18BIT);

  colorSensor.writeRegister(0x00, TCS3200_MEASUREMENT_MODE);

  delay(50);

  

  uint16_t red = colorSensor.readRed();

  uint16_t green = colorSensor.readGreen();

  uint16_t blue = colorSensor.readBlue();

  Serial.print("RGB: ");

  Serial.print(red);

  Serial.print(" ");

  Serial.print(green);

  Serial.print(" ");

  Serial.println(blue);

}

Anda dapat melakukan kalibrasi sensor dengan mengubah gain dan waktu integrasi pada bagian berikut:

colorSensor.setGain(TCS3200_GAIN_1X);

colorSensor.setIntegrationTime(TCS3200_INTEGRATIONTIME_2_4MS);

Jika hasil pembacaan warna masih kurang akurat, Anda dapat mencoba menyesuaikan gain dan waktu integrasi hingga nilai RGB yang dihasilkan sudah sesuai dengan ekspektasi.

Particle filter

Particle filter adalah salah satu jenis filter Bayes yang digunakan untuk memperkirakan status yang tidak teramati dari sistem dinamis. Particle filter dapat diterapkan pada berbagai aplikasi, termasuk pengenalan pola, navigasi, dan pengolahan sinyal. 

Source: https://www.youtube.com/watch?v=_LjBba2hnfk

Berikut adalah contoh coding Arduino untuk Particle filter:

Catatan: 

Contoh coding di atas hanya merupakan kerangka dasar untuk implementasi Particle filter pada Arduino dan tidak termasuk algoritma untuk memperbarui partikel dan menghitung bobot partikel. Implementasi algoritma tersebut harus disesuaikan dengan aplikasi yang diinginkan.

#include <math.h>

#include <stdlib.h>

#define N 100 // Jumlah partikel

// Inisialisasi partikel
struct Particle {
  float x; // Koordinat x
  float y; // Koordinat y
  float theta; // Sudut theta
  float weight; // Bobot
};

Particle particles[N]; // Array partikel
float weights[N]; // Array bobot
float sum_of_weights = 0.0; // Total bobot
int num_of_particles = N; // Jumlah partikel

// Inisialisasi sistem
void setup() {
  // Inisialisasi partikel
  for (int i = 0; i < num_of_particles; i++) {
    particles[i].x = random(0, 100); // Inisialisasi koordinat x
    particles[i].y = random(0, 100); // Inisialisasi koordinat y
    particles[i].theta = random(0, 360); // Inisialisasi sudut theta
    particles[i].weight = 1.0 / num_of_particles; // Inisialisasi bobot
  }
}

// Perbarui partikel
void updateParticles() {
  // Implementasi algoritma Particle filter di sini
  // ...
}

// Hitung bobot partikel
void computeWeights() {
  // Implementasi fungsi untuk menghitung bobot partikel di sini
  // ...
}

// Normalisasi bobot partikel
void normalizeWeights() {
  // Hitung total bobot
  sum_of_weights = 0.0;
  for (int i = 0; i < num_of_particles; i++) {
    sum_of_weights += particles[i].weight;
  }

  // Normalisasi bobot
  for (int i = 0; i < num_of_particles; i++) {
    particles[i].weight /= sum_of_weights;
  }
}

// Resampling partikel
void resample() {
  Particle new_particles[N];
  int index = random(0, num_of_particles);
  float beta = 0.0;

  // Implementasi algoritma resampling di sini
  // ...

  // Salin partikel baru ke array partikel lama
  for (int i = 0; i < num_of_particles; i++) {
    particles[i] = new_particles[i];
  }
}

// Loop utama
void loop() {
  // Perbarui partikel
  updateParticles();

  // Hitung bobot partikel
  computeWeights();

  // Normalisasi bobot partikel
  normalizeWeights();

  // Resampling partikel
  resample();

  // ...
}

Bagus mana Low Pass Filter (LPF) dengan Kalman Filter?

Low-pass filter dan Kalman filter adalah dua jenis filter yang memiliki kegunaan yang berbeda dan digunakan dalam konteks yang berbeda.

Low-pass filter digunakan untuk menyaring sinyal dengan memperbolehkan komponen frekuensi rendah dari sinyal untuk dilewatkan sementara memblokir komponen frekuensi tinggi. Tujuannya adalah untuk menghilangkan noise atau sinyal yang tidak diinginkan dari sinyal yang diukur.

Sementara itu, Kalman filter adalah algoritma pengolahan data yang digunakan untuk memperkirakan keadaan sistem dinamis yang tidak dapat diamati langsung. Kalman filter digunakan dalam banyak aplikasi, termasuk navigasi, pengolahan sinyal, dan pengendalian proses, untuk menghasilkan perkiraan keadaan yang lebih akurat berdasarkan data pengamatan yang tidak sempurna.

Jadi, jika Anda perlu menyaring sinyal untuk menghilangkan noise atau sinyal yang tidak diinginkan, maka low-pass filter mungkin lebih sesuai. Namun, jika Anda perlu mengolah data pengamatan yang tidak sempurna untuk memperkirakan keadaan sistem, maka Kalman filter mungkin lebih cocok.

Perlu diingat bahwa kedua filter ini memiliki prinsip yang berbeda dan digunakan dalam konteks yang berbeda, sehingga tidak bisa dibandingkan secara langsung untuk menentukan yang mana yang lebih bagus. Tergantung pada kebutuhan dan tujuan Anda, salah satu filter mungkin lebih cocok daripada yang lain.

Sumber: https://www.researchgate.net/publication/340412171_Compact_laser-spectroscopic_gas_sensors_using_vertical-cavity_surface-emitting_lasers