Kapasitor Elektrolitik – 4 unit (lihat skematik untuk nilai dan tegangan)
Kapasitor 470nF – 1 unit
Perfboard – 1 unit
Resistor 1/4W – 24 unit (lihat skematik untuk nilai)
Dupont Jumpers – 1 set
Kabel – 1 set
Alat dan Mesin yang Diperlukan
Soldering iron (generik)
Solder Wire – disarankan 0,5mm
Wire Clipper
Tentang Proyek Ini
Apa Gunanya?
Tampilan VFD tidak lagi tren karena beberapa alasan yang jelas, terbuat dari kaca ("uh keren!"), memiliki filamen pijar ("benar-benar?"), pada dasarnya tabung vakum ("menarik!"), menghasilkan cahaya yang sangat cerah, kadang berwarna, membutuhkan plastik hitam di atas ("uh, keren lagi!").
Biasanya Anda memerlukan chip khusus untuk mengemudikannya, sebagian besar modul/perangkat dilengkapi chip ini yang dapat Anda kontrol secara independen melalui I2C atau SPI (lebih baik dari segi kemudahan), jika Anda membeli atau memiliki salah satu tampilan ini dan kehilangan chip tersebut tidak begitu mudah untuk "hubungkan dan gunakan," idealnya adalah membeli chip tersebut (yang biasanya dalam format SMD). Rangkaian ini memberikan antarmuka yang cukup baik untuk Arduino dan dapat mengemudikan hampir semua VFD, termasuk tabung vintage yang besar, namun tampilan matriks dengan banyak segmen bukan ide yang bagus, Anda dapat memperluas rangkaian tetapi ribuan... mhhh, mungkin tidak.
Kelebihan dan Kekurangan
Kelebihan
biaya hampir nol (semoga)
bagian mudah ditemukan
kemampuan tegangan tinggi (hingga ratusan Volt pada anoda)
tegangan grid dan anoda independen
hanya 3 baris data digital yang diperlukan
dapat diperluas (memerlukan lebih banyak pekerjaan CPU)
kode siap pakai untuk setiap Arduino 8-bit
Kekurangan
memerlukan berbagai tegangan dan supply (biasa untuk VFD)
tidak ada fungsi reduksi kecerahan (kecuali dari pengaturan tegangan)
menggunakan dua sumber daya Arduino, SPI dan timer1
Anda tidak dapat mengantung mikrokontroler, sebaliknya pemindaian akan membeku pada satu grid
bukan sekadar resistor dan LED, memerlukan sejumlah pekerjaan
Prinsip Kerja
Tampilan VFD biasanya bekerja secara multiplex, seperti matriks 2D dengan sumbu X dan Y, Anda perlu memanaskan filamen (katoda, Anda melihat kawat tipis di depannya), menghubungkan ground pada filamen tersebut juga, tegangan positif ke sebuah grid (grid kontrol, satu titik pada sumbu X) dan lagi tegangan positif pada pin segmen (anoda, satu titik pada sumbu Y), pada titik ini sebuah segmen (hanya satu) menyala. Untuk menyalakan segmen apa pun dan kombinasi apa pun, dan memiliki "beberapa" kabel di sekitarnya, pemindaian memilih satu grid setiap kali dan pada saat yang sama mengonfigurasi anoda untuk menyalakan segmen yang sesuai di bawah grid itu, sejenak kemudian, memilih grid lain dan mengonfigurasi anoda kali ini untuk memiliki segmen yang sesuai dengan benar menyala di bawah grid kedua. Mempercepat pemindaian berulang ini menghasilkan gerakan yang sangat cepat sehingga di mata kita tidak memilih satu grid setiap kali, tetapi terlihat diemudikan sekaligus, ini yang disebut POV (Persistence Of Vision).
Rangkaian ini menggunakan dua jenis integrated circuit dari keluarga yang sama, dua CD4094 dan dua CD4017, CD4094 mengemudikan anoda dan CD4017 mengemudikan grid, CD4094 dapat menyimpan konfigurasi high\low pada outputnya dan cocok untuk sisi anoda, CD4017 adalah chip klasik dengan 10 output sequencing, sempurna untuk grid. Setelah CD4094 dimuat dengan konfigurasi anoda saat itu, sinyal "ok" (strobe) menerapkan pengaturan ini dan pada saat yang sama menggeser CD4017 satu langkah, memungkinkan sequencing otomatis.
Bagian daya pada dasarnya hanya beberapa transistor BC557 (atau setara) yang memungkinkan geseran tegangan yang lebih luas pada anoda, karena tampilan ini memerlukan tegangan yang lebih tinggi dari 5V Arduino. Grid diemudikan oleh CD4017 secara langsung, optocoupler PC817 memungkinkan tegangan lebih dari 5V di sekitar CD4017 dan juga level tegangan yang berbeda dari CD4094, ini menyederhanakan seluruhnya sangat banyak.
Arduino harus menyediakan semua orkestrasi, artinya harus menyimpan semua konfigurasi segmen dan memuat rangkaian dengan setup anoda pada setiap pergantian grid, ini berarti benar-benar memerlukan kode yang cerdas untuk melakukannya di luar tindakan pengguna. Kode yang saya buat mengatur interrupt berbasis timer yang memuat ulang chip CD4094 pada setiap langkah, sebenarnya sekitar 1000 kali per detik, jadi untuk 10 grid memberikan tingkat refresh 100Hz, yang baik. Ada array data yang menyimpan konfigurasi segmen dan dapat diubah dalam kode, tanpa prosedur atau tindakan khusus, rutinitas interrupt akan mengunggah data dengan sendirinya.
Sumber Daya
Tegangan grid pada chip CD4017 dapat dari 5Vdc hingga 18Vdc dan setidaknya 50mA arus, tidak perlu diatur. Biasa (sejauh yang saya lihat) 12V akan cukup untuk setiap situasi, meningkatkannya tidak terlihat meningkatkan kecerahan banyak (jika ini tabung vakum, grid tidak memerlukan tegangan besar).
Tegangan anoda dapat dari 0V secara harfiah hingga seberapa tinggi tahanan transistor Anda (50Vdc untuk BC557), biasanya jika tampilan sempurna 20-30Vdc akan bekerja sempurna, tidak diatur bagus. Untuk setup normal 50mA supply lebih dari cukup.
Daya digital dapat 5Vdc atau juga 3,3Vdc untuk jenis Arduino atau MCU tertentu (belum dicoba), ini memerlukan sekitar 100mA daya (semoga lebih sedikit), jika CD4094 menjadi lambat Anda dapat mengurangi kecepatan clock SPI dalam kode dan\atau menggunakan output 'Q'S' dari CD4094 pertama untuk komunikasi yang lebih konsisten.
Supply filamen harus menyediakan setidaknya 5V 200-300mA arus, jika Anda sudah memiliki sumber DC Anda dapat menghindari jembaterektifikasi dan kapasitor 1000uF, tetapi Anda TIDAK DAPAT menggunakan supply digital yang sama untuk\dari Arduino. Filamen aktual dalam kasus tampilan perangkat yang tidak terlalu besar berjalan pada sekitar 3V dan dapat menarik 150mA.
Tips dan Catatan
sebelum menghubungkan kabel, jika Anda tidak tahu pin mana yang berfungsi apa, lebih baik mencoba tampilan terlebih dahulu, biasanya pasangan baterai AA secara beruntun akan cukup untuk filamen (biasanya kontak sisi), sementara pasangan baterai 9V secara beruntun akan memberikan polarisasi positif untuk grid dan anoda; grid dan anoda sering digabungkan, ide yang baik adalah menemukan "anoda nol" sebenarnya karena kemungkinan besar segmen pertama pada bagian numerik atau alfanumerik, sering kali sama dan dengan urutan yang sama untuk semua grid, memasang kabel dalam urutan terbalik secara tidak sengaja membuat perangkat lunak lebih rumit di akhirnya, grid sebaliknya, tampaknya, mengikuti urutan pin
hati-hati pada supply filamen, tingkatkan arus sedikit demi sedikit, tetap dalam kegelapan dan saat Anda mulai melihat filamen menjadi sedikit incandescent kurangi sedikit dan Anda selesai, potentiometer daya adalah sempurna, Anda kadang menemukannya di TV lama tetapi sulit saat ini
tingkatkan tegangan pada grid dan anoda dengan cara yang wajar, fosfor dapat terbakar secara tidak dapat diperbaiki, rangkaian juga bekerja pemindaian, jadi jika sistem mengganggu Anda akan memberikan terlalu banyak daya pada satu bagian grid secara berkelanjutan
bermain dengan kompromi pada tegangan grid\anoda, ingat bahwa grid dapat mengonsumsi beberapa arus, tidak layak mendorong pada itu, lebih baik perhatikan anoda
menggunakan satu transformer untuk seluruh proyek\setup Anda adalah ideal, juga beberapa solusi campuran dapat digunakan, tetapi PSU switching dan terutama yang ber-ground dapat memainkan Anda kejahatan, itulah mengapa untuk bereksperimen selalu ide yang baik untuk menggunakan supply transformer klasik
Anda dapat memperluas driver ini menambahkan beberapa CD4094 dan\atau CD4017, tentu jika Anda perlu 8 anoda atau kurang Anda dapat melepaskan CD4094 kedua, skenario yang sama untuk CD4017, tetapi jika Anda ingin driver siap pakai bangunlah sebanyak mungkin lengkap
tidak ada resistor pada basis transistor anoda seperti yang Anda lihat, ini memberikan drive supercepat dan menyederhanakan daftar bagian tetapi membuat CD4094 mengonsumsi beberapa daya, mereka tidak akan panas hampir sama sekali tetapi beberapa spesimen chip mungkin memiliki output yang terlalu kuat, periksa konsumsi arus jika perlu, chip tidak akan meledak, karena daya yang disipasi adalah DI DALAM batas maksimum yang diizinkan, arus dapat dalam kisaran 4mA per pin pada supply 5V
tampilan lama yang lelah dapat diperbarui dengan beberapa kejutan arus pada filamen, jika ini seluruh tampilan yang redup dan bukan hanya segmen yang terbakar, mereka katakan Anda membuat kabel terlihat incandescent (kuning) lima kali berturut-turut selama beberapa detik setiap kali, belum pernah coba tetapi mungkin memerlukan dua kali tegangan ter-rated filamen, ini membersihkannya tetapi tampaknya lebih berguna untuk yang sangat lama\antik... dan berisiko, itu bukan lampu pijar, Anda bisa memutuskan kawat
Kode
Arduino code with working routineArduino
/* Versatile VFD Display Hrdware Interface Arduino Program Copyright (C) 2019 Genny A. Carogna This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>. */ /* this code uses resources from the Arduino in a "behind the curtains" way, the timer1 and SPI modules are both used and busy * , so you may have big problems using SPI, SPI pins, and some functionalities based upon timer1... the circuit proposed * doesn't have an onboard memory, so the segment setup must be "scanned" continuosly, every grid, 100 times per second * , from the Arduino segments array, this translates also on the so-called "overhaed" CPU work, that, for you to know, it's * no more than regular use of a micro at the end, it may hit around 3% of CPU work in terms of occupied time, you can also try * to use the regular SPI tools of Arduino but it needs an indepth analisys of the outtake and procedure * * this code works with whatever 8 bit Arduino, also 3.3V should work ok, maybe reduce the SCK frequency, considering the CD4094 are * powered along it and may "undervolt" (yes, exactly the overclock principles to fry your beloved PC) */ #define ledLed 13 // it's the led pin that leds a led on to led you know that a led on means some led related stuff (scientist mumbojumbo of course) #define strobePin 4 // the Arduino pin to dedicate to the "strobe" line #define strobeHold 10 // microseconds // holding time to switch the optocoupler... not megahertz-fast but acceptable // data for my displays (a video cassette recorder, an audiophoolery CD reader and a compact stereo)... dont mind, delete, and just define "gridAmount" and "anodeAmount" #define JVC #define mitsubishiGrids 10 #define mitsubishiAnodes 9 #define marantzGrids 9 #define marantzAnodes 14 #define JVCGrids 11 #define JVCAnodes 19 #if defined mitsubishi #define gridAmount mitsubishiGrids #define anodeAmount mitsubishiAnodes #elif defined marantz #define gridAmount marantzGrids #define anodeAmount marantzAnodes #elif defined JVC #define gridAmount JVCGrids #define anodeAmount JVCAnodes #endif // this array, segments[x], stores the segment bits // segments[0] means grid zero, and the least significative bit is segment zero in that grid // you can access and modify this array as you like, from wherever, without doing anything else, the effect is immediately visible on // the display, and stays on as long you don't change the bits, for more than 8 segments per grid displays, you need a // 16 or 32 bit container per grid, this is managed automatically from the #define(s) above #if anodeAmount > 16 volatile uint32_t segments[gridAmount] = {0}; // more than 16 segments per grid (32 bit needed) #elif anodeAmount > 8 volatile uint16_t segments[gridAmount] = {0}; // more than 8 segments per grid (16 bit, twin transfer) #else volatile uint8_t segments[gridAmount] = {0}; // 8 or less segments per grid (8 bit) #endif void setup(){ // turns SPI pins and some functional ones as output in a fast\direct way *portModeRegister(digitalPinToPort(PIN_SPI_SS)) |= digitalPinToBitMask(PIN_SPI_SS); *portModeRegister(digitalPinToPort(PIN_SPI_MOSI)) |= digitalPinToBitMask(PIN_SPI_MOSI); *portModeRegister(digitalPinToPort(PIN_SPI_SCK)) |= digitalPinToBitMask(PIN_SPI_SCK); *portModeRegister(digitalPinToPort(strobePin)) |= digitalPinToBitMask(strobePin); *portOutputRegister(digitalPinToPort(strobePin)) &= ~digitalPinToBitMask(strobePin); // put it low *portModeRegister(digitalPinToPort(ledLed)) |= digitalPinToBitMask(ledLed); *portOutputRegister(digitalPinToPort(ledLed)) &= ~digitalPinToBitMask(ledLed); // put it low delay(800); // some delay to wait for the CD4017 reset to complete (you need to run the code AFTER powering up the 4017s, this makes it automatic in case you power all in once) cli(); // disables interrupts to let us tweak some stuff without cats and dogs escaping everywhere // timer1 configuration, it makes an interrupt happen "grids times 100" per second... this gives a 100Hz total refresh that is ok TCCR1A = 0; TCCR1B = 0; TCNT1 = 0; OCR1A = 160000 / gridAmount; TCCR1B |= (1 << WGM12); TCCR1B |= (1 << CS10); TIMSK1 |= (1 << OCIE1A); // SPI configuration, we cannot use the Arduino SPI tools bcs they rely on interrupts AND we // need the communication happen INSIDE an interrupt.. // change SPR0 for SPR1 and uncomment the last line to have half SPI clock speed SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // 1MHz stock SCK speed // SPSR = (1 << SPI2X); // uncomment this and mod above for half clock speed sei(); // interrupts are a go again // it's better to put your addictional setup() code from here } // you can do whatever in loop(), delays, pollings, but disabling interrupts or making the micro halt completely will // freeze the display on a grid, and if the voltage is at top power you may also burn some segments (!!) void loop() { show(); // kinda screensaver, you can delete } // interrupt service routine, this happens at every grid scan switch and times 100 per second ISR(TIMER1_COMPA_vect){ /* ATTENTION ATTENTION: i dunno why i need to start "turn" from 1 for proper functionality (i power the Arduino after and it may flip a grid), in case it keeps missing the correct grid at statup, vary this ATTENTION */ static uint8_t turn = 1; // indestructible variable to remind at what grid we were the next interrupt #if anodeAmount > 24 SPDR = ~uint8_t(segments[turn] >> 24); // we need negated bits on the CD4094 (cos of the transistors arrangement) while (!(SPSR & (1 << SPIF))) ; // lets wait it completes the transfer #endif #if anodeAmount > 16 SPDR = ~uint8_t(segments[turn] >> 16); // we need negated bits on the CD4094 (cos of the transistors arrangement) while (!(SPSR & (1 << SPIF))) ; // lets wait it completes the transfer #endif #if anodeAmount > 8 SPDR = ~uint8_t(segments[turn] >> 8); // we need negated bits on the CD4094 (cos of the transistors arrangement) while (!(SPSR & (1 << SPIF))) ; // lets wait it completes the transfer #endif SPDR = ~uint8_t(segments[turn]); // we need negated bits on the CD4094 (cos of the transistors arrangement) while (!(SPSR & (1 << SPIF))) ; // lets wait it completes the transfer... yyyYYYAAAAWWWWNNNnnn........... // strobing (finally!!) this also switches the grid on the CD4017s *portOutputRegister(digitalPinToPort(strobePin)) |= digitalPinToBitMask(strobePin); // fast pin drive ON delayMicroseconds(strobeHold); *portOutputRegister(digitalPinToPort(strobePin)) &= ~digitalPinToBitMask(strobePin); // fast pin drive OFF // grid turn reminder at rotation turn ++; if (turn == gridAmount) turn = 0; } //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ///////////FROM NOW THE SKETCH IS REFERRED TO MY DISPLAYS AND VISUAL GAMES, YOU CAN DELETE FROM HERE ON///////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // this is just a demo, delete as you like void show() { // numbers flip #ifdef mitsubishi for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(200); mitsubishiPrintNum(j, i); } for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(20); mitsubishiPrintNum(j, i); } #elif defined marantz for (uint8_t i = 0; i < 6; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(200); marantzPrintNum(j, i); } for (uint8_t i = 0; i < 6; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(20); marantzPrintNum(j, i); } #elif defined JVC /* for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(200); JVCPrintNum(j, i); } for (uint8_t i = 0; i < 9; i ++) for (uint8_t j = 0; j < 11; j ++) { delay(20); JVCPrintNum(j, i); }*/ #endif delay(500); // segments flip for (uint8_t i = 0; i < gridAmount; i ++) for (uint8_t j = 0; j < anodeAmount + 1; j ++) { delay(100); segments[i] = (uint32_t(1) << j); } delay(500); // all the display blinkng for (uint8_t i = 0; i < 5; i ++) { delay(200); for (uint8_t j = 0; j < gridAmount; j ++) { segments[j] = 0xFFFFFFFF; } delay(200); for (uint8_t j = 0; j < gridAmount; j ++) { segments[j] = 0; } } delay(500); } // easy peasy seven segment number visualization void mitsubishiPrintNum(uint8_t val, uint8_t pos) { if (pos > 2) pos ++; uint16_t mask = 0xFF80; uint8_t numbers[] = {B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00100111, B01111111, B01101111, B00000000}; switch (pos) { case 0: case 1: case 4: case 5: case 6: case 7: case 8: segments[pos] &= mask; segments[pos] |= numbers[val]; break; case 2: if (val == 1) segments[1] |= (1 << 8); else segments[1] &= ~(uint16_t(1) << 8); break; case 9: segments[9] &= 0xFFF0; if (val == 1) segments[9] |= 3; else if (val == 2) segments[9] |= B1101; } } // easy peasy seven segment number visualization void marantzPrintNum(uint8_t val, uint8_t pos) { if (pos > 5) return; pos ++; pos ++; uint16_t mask = 0xFF80; // bitmask to delete the digit uint8_t numbers[] = {B00111111, B00000110, B01011011, B01001111, B01100110, B01101101, B01111101, B00100111, B01111111, B01101111, B00000000}; segments[pos] &= mask; // delete whatever digit segments[pos] |= numbers[val]; // set digit } // easy peasy seven segment number visualization void JVCPrintNum(uint8_t val, uint8_t pos) { // to come (you really don't care) } //
Skematik
Saya tidak menggambar SEMUA transistor BC557 karena mereka hanya terhubung pada semua output CD4094, semuanya sama.
Ada pemilih jumper (berjalan pada garis merah) yang harus Anda konfigurasikan pada chip CD4017, ini me-reset dua CD4017 setelah pemindaian grid selesai, Anda harus menghubungkan (atau solder) jumper terbang pada pin output SETELAH grid terakhir, jadi jika tampilan Anda memiliki 10 grid jumper berada pada output ke-11.
Koneksi Arduino diuraikan dalam merah, Anda dapat menggunakan daya USB untuknya tetapi sangat disarankan untuk menggunakan transformer tua reguler untuk supply yang tersisa jika Anda sudah memiliki sumber daya grounded seperti PC Anda. Supply ini harus semua DC kecuali mungkin supply filamen, saya menambahkan beberapa dioda karena kemungkinan Anda membutuhkan transformer terpisah dengan secondary tegangan rendah. Daya filamen biasanya berkisar sekitar 3V 150mA, transformer AC 5V akan cukup. Hal "ballast" kemungkinan akan berupa potentiometer daya wirewound sekitar 100ohm, atau resistor tetap, atau juga beberapa dioda 1N4007 untuk mengurangi tegangan.
Transistor BC557 menarik anoda ke tegangan anoda dan resistor 100kohm akan membuat drive tegangan jatuh ketika segmen mati, sementara CD4094 tetap pada 5V biasanya.
CD4017 akan di daya dengan tegangan grid dan tidak memerlukan transistor tambahan. Ada rangkaian reset "ghetto" untuk CD4017 yang bertahan sekitar satu bagian sepuluh detik, Anda harus menunggu sampai menetes sebelum menjalankan kode. Skematik "asli" untuk cascading beberapa CD4017 memerlukan chip logika lainnya, saya menggunakan transistor NPN dan optocoupler itu sendiri untuk mereplikasi gate AND, ini cukup cepat untuk menutup jadi sempurna untuk tugas ini, saat membuka agak lebih lambat tetapi kita tidak peduli, terutama karena input clock pada CD4017 adalah schmitt triggered dan kecepatan yang diperlukan tidak "menakutkan" di sana.
Ada berbagai ground untuk chip dan hal-hal seperti yang Anda lihat, perhatikan baik-baik.
