Tentang proyek ini
Pengukuran tekanan sudah digunakan dalam berbagai situasi. Ini memberikan informasi tentang mekanisme gaya berjalan dan memiliki berbagai aplikasi, yaitu dalam situasi klinis dan olahraga. Dalam proyek ini sensor digunakan untuk mendapatkan wawasan tentang distribusi berat. Visualisasi real-time pemetaan tekanan juga disertakan karena lebih memudahkan untuk memahami data Anda.
Perangkat keras yang diperlukan - Arduino MKR1000 - Sebagian besar papan 3.3V atau 5V dengan Wi-Fi akan melakukan pekerjaan itu, tetapi saya tidak akan menganjurkan untuk menggunakan ESP untuk ini. Untuk beberapa alasan, beberapa papan ESP mengembalikan pengukuran yang tidak akurat saat membuat proyek ini.
- Resistor Peka Gaya (3). Saya menggunakan Interlink 402 (100 N). Saya juga menggunakan Interlink 406 yang lebih mahal, tetapi jika dipikir-pikir, 402 juga akan berhasil. Gunakan lebih banyak FSR untuk akurasi yang lebih baik.
- Resistor 10K. Ubah resistor untuk menskalakan pembacaan Anda agar berada dalam kisaran yang Anda inginkan. Semakin tinggi resistor, semakin besar kenaikannya. Temukan informasi lebih lanjut tentang ini di sini.
- Akselerometer, saya menggunakan 16G ADXL345. Gunakan ini untuk mengukur akselerasi dan gerakan kaki.
- Setrika solder untuk menyatukan semuanya. Klip buaya tidak berfungsi dengan baik di sepatu karena alasan yang jelas.
Menghubungkan semuanya 
Beberapa catatan singkat tentang sirkuit:
FSR: Baca ini sebelum Anda mulai solder: berhati-hatilah saat menyolder kabel ke FSR. Jangan mencoba melakukan ini jika Anda tidak yakin apakah Anda memiliki keterampilan tersebut. Anda perlu menyoldernya sangat cepat atau plastik meleleh. Percayalah, saya menemukannya dengan cara yang sulit...
Tidak ada sisi positif atau negatif dari FSR, jadi Anda tidak perlu khawatir tentang itu.
Seperti yang saya sebutkan sebelumnya, Anda dapat mengubah resistor untuk mengubah skala pembacaan Anda menjadi kisaran yang Anda inginkan.
Ground/5V: Seperti yang Anda lihat, semua sensor disolder ke saluran 5V dan umum.
Akselerometer: Anda dapat mengabaikan akselerometer jika Anda tidak membutuhkannya untuk proyek Anda. Tidak perlu menggunakannya jika Anda hanya ingin mengukur tekanan, tetapi mungkin berguna jika Anda ingin mengukur akselerasi, atau jika Anda perlu menganalisis siklus gaya berjalan. Namun, itu tidak sepenuhnya diperlukan untuk tutorial ini.
Memasang perangkat keras ke sol dalam
Saya sarankan untuk melakukan ini setelah menjalankan kode terlebih dahulu, karena jika Anda membuat kesalahan penyolderan, Anda akan mengetahuinya pada saat itu. Itu dapat menghemat kerumitan Anda saat memasang dan memasang kembali perangkat keras ke sol dalam jika Anda perlu menyolder ulang apa pun.
FSR melekat pada tiga titik insole. FSR kiri atas mengukur eversi, FSR kanan atas mengukur inversi, dan FSR di tumit mengukur tekanan tumit. Menemukan tempat yang tepat untuk FSR Anda adalah masalah mencoba. Posisi terbaik untuk memasangnya adalah tempat di mana nilai analog paling banyak berubah saat berjalan.
Pita digunakan untuk menahan kabel pada tempatnya. Jika mereka bergerak, dapat menyebabkan gangguan pada pembacaan FSR. Saya juga menggunakan pita velcro di bagian bawah sol dan bagian dalam sepatu untuk menahan sol dalam di tempatnya.
Pasang akselerometer ke bagian belakang tumit sepatu jika Anda menggunakannya. Saya telah menggunakan selotip dua sisi untuk itu.
Mengukur kekuatan
Sekarang kita siap untuk mengukur kekuatan. Catatan:Dalam dua bagian berikutnya saya menganggap sudah familiar dengan perpustakaan Thinger.io. Untuk informasi lebih lanjut tentang ini, saya merujuk ke bagian berjudul "mengirim data melalui Thinger.io".
Program ini memiliki bagian header yang cukup panjang, termasuk variabel yang diperlukan untuk mengatur, seperti data koneksi WiFi. Bagian ini juga mencakup variabel global, kebanyakan array, yang digunakan dalam program. Salah satu pilihan penting yang saya buat adalah menggunakan array sebanyak mungkin. Idenya adalah menggunakan elemen array individual untuk setiap sensor FSR. Jadi dalam hal ini array memiliki panjang 3.
Jangan biasakan menggunakan terlalu banyak variabel global, karena efek samping yang tidak diinginkan. Kami menggunakannya karena dalam beberapa kasus mereka perlu mengirim data melalui Thinger.io.
Kode dijelaskan di komentar. Kami akan membahas kode langkah demi langkah. Anda dapat mengunduh kode lengkapnya di bawah ini.
#define _DEBUG_ //memungkinkan kami menggunakan Serial Monitor
#include
#include
#include //Akselerometer
#include //Accelerometer
#include //Accelerometer
#include
#define USERNAME "yourUsername"
#define DEVICE_ID "yourDeviceID"
#define DEVICE_CREDENTIAL "yourDeviceCredential"
#define SSID "yourSSID"
#define SSID_PASSWORD "yourSSIDPassword"
//* Sensor FSR*/
#define noFSRs 3 // Jumlah FSR yang terhubung
#define FSR1 A1
#define FSR2 A2
#define FSR3 A3
float fsrVoltageArray[3 ]; // Pembacaan analog dikonversi dan diskalakan ke tegangan sebagai angka floating point
float fsrForceArray[3]; // Gaya dalam Newton
float fsrWeightInGramsArray[3]; // Berat dikonversi ke gram
int pinArray[3] ={FSR1, FSR2, FSR3}; // ID pin untuk ketiga perangkat
float forceMaxArray[3] ={100.0, 100.0, 100.0}; // Gaya maksimum yang didukung
juta apung =1000000.0; // Satuan untuk "1/mikro
konversi floatToKgrams =1.0/9.80665;
panjang K =1000;
panjang R =10*K; // R dalam K Ohm
panjang Vcc =5000; // 5V=5000mV, 3,3V =3300 mV
voltase apungMaks =0,98 * Vcc; // Tegangan maksimum diatur ke 95% Vcc. Atur gaya ke maksimum di luar nilai ini.
ThingerWifi101 hal(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL);
Jangan panik jika Anda belum memahami semuanya. Ini akan lebih masuk akal, setelah Anda melihat sisa kodenya.
Kami ingin memvisualisasikan hasilnya. Untuk ini kami menggunakan perpustakaan Wi-Fi Thinger.io. Koneksi ini diatur melalui baris berikut:
ThingerWifi101 hal(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL);
Argumen input diperoleh melalui akun Anda di Thinger.io, jadi Anda harus mengaturnya terlebih dahulu.
Dalam fungsi setup(), koneksi serial dibuat terlebih dahulu. Ini diikuti dengan panggilan untuk membuat koneksi WiFi.
pengaturan batal(batal) {
Serial.begin(115200); //Mulai Komunikasi Serial
thing.add_wifi(SSID, SSID_PASSWORD); //panggil untuk mengatur fungsi WiFi
}
void loop(void) {
thing.handle();
}
Selanjutnya, kita mendefinisikan "sesuatu" yang disebut "tekanan". Sebuah "benda" adalah konsep kunci dari perpustakaan Thinger.io. Berperilaku seperti fungsi, tetapi memiliki struktur khusus. Diperlukan untuk mengirim data hasil ke cloud. Detail lebih lanjut tentang perpustakaan ini dapat ditemukan di bagian "Kirim data melalui Thinger.io".
"Hal" yang disebut "tekanan" membaca nilai dari tiga sensor FSR dan mencetaknya di konsol serial. Nilai yang sama juga dikirim ke saluran "keluar". Dengan cara ini, kita dapat dengan mudah memverifikasi data input mentah.
Dalam "benda" dengan nama "tegangan", nilai tegangan dibaca dan disimpan dalam variabel lokal yang disebut "fsrReading". Dengan fungsi "peta", nilainya diskalakan, relatif terhadap nilai minimum dan maksimum yang didukung, dan dikembalikan ke dalam larik "fsrVoltageArray". Melalui for-loop, kami memastikan bahwa setiap FSR memiliki lokasinya sendiri dalam larik hasil ini.
Perhatikan bahwa semua kode dimasukkan ke dalam fungsi setup. Jangan memasukkan apa pun ke dalam loop (seperti yang mungkin sudah biasa Anda lakukan). Pustaka Thinger.io tidak dapat menanganinya...
pengaturan batal(batal) {
Serial.begin(115200); //Mulai Komunikasi Serial
thing.add_wifi(SSID, SSID_PASSWORD); //panggil untuk mengatur fungsi WiFi
/*sensor FSR*/
hal["tekanan"]>> [](pson &keluar) {
out["FSR1"] =analogRead (FSR1);
Serial.print("FSR1:");
Serial.println(analogRead(FSR1));
out["FSR2"] =analogRead(FSR2);
Serial.print("FSR2:");
Serial.println(analogRead(FSR2));
out["FSR3"] =analogRead(FSR3);
Serial.print( "FSR3:");
Serial.println(analogRead(FSR3));
};
hal["voltage"]>> [](pson &out) {
for (int FSR =0; FSR fsrVoltageArray[ FSR] =0,0; // Reset nilai saat masuk
fsrForceArray[FSR] =0.0;
int fsrPin =pinArray[FSR];
int fsrReading =analogRead(fsrPin);
fsrVoltageArray[FSR] =(mengambang) peta(fsrReading, 0, 1023, 0, 5000); //ubah 5000 ke nilai lain jika Anda tidak menggunakan perangkat 5V
} //akhir loop di atas FSR
out["FSR1voltage"] =fsrVoltageArray[0];
out ["FSR2voltage"] =fsrVoltageArray[1];
out["FSR3voltage"] =fsrVoltageArray[2];
};
void loop(void) {
thing.handle ();
//Jangan masukkan kode apa pun di sini karena Thinger.io tidak akan menyukainya.
}
Setelah for-loop selesai, nilai dikirim ke saluran keluaran "keluar". Setiap sensor memiliki string unik, seperti "FSR1voltage".
"Benda" yang disebut "newton" adalah fungsi yang paling kompleks dalam program ini. Ini mengubah tegangan menjadi gaya dalam Newton. Sekali lagi for-loop digunakan untuk melakukan ini untuk setiap FSR.
Perhitungannya cukup rumit, karena kita perlu membedakan beberapa kasus sudut. Jika nilai tegangan terlalu kecil, atau terlalu besar, kami menetapkan nilai tetap untuk gaya. Jika tegangan berada di antara nilai cut-off, fungsi logaritmik digunakan untuk menghitung gaya. Fungsi ini dipilih untuk mengurangi kemiringan kurva.
Perhatikan bahwa rumus hanya perkiraan. Setiap sensor mungkin memiliki kurva (agak) berbeda, tetapi untuk kesederhanaan, kami tidak membedakannya di sini.
Nilai yang dihasilkan dari perhitungan disimpan ke dalam array "fsrForceArray". Sekali lagi, setiap FSR memiliki posisinya sendiri dalam array ini. Tiga nilai akhir dikirim ke saluran keluaran "keluar".
Fungsi "benda" terakhir disebut "berat". Konversi langsung diterapkan untuk mengembalikan gaya sebagai berat dalam gram.
thing["newton"]>> [](pson &out) {
for (int FSR =0; FSR // Nilai dari gaya F sebagai fungsi dari tegangan V dihitung sebagai:F(V) =(Fmax/Vmax) * V
float force_value =(forceMaxArray[FSR]/voltageMax) * fsrVoltageArray[FSR];
// Tiga situasi dibedakan:
//
// 1. Jika V terlalu dekat dengan maksimum (seperti yang didefinisikan oleh voltageMax),
//
// 2 Jika gaya yang dihitung F terlalu kecil, kita set ke nol untuk menghindari efek noise.
//
// 3. Dalam semua kasus lain, kita ambil nilai logaritma untuk mengurangi sloop dan
if ( fsrVoltageArray[FSR] // V tidak terlalu tinggi di cabang ini
if ( force_value <=1.00 ) {
fsrForceArray[FSR] =0.0; // Force terlalu kecil, set ke nol
} else {
fsrForceArray[FSR] =log10(force_value); // Nilainya oke, ambil log ini
}
} else {
// Tutup gaya jika tegangan terlalu dekat dengan Vcc (untuk Vcc akan tak terhingga)
fsrForceArray[FSR] =log10(forceMaxArray[FSR]);
Serial.print("Cut off diaktifkan untuk FSR ="); Serial.println(FSR);
}
} // Akhir loop pada FSR
out["FSR1newton"] =fsrForceArray[0];
out["FSR2newton"] =fsrForceArray[1];
out["FSR3newton"] =fsrForceArray[2];
}; //akhir benda
benda["berat"]>> [](pson &out) {
// Perhitungan langsung untuk mengubah gaya dalam Newton menjadi berat dalam gram
untuk ( int FSR =0; FSR fsrWeightInGramsArray[FSR] =fsrForceArray[FSR] * conversionToKgrams * 1000.0;
}
out["FSR1weight"] =fsrWeightInGramsArray[0];
out["FSR2weight"] =fsrWeightInGramsArray[1];
out["FSR3weight"] =fsrWeightInGramsArray[2];
}; //akhirnya
Jangan lupa untuk mengatur dasbor di Thinger.io. Saya berasumsi Anda tahu cara kerjanya.
Petunjuk :Jika semuanya berfungsi seperti yang diharapkan, dasbor Anda akan terlihat seperti ini:
Mengukur percepatan
Ini sebenarnya jauh lebih mudah daripada mengukur tekanan. Kita perlu menambahkan beberapa kode ke bagian header terlebih dahulu. Kita mulai dengan Menyertakan pustaka "Wire.h" (untuk berkomunikasi dengan pin SDA dan SDL), "Adafruit_Sensor.h", dan "Adafruit_ADXL345_U.h". Kami juga membutuhkan tiga variabel global baru, sehingga kami dapat mengukur dan mentransfer percepatan pada sumbu x, y dan z
Jangan hapus perpustakaan yang telah Anda tambahkan sebelumnya. Anda akan memerlukan ini untuk koneksi ke Thinger.io.
Di blok kode berikutnya, kami memeriksa akselerometer untuk merespons. Jika tidak, tidak akan terjadi apa-apa. Jika tidak, rentang ditentukan dan "benda" yang disebut "akselerometer" dijalankan. Ini menanyakan perangkat dan mengirimkan tiga nilai percepatan dalam arah x, y, dan z ke saluran "keluar" keluaran.
Bagian kode ini mirip dengan kode sampel Adafruit yang disertakan (File> Contoh> Adafruit ADXL345), tetapi saya meninggalkan beberapa bagian, karena kita tidak membutuhkannya.
#include
#include
#include
/* Tetapkan ID unik untuk sensor ini di waktu yang sama */
Adafruit_ADXL345_Unified accel =Adafruit_ADXL345_Unified(12345);
int x =0;
int y =0;
int z =0;
pengaturan void(void) {
Serial.begin(115200);
if(!accel.begin()) { // Inisialisasi sensor
Serial.println("Tidak ADXL345 terdeteksi");
} else {
// Rentang untuk sensor ini - Jika Anda tidak tahu rentangnya, jalankan
// displayDataRate dari kode contoh ADXL345 yang disediakan oleh Adafruit
accel.setRange(ADXL345_RANGE_16_G);
hal["akselerometer"]>> [](pson&out){ // Fungsi "benda" baru untuk Thinger.io
sensor_event_t event;
accel.getEvent(&event); // Dapatkan peristiwa sensor baru
out["x"] =event.acceleration.x; // Menampilkan hasil (percepatan diukur dalam m/s^2)
out["y"] =event.acceleration.y;
out["z"] =event.acceleration.z;
Serial.print("X:"); Serial.print(event.acceleration.x); Serial.print(" ");
Serial.print("Y:"); Serial.print(event.acceleration.y); Serial.print(" ");
Serial.print("Z:"); Serial.print(event.acceleration.z); Serial.print(" ");Serial.println("m/s^2 ");
}; //end of thing
} //end of if/else statement
}
Petunjuk: setelah menjalankan kode di atas, output Anda akan terlihat seperti contoh di bawah ini
Menyatukan semuanya
Silakan temukan kode lengkapnya di bagian bawah halaman :)
Kirim data melalui Thinger.io
Pustaka ini didokumentasikan dengan baik di sini, tetapi berikut adalah beberapa informasi penting untuk membuat "sesuatu" (tidak ada permainan kata-kata) lebih mudah untuk ditulis dan digunakan.
Thinger.io adalah perpustakaan yang sangat luas. Di bagian ini kami hanya membahas fungsionalitas yang dibutuhkan dan digunakan dalam aplikasi kami. Strukturnya adalah sebagai berikut (perhatikan titik koma ";" setelah kurung kurawal penutup "}"):
hal[]>> [](pson&out)
{
};
Ini disebut fungsi lambda di C++. Kata pertama wajib untuk memulai definisi adalah "benda" dan seluruh fungsi juga disebut sebagai "benda".
String (misalnya hal["myFirstThing"] ) memberi nama pada fungsi tersebut. Setiap "benda" harus memiliki nama yang unik.
Simbol ">>" menunjukkan bahwa "benda" ini hanya memiliki nilai keluaran. Jika input diperlukan, ubah ini menjadi "<<". Jika input dan output diperlukan, simbol "=" harus digunakan. Dalam kasus kami, kami hanya memiliki nilai keluaran.
Argumen "pson &out" berarti bahwa nilai keluaran kami dikirim melalui struktur data yang disebut "keluar". Tipe data "pson" sangat fleksibel dan dapat berisi berbagai jenis variabel, dan juga mendukung dokumen JSON.
Dalam kode kami, kami menggunakan formulir "out[] =value" t o kirim nilai ke tampilan visualisasi yang terhubung dengan panggilan "ThingerWifi101 thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL)" di bagian pertama program.
Seperti yang mungkin Anda perhatikan, biasanya tidak banyak kode di dalam fungsi loop. Anda hanya perlu memanggil "thing.handle()". Anda dapat memanggil titik akhir dan mengalirkan sumber daya di bagian loop juga. Semua kode lainnya ditangani dalam "hal" yang Anda tetapkan.
Kode di dalam "sesuatu" dilingkarkan terus menerus. Penting untuk memasukkan perhitungan Anda ke dalam "hal" jika data Anda diperbarui secara berkala, seperti dalam kasus kami.
FAQ
Tidak ada yang terjadi!
Periksa kabel Anda. Kemungkinan ada sesuatu yang rusak pada level ini. Jika tidak ada yang muncul di dalam Serial Monitor Anda, periksa apakah "#define _DEBUG_" ada di baris pertama kode Anda. TLS mungkin juga mengganggu. Anda dapat menonaktifkannya, tetapi berhati-hatilah dengan ini. Periksa juga apakah koneksi Anda ke Thinger.io berfungsi dengan baik.
Keluaran tidak seperti yang diharapkan
Apakah semua kode yang perlu diperbarui di dalam "benda"? Jika itu di luar "benda" itu tidak diperbarui. Saya juga menemukan bahwa perangkat ESP tidak bekerja dengan baik dengan sensor FSR tanpa alasan yang jelas.
Yang keluaran adalah tidak diperbarui secara teratur
Apakah Anda menambahkan penundaan ke kode Anda? Hapus mereka :) Anda dapat mengatur kecepatan refresh di Thinger.io itu sendiri.
Saya lebih suka memiliki semua keluaran dalam satu grafik
Tambahkan semua kode di dalam satu "benda"
Bagus!
Saya harap tutorial ini membantu Anda memahami dasar-dasar sensor FSR, akselerometer, dan Thinger.io. Saya ingin membaca saran apa pun untuk meningkatkan kode ini, dan tolong jangan malu dan bagikan kreasi Anda!
Kode
Tutorial-Insole-SmartArduino
Kode lengkap tutorial ini#define _DEBUG_ //Pastikan ini ada sebelum penyertaan lainnya atau board Anda mungkin mogok/*Silakan temukan tutorialnya di sini:https://www.hackster.io/projects/a5ceae*/# include //Thinger#include //Thinger#include //Accelerometer#include //Accelerometer#include //Accelerometer# tentukan USERNAME "namaPengguna Anda"#tentukan DEVICE_ID "Perangkat Anda"#tentukan DEVICE_CREDENTIAL "Kredensial Anda"#tentukan SSID "SSID Anda"#tentukan SSID_PASSWORD "SandiSSID Anda"Adafruit_ADXL345_Unified accel =Adafruit_ADXL345_Unified(ADXL12345_Unified); //Akselerometerint x =0; //Setel ulang ke 0 int y =0;int z =0; //*sensor FSR*/#define noFSRs 3 // Jumlah FSR yang terhubung#define FSR1 A1 //Port analog#define FSR2 A2 #define FSR3 A3 float fsrVoltageArray[3]; // Pembacaan analog dikonversi dan // diskalakan ke tegangan sebagai floating point //numberfloat fsrForceArray[3]; // Gaya dalam Newtonfloat fsrWeightInGramsArray[3]; // Bobot dikonversi ke gramint pinArray[3] ={FSR1, FSR2, FSR3}; // ID pin untuk //tiga perangkatfloat forceMaxArray[3] ={100.0, 100.0, 100.0}; // Pasukan maksimum //supportedfloat million =1000000.0; // Satuan untuk "1/konversi mikrofloatToKgrams =1.0/9.80665;panjang K =1000;panjang R =10*K; // R dalam K Ohmlong Vcc =5000; // 5V=5000mV, 3.3V =3300 mVvoltase apungMaks =0,98 * Vcc; // Tegangan maksimum diatur ke 95% Vcc. Atur // gaya ke maksimum di luar //nilai ini.ThingerWifi101 thing(USERNAME, DEVICE_ID, DEVICE_CREDENTIAL); //Panggil untuk mengatur fungsi WiFi, batalkan pengaturan(void) { Serial.begin(115200); thing.add_wifi(SSID, SSID_PASSWORD); if(!accel.begin()) { //Inisialisasi sensor Serial.println("Tidak ada ADXL345 yang terdeteksi."); } else { accel.setRange (ADXL345_RANGE_16_G); //Rentang untuk sensor ini["accelerometer"]>> [](pson&out){ sensor_event_t event; accel.getEvent(&event); out["x"] =event.acceleration.x; out[ "y"] =event.acceleration.y; out["z"] =event.acceleration.z; }; } /*FSR sensor*/ thing["pressure"]>> [](pson &out) { out ["FSR1"] =analogRead(FSR1); // Serial.print("FSR1:"); // Serial.println(analogRead(FSR1)); out["FSR2"] =analogRead(FSR2); // Serial .print("FSR2:"); // S erial.println(analogRead(FSR2)); out["FSR3"] =analogRead(FSR3); // Serial.print("FSR3:"); // Serial.println(analogRead(FSR3)); }; hal["tegangan"]>> [](pson &keluar) { for (int FSR =0; FSR > [](pson &out) { for (int FSR =0; FSR > [](pson &out) { //Perhitungan langsung untuk mengubah gaya dalam Newton menjadi berat dalam gram untuk (int FSR =0; FSR Skema
Tiga FSR (dengan pembagi tegangan) dan akselerometer. 
