Girino - Fast Arduino Oscilloscope

Saya seorang ahli fizik dan bahagian paling baik dalam bidang ini ialah saya dapat membina instrumen saya sendiri. Dengan cara pemikiran ini, saya memutuskan untuk membina Homebrew Arscino Oscilloscope. Pengajaran ini ditulis dengan tujuan mengajar sedikit mengenai mikrokontroler dan pengambilalihan data. Ini adalah satu projek yang melampau kerana saya mahu memerah dari Arduino sejauh halangan seperti yang saya boleh, saya tidak nampak lain Arscino Oscilloscope secepat ini.

Beberapa ketika dahulu saya sedang menjalankan projek Arduino dan saya perlu melihat sama ada isyarat keluaran mematuhi spesifikasi. Oleh itu saya meluangkan sedikit masa di internet untuk mencari Arduino Oscilloscopes yang sudah dilaksanakan, tetapi saya tidak suka apa yang saya dapati. Projek yang saya dapati kebanyakannya terdiri daripada Antara Muka Pengguna Grafis untuk komputer yang ditulis dalam Pemprosesan dan lakaran arduino yang sangat mudah. Lekapan adalah seperti: persediaan tidak sah () {

Serial.begin (9600);

}

kekosongan gelung () {

int val = analogRead (ANALOG_IN);

Serial.println (val);

} Pendekatan ini tidak salah dan saya tidak mahu menghina sesiapa, tetapi ini terlalu lambat untuk saya. Port siri lambat dan menghantar setiap hasil analogRead () melalui ia adalah hambatan.

Saya telah mengkaji Waveform Digitizers untuk beberapa waktu dan saya tahu dengan baik bagaimana mereka bekerja, jadi saya mendapat ilham dari mereka. Ini adalah titik awal osiloskop yang saya ingin buat:

  • isyarat yang akan datang hendaklah dihancurkan dari arduino untuk memeliharanya;
  • dengan mengimbangi isyarat ia mungkin untuk melihat isyarat negatif;
  • data harus dipertahankan;
  • pemicu perkakasan diperlukan untuk menangkap isyarat;
  • penampan bulat boleh memberi bentuk isyarat sebelum pencetus (lebih banyak untuk diikuti pada titik ini);
  • dengan menggunakan fungsi tuil yang lebih rendah, yang standard membuat program berjalan dengan lebih cepat.

Lakaran untuk Arduino dilampirkan pada langkah ini, bersama dengan skema litar yang saya buat.

Nama yang saya datang dengan, Girino, adalah pun bahasa Itali. Giro bererti putaran dan menambah sufiks -ino anda mendapat giliran kecil, tetapi Girino juga bererti tadpole . Dengan cara ini saya mendapat nama dan maskot.

Langkah 1: Penafian

PENYATAAN INI YANG TIDAK MEMBUAT TIDAK MEMBUAT JAMINAN KESALAHAN DAN TIDAK ADA JAMINAN WHATSOEVER .

Elektronik boleh berbahaya jika anda tidak tahu apa yang anda lakukan dan penulis tidak dapat menjamin kesahihan maklumat yang terdapat di sini. Ini bukan nasihat profesional dan apa yang ditulis dalam pengajaran ini boleh tidak tepat, mengelirukan, berbahaya atau salah. Jangan bergantung kepada apa-apa maklumat yang terdapat di sini tanpa pengesahan bebas.

Terpulang kepada anda untuk mengesahkan apa-apa maklumat dan untuk memeriksa semula bahawa anda tidak mendedahkan diri anda, atau sesiapa, kepada apa-apa kemudaratan atau mendedahkan apa-apa kepada apa-apa kerosakan; Saya tidak bertanggungjawab. Anda perlu mengikuti sendiri langkah berjaga-jaga keselamatan yang betul, jika anda ingin menghasilkan semula projek ini.

Gunakan panduan ini dengan risiko anda sendiri!

Langkah 2: Apa yang Anda Perlu

Apa yang kita perlukan untuk projek ini adalah papan Arduino dan datasheet ATMega328P.
Lembaran data adalah apa yang memberitahu kita bagaimana kerja mikrokontroler dan sangat penting untuk memastikannya jika kita menginginkan kawalan yang lebih rendah.

Lembaran data boleh didapati di sini: //www.atmel.com/Images/doc8271.pdf

Perkakasan yang saya tambah kepada Arduino sebahagiannya diperlukan, tujuannya adalah untuk membentuk isyarat untuk ADC dan untuk memberikan tahap voltan untuk pemicu. Jika anda mahu, anda boleh menghantar isyarat terus ke Arduino dan gunakan beberapa rujukan voltan yang ditakrifkan oleh pembahagi voltan, atau walaupun 3.3 V yang diberikan oleh Arduino itu sendiri.

Langkah 3: Output Debug

Saya biasanya meletakkan banyak output debug dalam program saya kerana saya ingin menjejaki apa-apa yang berlaku; masalah dengan Arduino adalah bahawa kita tidak mempunyai stdout untuk menulis kepada. Saya memutuskan untuk menggunakan port Serial sebagai stdout.

Sedarlah, pendekatan ini tidak berfungsi sepanjang masa! Kerana menulis ke port Serial memerlukan sedikit masa untuk pelaksanaan dan ia secara dramatik boleh mengubah perkara-perkara semasa rutin yang wajar.

Saya biasanya menentukan output debugging di dalam makro preprocessor, jadi apabila debug dilumpuhkan, mereka hanya hilang dari program dan tidak memperlambat pelaksanaan:
  • dprint (x); - Menulis kepada port bersiri seperti: # x: 123
  • dshow ("Sesetengah rentetan"); - Menulis rentetan

Inilah definisi:

#if DEBUG == 1
#define dprint (ungkapan) Serial.print ("#"); Serial.print (#expression); Serial.print (":"); Serial.println (ungkapan)
#define dshow (ungkapan) Serial.println (ungkapan)
#else
#define dprint (ekspresi)
#define dshow (ungkapan)
#endif

Langkah 4: Menetapkan Daftar Bit

Dengan tujuan untuk menjadi pantas, adalah perlu untuk memanipulasi ciri mikrokontroler dengan fungsi tuil yang lebih rendah daripada yang standard yang disediakan oleh Arduino IDE. Fungsi dalaman diuruskan melalui beberapa daftar, yang merupakan koleksi lapan bit di mana setiap orang mentadbir sesuatu yang tertentu. Setiap daftar mengandungi lapan bit kerana ATMega328P mempunyai arsitektur 8-bit.

Daftar tersebut mempunyai beberapa nama yang dinyatakan dalam lembaran data bergantung kepada makna mereka, seperti ADCSRA untuk ADC Settings List A. Juga setiap bit yang bermakna dari register mempunyai nama, seperti ADEN untuk ADC Enable Bit dalam ADCSRA register.

Untuk menetapkan bit mereka, kita boleh menggunakan sintaks C biasa untuk algebra binari, tetapi saya dapati di internet beberapa makro yang sangat bagus dan bersih:

/ / Menetapkan untuk menetapkan dan membersihkan bit pendaftaran
#ifndef cbi
#define cbi (sfr, bit) (_SFR_BYTE (sfr) & = ~ _BV (bit))
#endif
#ifndef sbi
#define sbi (sfr, bit) (_SFR_BYTE (sfr) | = _BV (bit))
#endif

Menggunakannya sangat mudah, jika kita mahu menetapkan 1 Enable Bit of ADC kita boleh menulis:

sbi (ADCSRA, ADEN);

Walaupun jika kami ingin menetapkannya kepada 0 ( id est jelaskannya) kita boleh menulis:

cbi (ADCSRA, ADEN);

Langkah 5: Apakah Gangguan tersebut

Seperti yang akan kita lihat dalam langkah seterusnya, penggunaan interupsi diperlukan dalam projek ini. Gangguan adalah isyarat yang memberitahu mikrokontroler untuk menghentikan pelaksanaan gelung utama dan lulus ke beberapa fungsi khas. Imej-imej memberi idea aliran program.

Fungsi-fungsi yang dilaksanakan disebut Interrupt Service Routines (ISR) dan fungsi lebih atau kurang mudah, tetapi itu tidak mengambil argumen.

Marilah kita melihat contoh, seperti mengira beberapa denyutan. ATMega328P mempunyai Comparator Analog yang mempunyai interupsi berkaitan yang diaktifkan apabila isyarat melebihi voltan rujukan. Pertama sekali anda mesti menentukan fungsi yang akan dikeluarkan:

ISR (ANALOG_COMP_vect)
{
kaunter ++;
}

Ini sangat mudah, arahan ISR () adalah makro yang memberitahu pengkompil bahawa fungsi berikut adalah Rutin Perkhidmatan Interrupt. Walaupun ANALOG_COMP_vect dipanggil Vector Interrupt dan ia memberitahu compiler yang mengganggu dikaitkan dengan rutin itu. Dalam kes ini, ia adalah Analog Comparator Interrupt. Jadi setiap kali bahawa komparator melihat isyarat yang lebih besar daripada rujukan ia memberitahu mikrokontroler untuk melaksanakan kod itu, id est dalam kes ini untuk menambah pemboleh ubah itu.

Langkah seterusnya adalah untuk membolehkan interupsi yang berkaitan. Untuk membolehkannya, kita mesti menetapkan sedikit ACIE (Analog Comparator Interrupt Enable) yang mendaftar: ACSR (Daftar Penyusun Comparator Analog):

sbi (ACSR, ACIE);

Di laman web berikut, kita dapat melihat senarai semua Vectors Interrupt:
//www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

Langkah 6: Memperolehi secara berterusan dengan Penampan Pekeliling

Konsep menggunakan Penampan Circular cukup lurus ke hadapan:

Memperolehi secara berterusan sehingga isyarat dijumpai, kemudian hantar isyarat digitasi ke komputer.

Pendekatan ini membolehkan bentuk isyarat masuk juga sebelum peristiwa pencetus.


Saya menyediakan beberapa rajah untuk membuat diri saya jelas. Perkara-perkara berikut merujuk kepada imej.
  • Pada imej pertama kita dapat melihat apa yang saya maksudkan dengan pemerolehan yang berterusan . Kami menentukan penimbal yang akan menyimpan data, dalam kes saya array dengan 1280 slot, maka kita mula membaca terus ADC output register (ADCH) iklan mengisi penampan dengan data. Apabila kita sampai ke penghujung penambangan kita mula semula dari awal tanpa membersihkannya. Sekiranya kita menghidupkan tatasusunan yang disusun dengan cara bulat, mudah untuk melihat apa yang saya maksudkan.
  • Apabila isyarat melebihi ambang, Analog Comparator Interrupt diaktifkan. Kemudian kita memulakan fasa menunggu di mana kita terus memperoleh isyarat tetapi menyimpan kiraan kitaran ADC yang diluluskan dari Analog Comparator Interrupt.
  • Apabila kita menunggu kitaran N (dengan N <1280), kita membekukan keadaan dan menghentikan kitaran ADC. Jadi kita berakhir dengan penampan yang dipenuhi dengan pendigitan bentuk temporal temporal. Sebahagian besar daripada ini, kita juga mempunyai bentuk sebelum peristiwa pencetus, kerana kita sudah memperoleh sebelum itu.
  • Sekarang kita boleh menghantar keseluruhan penampan ke port bersiri dalam blok data binari, dan bukannya menghantar bacaan ADC tunggal. Ini mengurangkan overhead yang diperlukan untuk menghantar data dan kesesakan sketsa yang saya dapati di internet.

Langkah 7: Memacu Oscilloscope

Osiloskop menunjukkan pada paparan isyarat, pada kita semua bersetuju, tetapi bagaimana ia boleh menunjukkannya dengan mantap dan tidak menunjukkan ia melompat di sekitar skrin? Ia mempunyai pencetus dalaman yang mampu menunjukkan isyarat sentiasa pada kedudukan yang sama pada skrin (atau sekurang-kurangnya kebanyakan masa), mewujudkan ilusi plot yang stabil.

Pencetus dikaitkan dengan ambang yang mengaktifkan penyapu apabila isyarat melewatinya. Satu sapuan adalah fasa di mana rekod oscilloscope dan memaparkan isyarat. Selepas menyapu fasa lain berlaku: penangguhan, di mana osiloskop menolak mana-mana isyarat masuk. Tempoh pemegangan boleh terdiri daripada sebahagian masa mati, di mana oscilloscope tidak dapat menerima apa-apa isyarat, dan bahagian yang boleh dipilih oleh pengguna. Masa mati boleh disebabkan oleh pelbagai sebab seperti yang perlu dilukis di skrin atau menyimpan data di suatu tempat.

Melihat imej kita mendapat gambaran tentang apa yang berlaku.
  1. Isyarat 1 melebihi ambang dan mengaktifkan sapuan;
  2. isyarat 2 berada di dalam masa menyapu dan ditangkap dengan yang pertama;
  3. selepas penangguhan, isyarat 3 mengaktifkan sapuan sekali lagi;
  4. sebaliknya isyarat 4 ditolak kerana ia jatuh di dalam kawasan pemegangan.
The raison d'être fasa holdoff adalah untuk mengelakkan beberapa isyarat yang tidak diingini untuk masuk ke kawasan menyapu. Ia agak lama untuk menerangkan maksud ini dan ia tidak bertujuan tujuan pengajaran ini.

Moral cerita ini adalah yang kita perlukan:
  1. tahap ambang ke mana kita dapat membandingkan isyarat masuk;
  2. isyarat yang memberitahu mikrokontroler untuk memulakan fasa menunggu (lihat langkah sebelumnya).
Kami mempunyai beberapa penyelesaian yang mungkin untuk titik 1.:
  • menggunakan perapi yang kita dapat menetapkan tahap voltan secara manual;
  • menggunakan PWM Arduino kita boleh menetapkan tahap oleh perisian;
  • menggunakan 3.3 V yang disediakan oleh Arduino itu sendiri;
  • menggunakan rujukan bangap dalaman kita boleh menggunakan tahap tetap.
Untuk titik 2. kita mempunyai penyelesaian yang tepat: kita boleh menggunakan gangguan dari Pembanding Analog dalaman pengawal mikrokontroler.

Langkah 8: Bagaimana ADC berfungsi

Mikrokontroller Arduino mempunyai ADC penghampiran 10-bit berturut-turut. Sebelum ADC terdapat pemultipleks analog yang membolehkan kita menghantar, ke ADC, isyarat dari pin dan sumber yang berlainan (tetapi hanya satu pada satu masa).

Penghampiran ADC secara beransur-ansur bermaksud ADC mengambil 13 siklus jam untuk menyelesaikan penukaran (dan 25 pusingan jam untuk penukaran pertama). Terdapat isyarat jam yang didedikasikan untuk ADC yang "dikira" dari jam utama Arduino; ini kerana ADC agak perlahan dan tidak dapat mengikuti perkembangan bahagian mikropengawal lain. Ia memerlukan frekuensi jam input antara 50 kHz dan 200 kHz untuk mendapatkan resolusi maksimum. Jika resolusi lebih rendah daripada 10 bit diperlukan, frekuensi jam masukan ke ADC boleh lebih tinggi daripada 200 kHz untuk mendapatkan kadar sampel yang lebih tinggi.

Tetapi berapa kadar yang lebih tinggi yang boleh kita gunakan? Terdapat beberapa panduan yang baik mengenai ADC di Makmal Muzik Terbuka yang saya cadangkan untuk membaca:
  • //www.openmusiclabs.com/learning/digital/atmega-adc/
  • //www.openmusiclabs.com/learning/digital/atmega-adc/in-depth/
Oleh kerana tujuan saya adalah untuk mendapatkan osiloskop pantas saya memutuskan untuk menghadkan ketepatan kepada 8-bit. Ini mempunyai beberapa bonus:
  1. penimbalan data boleh menyimpan lebih banyak data;
  2. anda tidak membuang 6-bit RAM setiap datum;
  3. ADC boleh memperoleh lebih cepat.
Prescaler membolehkan kita membahagikan frekuensi, oleh beberapa faktor, dengan menetapkan ADPS0-1-2 bit dari senarai ADCSRA. Melihat plot ketepatan dari Artikel Makmal Muzik Terbuka, kita dapat melihat bahawa untuk ketepatan 8-bit kekerapan boleh mencapai 1.5 MHz, baik! Tetapi sejak keupayaan mengubah faktor prescaler membolehkan kita menukar kadar pengambilalihan, kita juga boleh menggunakannya untuk mengubah skala masa osiloskop.

Terdapat ciri yang baik mengenai daftar output: kita boleh menentukan penyesuaian bit penukaran, dengan menetapkan bit ADLAR dalam daftar ADMUX. Sekiranya 0 mereka betul diselaraskan dan viceversa (lihat gambar). Oleh kerana saya mahukan ketepatan 8 bit saya menetapkan kepada 1 supaya saya dapat membaca hanya pendaftaran ADCH dan mengabaikan ADCL.

Saya memutuskan untuk mempunyai hanya satu saluran masukan untuk mengelakkan perlu menukar saluran ke belakang dan sebagainya pada setiap penukaran.

Satu perkara terakhir tentang ADC, ia mempunyai mod berlainan yang berbeza masing-masing dengan sumber pencetus yang berbeza:
  • Mod Running Percuma
  • Pembanding Analog
  • Permintaan Pengganggu Luar 0
  • Pemasa / Counter0 Bandingkan Perlawanan A
  • Limpa / Counter0 Limpahan
  • Timer / Counter1 Bandingkan Match B
  • Limpahan / Kawalan Litar 1 / Counter1
  • Acara Tangkap Pemasa / Kaunter 1
Saya berminat dengan mod berjalan bebas yang merupakan mod di mana ADC terus menukar input dan melemparkan Interrupt pada akhir setiap penukaran (vektor berkaitan: ADC_vect).

Langkah 9: Pengambilan Input Digital

Pin input analog Arduino juga boleh digunakan sebagai pin I / O digital, oleh itu ia mempunyai penimbal input untuk fungsi digital. Sekiranya kita mahu menggunakannya sebagai analog analog, anda harus mematikan ciri ini.

Menghantar isyarat analog kepada pin digital menyebabkan ia bertukar-tukar antara keadaan TINGGI dan LOW, terutamanya jika isyarat adalah berhampiran sempadan antara kedua-dua negeri; toggling ini menginduksi beberapa bunyi ke litar terdekat seperti ADC itu sendiri (dan menginduksi penggunaan energi yang lebih tinggi).

Untuk melumpuhkan penimbal digital kita harus menetapkan bit ADCnD dari daftar DIDR0:

sbi (DIDR0, ADC5D);
sbi (DIDR0, ADC4D);
sbi (DIDR0, ADC3D);
sbi (DIDR0, ADC2D);
sbi (DIDR0, ADC1D);
sbi (DIDR0, ADC0D);

Langkah 10: Menetapkan ADC

Dalam lakaran, saya menulis fungsi inisial yang menyusun semua parameter fungsi ADC. Oleh kerana saya cenderung untuk menulis kod yang bersih dan mengulas, saya akan melepasi fungsi di sini. Kita boleh merujuk kepada langkah sebelumnya dan komen untuk makna daftar. void initADC (void)
= (ADCPIN & 0x07);

// ------------------------------------------------ ---------------------
// Pengaturan ADCSRA
// ------------------------------------------------ ---------------------
// Menulis sedikit ini kepada satu membolehkan ADC. Dengan menulisnya kepada sifar,
// ADC dimatikan. Menghidupkan ADC semasa penukaran berada
// kemajuan, akan menamatkan penukaran ini.
cbi (ADCSRA, ADEN);
// Dalam mod Penukaran Single, tulis sedikit ini kepada satu untuk memulakan setiap
// penukaran. Dalam mod Running Percuma, tulis sedikit ini kepada satu untuk memulakannya
// penukaran pertama. Penukaran pertama selepas ADSC telah ditulis
// selepas ADC telah diaktifkan, atau jika ADSC ditulis pada masa yang sama
// masa sebagai ADC diaktifkan, akan mengambil 25 siklus jam ADC dan bukannya
/ / normal 13. Penukaran pertama ini melakukan inisialisasi
// ADC. ADSC akan membaca sebagai satu selagi penukaran sedang dijalankan.
// Apabila penukaran selesai, ia akan kembali menjadi sifar. Menulis sifar kepada
/ // bit ini tidak mempunyai kesan.
cbi (ADCSRA, ADSC);
// Apabila bit ini ditulis kepada satu, Pencetus Auto ADC adalah
// didayakan. ADC akan memulakan penukaran pada kelebihan positif
/ // isyarat pencetus terpilih. Sumber pencetus dipilih dengan tetapan
// pemicu ADC Pilih bit, ADTS dalam ADCSRB.
sbi (ADCSRA, ADATE);
// Apabila bit ini ditulis kepada satu dan I-bit dalam SREG ditetapkan, yang
// Interc Lengkap Interrupt diaktifkan.
sbi (ADCSRA, ADIE);
// Bit ini menentukan faktor bahagian antara jam sistem
// frekuensi dan jam input ke ADC.
/ ADPS2 ADPS1 ADPS0 Factor Division
// 0 0 0 2
// 0 0 1 2
// 0 1 0 4
// 0 1 1 8
// 1 0 0 16
// 1 0 1 32
// 1 1 0 64
// 1 1 1 128
sbi (ADCSRA, ADPS2);
sbi (ADCSRA, ADPS1);
sbi (ADCSRA, ADPS0);

// ------------------------------------------------ ---------------------
// Pengaturan ADCSRB
// ------------------------------------------------ ---------------------
// Apabila bit ini ditulis satu logik dan ADC dimatikan
// (ADEN dalam ADCSRA adalah sifar), multiplexer ADC memilih negatif
/ input ke Comparator Analog. Apabila bit ini ditulis logik sifar,
// AIN1 digunakan untuk input negatif dari Comparator Analog.
cbi (ADCSRB, ACME);
// Jika ADATE dalam ADCSRA ditulis kepada satu, nilai bit ini
/ / memilih sumber mana yang akan mencetuskan penukaran ADC. Jika ADATE adalah
/ // dibersihkan, tetapan ADTS2: 0 tidak mempunyai kesan. Penukaran akan
/ / dicetuskan oleh tepi yang semakin meningkat dari Flag Interrupt yang dipilih. Catatan
// yang beralih dari sumber pencetus yang dibersihkan ke pemicu
// sumber yang ditetapkan, akan menghasilkan kelebihan positif pada pemicu
// isyarat. Jika ADEN dalam ADCSRA ditetapkan, ini akan memulakan penukaran.
// Menukar ke mod Running Percuma (ADTS [2: 0] = 0) tidak akan menyebabkan
// peristiwa pencetus, walaupun bendera ADC Interrupt ditetapkan.
/ ADTS2 ADTS1 ADTS0 Sumber pencetus
// 0 0 0 Mod Running Percuma
// 0 0 1 Analog Comparator
// 0 1 0 Permintaan Interrupt Luar 0
// 0 1 1 Timer / Counter0 Bandingkan Padanan A
// 1 0 0 Pemasa / Counter0 Limpahan
// 1 0 1 Timer / Counter1 Bandingkan Padanan B
// 1 1 0 Limpa / Counter1 Limpahan
// 1 1 1 Tangkapan / Kaunter 1 Tangkapan Acara
cbi (ADCSRB, ADTS2);
cbi (ADCSRB, ADTS1);
cbi (ADCSRB, ADTS0);

// ------------------------------------------------ ---------------------
// Pengaturan DIDR0
// ------------------------------------------------ ---------------------
// Apabila bit ini ditulis satu logik, penimbal input digital pada
// PIN ADC sepadan dilumpuhkan. Daftar PIN yang sepadan
// bit akan sentiasa dibaca sebagai sifar apabila bit ini ditetapkan. Apabila analog
// isyarat digunakan pada PIN ADC5..0 dan input digital daripada ini
// pin tidak diperlukan, bit ini harus ditulis logik untuk mengurangkan
// penggunaan kuasa dalam penimbulan input digital.
// Perhatikan bahawa pin ADC ADC7 dan ADC6 tidak mempunyai buffer input digital,
// dan oleh itu tidak memerlukan bit Digital Input Disable.
sbi (DIDR0, ADC5D);
sbi (DIDR0, ADC4D);
sbi (DIDR0, ADC3D);
sbi (DIDR0, ADC2D);
sbi (DIDR0, ADC1D);
sbi (DIDR0, ADC0D);

Langkah 11: Bagaimana Perbandingan Analog berfungsi

Comparator Analog adalah modul dalaman mikrokontroler dan ia membandingkan nilai input pada pin positif (Digital Pin 6) dan pin negatif (Digital Pin 7). Apabila voltan pada pin positif lebih tinggi daripada voltan pada pin negatif AIN1, Analog Comparator menghasilkan 1 dalam bit ACO dari daftar ACSR.

Secara pilihan, komparator boleh mencetuskan gangguan, eksklusif kepada Comparator Analog. Vektor yang berkaitan ialah ANALOG_COMP_vect.

Kami juga boleh menetapkan gangguan yang akan dilancarkan pada pinggir yang semakin meningkat, jatuh ke tepi atau pada togol keadaan.

The Comparator Analog adalah apa yang kita perlukan untuk mencetuskan menyambungkan isyarat masukan ke pin 6, sekarang apa yang tersisa adalah tahap ambang pada pin 7.

Langkah 12: Menyediakan Comparator Analog

Dalam lakaran, saya menulis satu lagi fungsi permulaan yang menyusun semua parameter fungsi Pembanding Analog. Masalah yang sama tentang buffer digital ADC terpakai pada Comparator Analog, seperti yang kita lihat di bahagian bawah rutin.

void initAnalogComparator (void)
{
// ------------------------------------------------ ---------------------
// Pengaturan ACSR
// ------------------------------------------------ ---------------------
// Apabila bit ini ditulis satu logik, kuasa untuk Analog
/ // Comparator dimatikan. Bit ini boleh ditetapkan pada bila-bila masa untuk bertukar
/ / dari Pembanding Analog. Ini akan mengurangkan penggunaan tenaga dalam
// Mod aktif dan Idle. Apabila menukar bit ACD, Analog
// Interrupt Comparator mesti dilumpuhkan dengan membersihkan bit ACIE
// ACSR. Jika tidak, gangguan boleh berlaku apabila bit berubah.
cbi (ACSR, ACD);
// Apabila bit ini ditetapkan, voltan rujukan bandgap tetap menggantikan
// input positif kepada Comparator Analog. Apabila bit ini dibersihkan,
// AIN0 digunakan untuk masukan positif dari Comparator Analog. Bila
// referensi bandgap digunakan sebagai input kepada Comparator Analog, ia
// akan mengambil masa tertentu untuk voltan untuk menstabilkan. Jika tidak
// stabil, penukaran pertama mungkin memberikan nilai yang salah.
cbi (ACSR, ACBG);
// Apabila bit ACIE bertulis logik satu dan I-bit dalam Status
// Daftar telah ditetapkan, interrupt Comparator Analog diaktifkan.
// Apabila logik bertulis sifar, gangguan tersebut dinyahdayakan.
cbi (ACSR, ACIE);
// Apabila logik bertulis satu, bit ini membolehkan fungsi tangkapan input
// dalam Timer / Counter1 yang akan dicetuskan oleh Comparator Analog. The
// output komparator dalam kes ini terus disambungkan ke input
// menangkap logik akhir, membuat komparator menggunakan bunyi
/ // pembelak dan kelebihan pilih ciri Input Timer / Counter1
// Tekan tangkapan. Apabila logik bertulis sifar, tiada sambungan antara
// Comparator Analog dan fungsi penangkapan input wujud. Untuk
// membuat komparator mencetuskan Tangkapan Input Timer / Counter1
/ // mengganggu, bit ICIE1 dalam Daftar Topeng Interrupt Timer
// (TIMSK1) mesti ditetapkan.
cbi (ACSR, ACIC);
// Bit ini menentukan peristiwa pembanding yang mencetuskan Analog
/ // Comparator interrupt.
// Mod ACIS1 ACIS0
// 0 0 Togol
// 0 1 Reserved
// 0 0 Jatuh jatuh
/ 1 1 Rising edge
sbi (ACSR, ACIS1);
sbi (ACSR, ACIS0);

// ------------------------------------------------ ---------------------
// Pengaturan DIDR1
// ------------------------------------------------ ---------------------
// Apabila bit ini ditulis satu logik, penimbal input digital pada
/ // PIN AIN1 / 0 dinyahdayakan. Butang PIN PIN yang sepadan akan
// sentiasa dibaca sebagai sifar apabila bit ini ditetapkan. Apabila isyarat analog adalah
// digunakan pada pin AIN1 / 0 dan input digital dari pin ini tidak
/ / diperlukan, bit ini harus ditulis satu logik untuk mengurangkan kuasa
// penggunaan dalam penimbal input digital.
sbi (DIDR1, AIN1D);
sbi (DIDR1, AIN0D);
}

Langkah 13: Ambang

Mengingat semula apa yang kita katakan tentang pencetus, kita boleh melaksanakan kedua-dua penyelesaian untuk ambang ini:
  • menggunakan perapi yang kita dapat menetapkan tahap voltan secara manual;
  • menggunakan PWM Arduino kita boleh menetapkan tahap oleh perisian.
Pada imej kita dapat melihat pelaksanaan perkakasan ambang di kedua-dua laluan.

Untuk pemilihan manual, potentiometer pelbagai putaran yang dipasang antara +5 V dan GND cukup.

Walaupun untuk pemilihan perisian kita memerlukan penapis rendah-pass yang menapis isyarat PWM yang datang dari Arduino. Isyarat PWM (lebih lanjut mengenai ini untuk diikuti) ialah isyarat persegi dengan kekerapan yang berterusan tetapi satu pulsa berubah-ubah. Kebolehubahan ini membawa nilai min yang berubah-ubah isyarat yang boleh diekstrak dengan penapis lulus rendah. Frekuensi cutoff yang baik untuk penapis adalah kira-kira seratus frekuensi PWM dan saya memilih kira-kira 560 Hz.

Selepas kedua-dua sumber ambang saya memasukkan beberapa pin yang membolehkan untuk memilih, dengan jumper, yang sumber saya inginkan. Selepas pemilihan, saya juga menambah pengikut pemancar untuk memecahkan sumber dari pin Arduino.

Langkah 14: Bagaimana Modulasi Lebar Pulse berfungsi

Seperti yang dinyatakan sebelum ini, Isyarat Lebar Pulse (PWM) isyarat persegi dengan frekuensi tetap tetapi lebar berubah. Pada imej kita melihat contoh. Pada setiap baris terdapat satu isyarat sedemikian dengan kitaran tugas yang berbeza ( id est bahagian tempoh di mana isyarat Tinggi). Mengambil isyarat min selama satu tempoh, kami mendapat garis merah yang sesuai dengan kitaran tugas berkenaan dengan maksimum isyarat.

Secara elektronik "mengambil isyarat isyarat" boleh diterjemahkan ke "lulus ke penapis lulus rendah", seperti yang dilihat pada langkah sebelumnya.

Bagaimanakah Arduino menghasilkan isyarat PWM? Terdapat tutorial yang bagus tentang PWM di sini:
//arduino.cc/en/Tutorial/SecretsOfArduinoPWM
Kami akan melihat hanya mata yang diperlukan untuk projek ini.

Di ATMega328P terdapat tiga pemasa yang boleh digunakan untuk menghasilkan isyarat PWM, masing-masing mempunyai ciri-ciri yang berbeza yang boleh anda gunakan. Bagi setiap pemasa yang sepadan dengan dua daftar disebut Output Compare Registers A / B (OCRnx) yang digunakan untuk menetapkan kitaran tugas isyarat.

Bagi ADC terdapat prescaler (lihat imej), yang melambatkan jam utama untuk mempunyai kawalan yang tepat terhadap kekerapan PWM. Jam melambatkan diberi kepada kaunter yang menambah Penunjuk Waktu / Kaunter (TCNTn). Daftar ini secara berterusan dibandingkan dengan OCRnx, apabila ia sama dengan isyarat dihantar ke Generator Waveform yang menghasilkan nadi pada pin output. Oleh itu silap mata menetapkan tetapan OCRnx kepada beberapa nilai untuk menukar nilai min isyarat.

Jika kita menginginkan isyarat 5 V (maksima) kita mesti menetapkan kitaran tugas 100% atau 255 dalam OCRnx (maksima untuk nombor 8-bit), manakala jika kita mahu isyarat 0.5 V kita mesti menetapkan kitaran tugas 10% atau 25 di OCRnx.

Oleh kerana jam terpaksa mengisi pendaftaran TCNTn sebelum bermula dari permulaan untuk nadi baru, kekerapan output PWM ialah:

f = (Jam utama) / prescaler / (maksimum TCNTn)

exempli gratia untuk Pemasa 0 dan 2 (8-bit) tanpa prescaler ia akan: 16 MHz / 256 = 62.5 KHz sementara untuk Pemasa 1 (16-bit) ia akan menjadi 16 MHz / 65536 = 244 Hz.

Saya memutuskan untuk menggunakan Nombor Pemasa 2 kerana
  • Pemasa 0 digunakan secara dalaman oleh Arduino IDE untuk fungsi seperti millis ();
  • Pemasa 1 mempunyai frekuensi output terlalu perlahan kerana ia adalah pemasa 16-bit.

Di ATMega328P terdapat pelbagai jenis mod pengendalian pemasa, tetapi apa yang saya mahukan ialah PWM Cepat yang tidak mempunyai prescaling untuk mendapatkan kekerapan output maksimum.

Langkah 15: Menetapkan PWM

Dalam lakaran, saya menulis satu lagi fungsi permulaan yang menetapkan semua parameter pemasa yang berfungsi dan memulakan beberapa pin. void initPins (batal)
{
// ------------------------------------------------ ---------------------
// Pengaturan TCCR2A
// ------------------------------------------------ ---------------------
// Bit ini mengawal Output Bandingkan pin (OC2A) tingkah laku. Jika satu atau
// keduanya COM2A1: 0 bit ditetapkan, keluaran OC2A menimpa
// Fungsi pelabuhan normal pin I / O ia disambungkan ke.
// Namun, perhatikan bahawa Daftar Arah Arah Data (DDR) sedikit
// sama dengan pin OC2A mesti ditetapkan untuk membolehkan
/ / driver output.
// Apabila OC2A disambungkan ke pin, fungsi COM2A1: 0 bit
/ / bergantung kepada WGM22: tetapan 0 bit.
//
// Mod PWM Cepat
// COM2A1 COM2A0
/ 0 0 Operasi pelabuhan biasa, OC2A terputus.
// 0 1 WGM22 = 0: Operasi Port Normal, OC0A Terputus.
// WGM22 = 1: Togol OC2A pada Match Match.
// 0 0 Kosongkan OC2A pada Match Match, tetapkan OC2A di BOTTOM
// 1 1 Kosongkan OC2A pada Match Match, jelas OC2A di BOTTOM
cbi (TCCR2A, COM2A1);
cbi (TCCR2A, COM2A0);
sbi (TCCR2A, COM2B1);
cbi (TCCR2A, COM2B0);

// Digabungkan dengan bit WGM22 yang terdapat di Register TCCR2B, bit ini
// mengawal urutan penghitung kaunter, sumber maksimum
Nilai counter // // (TOP), dan jenis jenis gelombang yang akan digunakan
// Mod operasi yang disokong oleh Unit Pemasa / Kaunter adalah:
// - Mod biasa (kaunter),
/ / - Mod Pembetulan Cet Padih (CTC)
/ / - dua jenis mod Pulse Width Modulation (PWM).
//
// Mod WGM22 WGM21 WGM20 Operasi TOP
// 0 0 0 0 Normal 0xFF
// 1 0 0 1 PWM 0xFF
// 2 0 1 0 CTC OCRA
// 3 0 1 1 Fast PWM 0xFF
// 4 1 0 0 Reserved -
// 5 1 0 1 PWM OCRA
// 6 1 1 0 Reserved -
// 7 1 1 1 Fast PWM OCRA
cbi (TCCR2B, WGM22);
sbi (TCCR2A, WGM21);
sbi (TCCR2A, WGM20);

// ------------------------------------------------ ---------------------
// Pengaturan TCCR2B
// ------------------------------------------------ ---------------------
// Bit FOC2A hanya aktif apabila bit WGM menentukan bukan PWM
// mod.
// Namun, untuk memastikan keserasian dengan peranti masa depan, sedikit ini
// mesti ditetapkan kepada sifar apabila TCCR2B ditulis semasa beroperasi di PWM
// mod. Apabila menulis satu logik kepada bit FOC2A, segera
/ / Match Match dipaksa pada unit Generasi Gelombang. The OC2A
// output diubah mengikut tetapan COM2A1: 0 bitnya. Perhatikan bahawa
// bit FOC2A dilaksanakan sebagai strob. Oleh itu, ia adalah nilai
// hadir dalam COM2A1: 0 bit yang menentukan kesannya
// dipaksa membandingkan.
// Strobe FOC2A tidak akan menghasilkan sebarang gangguan, dan tidak akan jelas
// pemasa dalam mod CTC menggunakan OCR2A sebagai TOP.
// Bit FOC2A sentiasa dibaca sebagai sifar.
cbi (TCCR2B, FOC2A);
cbi (TCCR2B, FOC2B);

// Tiga Jam Pilih bit pilih sumber jam untuk digunakan oleh
// Pemasa / Kaunter.
// CS22 CS21 CS20 Prescaler
// 0 0 0 Tiada sumber jam (Timer / Kaunter berhenti).
// 0 0 1 Tidak ada rahsia
// 0 1 0 8
// 0 1 1 32
// 1 0 0 64
// 1 0 1 128
// 1 1 0 256
// 1 1 1 1024
cbi (TCCR2B, CS22);
cbi (TCCR2B, CS21);
sbi (TCCR2B, CS20);

pinMode (errorPin, OUTPUT);
pinMode (thresholdPin, OUTPUT);

analogWrite (thresholdPin, 127);
}

Langkah 16: Pembolehubah yang meruap

Saya tidak ingat di mana, tetapi saya membaca bahawa pemboleh ubah yang diubahsuai di dalam ISR harus diisytiharkan sebagai tidak menentu .

Pembolehubah tidak menentu adalah pemboleh ubah yang boleh berubah pada masa, walaupun program yang sedang berjalan tidak mengubahnya. Sama seperti daftar Arduino yang boleh mengubah nilai untuk beberapa campur tangan luar.

Mengapa pengkompil ingin tahu mengenai pemboleh ubah tersebut? Itu kerana pengkompil selalu cuba mengoptimumkan kod yang kita tulis, untuk menjadikannya lebih cepat, dan mengubahnya sedikit, cuba untuk tidak menukar makna itu. Sekiranya perubahan berubah dengan sendirinya, ia mungkin kelihatan sebagai pengkompil bahawa ia tidak diubah suai semasa pelaksanaan, katakan, gelung dan ia boleh mengabaikannya; sementara itu boleh menjadi penting bahawa pemboleh ubah mengubah nilainya. Oleh itu mengisytiharkan pembolehubah yang tidak menentu ia menghalang pengkompil untuk mengubah suai kod berkenaan.

Untuk maklumat lanjut, saya cadangkan membaca laman Wikipedia: //en.wikipedia.org/wiki/Volatile_variable

Langkah 17: Menulis Kernel Sketch

Akhirnya kita telah mendapat kernel program!

Seperti yang kita lihat sebelum ini, saya mahukan pengambilalihan yang berterusan dan saya menulis Rutin Perkhidmatan ADC Interrupt untuk menyimpan dalam penimbal pekeliling data secara berterusan. Ia berhenti apabila ia mencapai indeks yang sama dengan stopIndex. Penampan ini dilaksanakan sebagai pekeliling yang menggunakan pengendali modulo.

// ------------------------------------------------ -----------------------------
// Penukaran ADC Interrupt Lengkap
// ------------------------------------------------ -----------------------------
ISR (ADC_vect)
{
// Apabila ADCL dibaca, Daftar Data ADC tidak dikemas kini sehingga ADCH
// dibaca. Akibatnya, jika keputusannya diselaraskan dan tidak lagi
/ / daripada ketepatan 8-bit diperlukan, sudah cukup untuk membaca ADCH.
// Jika tidak, ADCL mesti dibaca terlebih dahulu, kemudian ADCH.
ADCBuffer [ADCCounter] = ADCH;

ADCCounter = (ADCCounter + 1)% ADCBUFFERSIZE;

jika (tunggu)
{
jika (stopIndex == ADCCounter)
{
/ // Situasi beku
// Matikan ADC dan hentikan Mod Penukaran Running Percuma
cbi (ADCSRA, ADEN);

membekukan = benar;
}
}
}

Rangkaian Perkhidmatan Pengganggu Analog Rutin (yang dipanggil apabila isyarat melepasi ambang) melumpuhkan dirinya dan memberitahu ADC ISR untuk memulakan fasa menunggu dan menetapkan stopIndex.

// ------------------------------------------------ -----------------------------
/ // Analog Comparator interrupt
// ------------------------------------------------ -----------------------------
ISR (ANALOG_COMP_vect)
{
// Matikan mengganggu Analog Comparator
cbi (ACSR, ACIE);

// Hidupkan errorPin
/ / digitalWrite (errorPin, HIGH);
sbi (PORTB, PORTB5);

tunggu = benar;
stopIndex = (ADCCounter + waitDuration) ADCBUFFERSIZE;
}


Ini benar-benar mudah selepas semua itu!

Langkah 18: Membentuk Isyarat Masuk

Marilah kita pergi ke perkakasan sekarang. Litar mungkin kelihatan rumit tetapi ia benar-benar mudah.
  • Terdapat 1 MΩ perintang pada input, untuk memberikan rujukan massa kepada isyarat dan mempunyai input impedans yang tinggi. Impedance yang tinggi "menyerupai" litar terbuka jika anda menyambungkannya ke impedans yang lebih rendah, jadi kehadiran Girino tidak terlalu kencang dengan litar yang ingin anda ukur.
  • Selepas perintang terdapat pengikut pemancar untuk menyahsulit isyarat dan melindungi elektronik berikut.
  • Terdapat satu offset mudah yang menghasilkan tahap 2.5 V dengan pembahagi voltan. Ia dipasang pada kapasitor untuk menstabilkannya.
  • Terdapat penguat jumlah yang tidak terbalik yang merangkumkan isyarat masuk dan mengimbangi. Saya menggunakan teknik ini kerana saya mahu dapat melihat juga isyarat negatif, kerana Arduino ADC dapat melihat isyarat hanya antara 0 V hingga 5 V.
  • Selepas sum-amp terdapat pengikut pemancar yang lain.
  • Pelompat membolehkan kami membuat keputusan jika kami mahu memberi isyarat dengan mengimbangi atau tidak.
Penguat Operasi yang dimaksudkan untuk digunakan ialah LM324 yang mampu bekerja antara 0 V hingga 5 V tetapi juga antara, katakan, -12 V hingga 12 V. Ini memberikan kita lebih banyak kemungkinan dengan bekalan kuasa. Saya juga mencuba TL084 yang lebih cepat daripada LM324 tetapi memerlukan bekalan kuasa dua. Kedua-duanya mempunyai pinout yang sama supaya dapat diubah tanpa sebarang modifikasi litar.

Langkah 19: Bypass Capacitors

Bypass Capacitors adalah kapasitor yang digunakan untuk menapis bekalan kuasa Litar Bersepadu (IC) dan mereka harus diletakkan sedekat mungkin ke pin pemakan. Mereka digunakan biasanya dalam pasangan, satu seramik dan satu elektrolitik kerana mereka boleh menyaring frekuensi yang berbeza.

Langkah 20: Sumber Kuasa

Saya menggunakan bekalan kuasa dua untuk TL084 yang boleh ditukar kepada bekalan kuasa tunggal untuk LM324.

Pada imej kita dapat melihat bahawa saya menggunakan beberapa regulator voltan 7812, untuk +12 V, dan 7912, untuk -12 V. Kapasitor, seperti biasa, digunakan untuk menstabilkan tahap dan nilai mereka adalah yang dicadangkan dalam lembaran data.

Jelas untuk mempunyai ± 12 V kita perlu mempunyai sekurang-kurangnya kira-kira 30 V pada input kerana pengawal selia voltan memerlukan input yang lebih tinggi untuk memberikan keluaran yang stabil. Oleh kerana saya tidak mempunyai bekalan kuasa seperti ini, saya menggunakan trik menggunakan dua bekalan kuasa 15 V secara siri. Salah satu daripada kedua-duanya disambungkan kepada penyambung kuasa Arduino (jadi ia memberi makan kepada Arduino dan litar saya) dan yang lain langsung ke litar.

Ia bukan kesilapan untuk menyambung +15 V bekalan kuasa kedua ke GND yang pertama! Inilah cara kami memperolehi -15 V dengan bekalan kuasa terpencil .

Jika saya tidak mahu membawa Arduino dan dua bekalan kuasa saya masih boleh menggunakan +5 V yang disediakan oleh Arduino yang menukar jumper tersebut (dan menggunakan LM324).

Langkah 21: Menyediakan Penyambung Perisai

Saya selalu terganggu oleh penyambung yang saya dapati untuk membuat perisai Arduino, kerana mereka selalu mempunyai pin yang terlalu pendek dan papan yang saya gunakan dapat disolder hanya di satu sisi. Jadi saya membuat helah sedikit untuk membuat pin lagi supaya mereka boleh disolder dan dimasukkan ke dalam Arduino.

Memasukkan jalur pin ke dalam papan, seperti pada gambar, kita boleh menolak pin, untuk memilikinya hanya pada satu sisi plastik hitam. Kemudian kita boleh menyolder mereka di sisi yang sama di mana mereka akan dimasukkan ke dalam Arduino.

Langkah 22: Pematerian dan Ujian

Saya tidak dapat menunjukkan kepada anda semua prosedur pematerian litar kerana ia menjalani banyak kerja percubaan dan kesilapan. Pada akhirnya ia mendapat sedikit kemas tetapi tidak terlalu buruk, walaupun saya tidak akan menunjukkan bahagian bawah kerana itu benar-benar kemas.

Pada peringkat ini tidak banyak yang boleh dikatakan kerana saya telah menjelaskan secara terperinci semua bahagian litar tersebut. Saya mengujinya dengan oscilloscope, bahawa seorang kawan meminjam saya, untuk melihat isyarat di setiap titik litar. Nampaknya semuanya berjalan dengan baik dan saya cukup berpuas hati.

Penyambung untuk isyarat masuk mungkin kelihatan agak aneh bagi seseorang yang tidak berasal dari Fizik Tenaga Tinggi, ia adalah penyambung LEMO. Ia adalah penyambung standard bagi isyarat nuklear, sekurang-kurangnya di Eropah seperti di Amerika Syarikat yang saya lihat kebanyakan penyambung BNC.

Langkah 23: Isyarat Ujian

Untuk menguji litar dan Data AcQuisition (DAQ) Saya menggunakan arduino kedua dengan lakaran mudah yang menghasilkan pulsa persegi dengan lenghts yang berbeza. Saya juga menulis skrip python yang bercakap kepada Girino dan menceritakannya untuk memperoleh beberapa siri data dan menyelamatkan salah satu daripada mereka ke fail.
Mereka berdua melekat pada langkah ini.

Lampiran

  • Muat Turun TaraturaTempi.ino
  • readgirino.py Muat turun

Langkah 24: Penentukuran Masa

Menggunakan isyarat ujian saya menentukur skala mendatar plot. Dengan mengukur lebar denyut (yang diketahui kerana dijana) dan merancang lebar denyutan terukur terhadap nilai-nilai yang diketahui, kami mendapat plot linear yang diharapkan. Melakukan ini untuk setiap penetapan prescaler kami mempunyai penentukuran masa untuk semua kadar perolehan.

Pada imej kita dapat melihat semua data yang saya telah dianalisis. Plot "Luas cerun" adalah yang paling menarik kerana ia memberitahu kami kadar perolehan sebenar sistem saya pada setiap tetapan prescaler. Lereng diukur sebagai nombor [ch / ms] tetapi ini bersamaan dengan [kHz], jadi nilai lereng sebenarnya adalah kHz atau juga kS / s (Sampel kilo sesaat). Ini bermakna bahawa dengan prescaler ditetapkan kepada 8 kita memperoleh kadar pengambilalihan:

(154 ± 2) kS / s

Tidak buruk, eh?

Walaupun dari plot "Dilancarkan y-campur tangan" kita mendapat gambaran tentang garis lurus sistem. Semua penyambungan y harus sifar kerana pada isyarat dengan panjang sifar sepadan dengan nadi dengan panjang sifar. Seperti yang dapat kita lihat pada graf mereka semua serasi dengan sifar, tetapi bukan dataset 18-prescaler. Dataset ini, walaupun, adalah yang paling teruk kerana hanya memiliki dua data dan penentukurannya tidak boleh dipercayai.

Berikutan terdapat jadual dengan kadar pengambilalihan untuk setiap penetapan prescaler.

PrescalerKadar perolehan [kS / s]
1289.74 ± 0.04
6419.39 ± 0.06
3237.3 ± 0.6
1675.5 ± 0.3
8153 ± 2
Kesalahan yang diberikan berasal dari enjin patut Gnuplot dan saya tidak pasti tentangnya.

Saya juga mencuba sesuatu yang tidak berat dari kadar kerana anda dapat melihat bahawa mereka kira-kira dua kali ganda apabila memisahkan bahagian, ini kelihatan seperti undang-undang perkadaran songsang. Jadi saya memasang kadar vs tetapan prescaler dengan undang-undang mudah

y = a / x

Saya mendapat nilai untuk satu

a = 1223

dengan χ² = 3.14 dan 4 darjah kebebasan, ini bermakna bahawa undang-undang diterima dengan tahap keyakinan 95%!

Langkah 25: Selesai! (Hampir)

Pada akhir pengalaman panjang ini, saya merasa sangat puas kerana
  • Saya belajar banyak tentang microcontrollers secara amnya;
  • Saya belajar banyak lagi mengenai ATMega328P Arduino;
  • Saya mempunyai pengalaman pengambilan Data Perolehan, bukan dengan menggunakan sesuatu yang telah dilakukan tetapi dengan membuat sesuatu;
  • Saya sedar osiloskop amatir yang tidak begitu buruk.
Saya harap panduan ini berguna kepada sesiapa sahaja yang membacanya. Saya ingin menulisnya dengan terperinci kerana saya belajar semua dengan cara yang sukar (melayari internet, membaca datasheet dan dengan banyak percubaan dan kesilapan) dan saya ingin melepaskan sesiapa dari pengalaman itu.

Langkah 26: Akan Terus ...

Projek itu jika tidak selesai, walaupun. Apa yang hilang ialah:
  1. Ujian dengan isyarat analog yang berbeza (saya hilang penjana isyarat analog);
  2. Antara muka pengguna grafik untuk bahagian komputer.
Walaupun untuk titik 1. Saya tidak pasti apabila ia akan selesai, kerana saya tidak merancang untuk membeli / membina satu dalam masa terdekat.

Untuk titik 2. keadaan menjadi lebih baik. Adakah sesiapa bersedia membantuku? Saya dapati Python Oscilloscope yang bagus di sini:
//www.phy.uct.ac.za/courses/python/examples/moreexamples.html#oscilloscope-and-spectrum-analyser
Saya ingin mengubahnya agar sesuai dengannya untuk Girino, tetapi saya menerima cadangan.

Artikel Berkaitan