Cewka Tesli #1 – notatki

Kalkulator

http://tesla.nu/programs/javatc/javatc.html

function loadDemo(form) {
Clear(form);
z = 1; if(z==0){form.units.selectedIndex=0; inches=true;}
if(z==1){form.units.selectedIndex=1; cm=true;}
z = 1; if(z==0){form.ambient.selectedIndex=0; fahrenheit=true;}
if(z==1){form.ambient.selectedIndex=1; centigrade=true;}
GetUnits(form);
z = 1; if(z==1){form.s_ws.checked=true;form.s_awg.checked=false;}
if(z==0){form.s_ws.checked=false;form.s_awg.checked=true;}
z = 0; if(z==1){form.s_Al.checked=true;form.s_Cu.checked=false;}
if(z==0){form.s_Al.checked=false;form.s_Cu.checked=true;}
z = 1; if(z==1){form.p_ws.checked=true;form.p_awg.checked=false;}
if(z==0){form.p_ws.checked=false;form.p_awg.checked=true;}
z = 0; if(z==1){form.p_Al.checked=true;form.p_Cu.checked=false;}
if(z==0){form.p_Al.checked=false;form.p_Cu.checked=true;}
z = 20; {eval(z); temp = z; form.temp.value = temp;}// ambient temperature
z = 6000; {eval(z); g_radius = z; form.g_radius.value = g_radius;}
z = 6000; {eval(z); w_radius = z; form.w_radius.value = w_radius;}
z = 2800; {eval(z); r_height = z; form.r_height.value = r_height;}
z = 5.5; {eval(z); s_radius1 = z; form.s_radius1.value = s_radius1;}
z = 5.5; {eval(z); s_radius2 = z; form.s_radius2.value = s_radius2;}
z = 2.2; {eval(z); s_height1 = z; form.s_height1.value = s_height1;}
z = 57.2; {eval(z); s_height2 = z; form.s_height2.value = s_height2;}
z = 1870.7; {eval(z); s_turn = z; form.s_turn.value = s_turn;}
z = 0.025; {eval(z); s_wd = z; form.s_wd.value = s_wd;}
z = 7; {eval(z); p_radius1 = z; form.p_radius1.value = p_radius1;}
z = 15; {eval(z); p_radius2 = z; form.p_radius2.value = p_radius2;}
z = 1.3; {eval(z); p_height1 = z; form.p_height1.value = p_height1;}
z = 1.3; {eval(z); p_height2 = z; form.p_height2.value = p_height2;}
z = 7.6; {eval(z); p_turn = z; form.p_turn.value = p_turn;}
z = 0.6; {eval(z); p_wd = z; form.p_wd.value = p_wd;}
z = 0.2; {eval(z); Cp_uF = z; form.Cp_uF.value = Cp_uF;}
z = 0; {eval(z); Lead_Length = z; form.Lead_Length.value = Lead_Length;}
z = 0; {eval(z); Lead_Diameter = z; form.Lead_Diameter.value = Lead_Diameter;}
z = 0; {eval(z); desired_k = z; form.desired_k.value = desired_k;}
z = 13; {eval(z); t_inner = z; form.t_inner.value = t_inner;}
z = 45; {eval(z); t_outer = z; form.t_outer.value = t_outer;}
z = 63.2; {eval(z); t_height = z; form.t_height.value = t_height;}
form.TT.checked = true; form.TG.checked = false;
add_toroid();
z = 120; {eval(z); x_Vin = z; form.x_Vin.value = x_Vin;}
z = 12000; {eval(z); x_Vout = z; form.x_Vout.value = x_Vout;}
z = 60; {eval(z); x_Iout = z; form.x_Iout.value = x_Iout;}
z = 60; {eval(z); x_Hz = z; form.x_Hz.value = x_Hz;}
z = 140; {eval(z); x_Vadjust = z; form.x_Vadjust.value = x_Vadjust;}
z = 0; {eval(z); x_ballast = z; form.x_ballast.value = x_ballast;}
z = 1; {eval(z); rsg_ELS = z; form.rsg_ELS.value = rsg_ELS;}
z = 4; {eval(z); rsg_ELR = z; form.rsg_ELR.value = rsg_ELR;}
z = 1800; {eval(z); rsg_rpm = z; form.rsg_rpm.value = rsg_rpm;}
z = 26.924; {eval(z); rsg_disc_D = z; form.rsg_disc_D.value = rsg_disc_D;}
z = 0.9525; {eval(z); rsg_ELR_D = z; form.rsg_ELR_D.value = rsg_ELR_D;}
z = 0.9525; {eval(z); rsg_ELS_D = z; form.rsg_ELS_D.value = rsg_ELS_D;}
z = 6; {eval(z); stat_EL = z; form.stat_EL.value = stat_EL;}
z = 3.175; {eval(z); stat_EL_D = z; form.stat_EL_D.value = stat_EL_D;}
z = 0.635; {eval(z); stat_gap = z; form.stat_gap.value = stat_gap;}
if(form.SPE.checked==true){form.SPE.checked=true;form.RGE.checked=false;}
if(form.RGE.checked==true){form.SPE.checked=false;form.RGE.checked=true;}
}

Wgrywanie wsadu do FPGA Lattice ice40 przez SPI z STM32 #2

Plik wsadowy .bin można też zamienić lokalnie na tablicę C w pliku nagłówkowym .h za pomocą aplikacji:

https://github.com/AntumDeluge/bin2header/releases/tag/v0.3.1

Odpowiednio ustawiając skrypty poprzedzające kompilację, możemy automatycznie dokonywać konwersji. Oczywiście to tylko przykład, wsad mikrokontroler może odbierać dynamicznie z innego źródła, np. USB. Jedynym ograniczeniem jest wtedy pamięć RAM, która musi zbuforować ciąg danych.

Skompensowana funkcja dokonująca programowania:

/*
* SPI has to be configured in range (1..25MHz)SCK Freq, 8-bit, MSB-first.
* CRESET_B, SS, - GPIO OUTPUT
* CDONE - GPIO INPUT 
* Returns: 0-programming failed; 1-programming successful
*/
uint8_t flash_fpga(SPI_HandleTypeDef *hspi, const uint8_t *bitstream){

uint8_t retval = 0;
const uint8_t zeroes[] = {0,0,0,0,0,0,0,0,0,0,0,0,0};
HAL_GPIO_WritePin(CRESET_B_GPIO_Port, CRESET_B_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_RESET);
HAL_Delay(1);
HAL_GPIO_WritePin(CRESET_B_GPIO_Port, CRESET_B_Pin, GPIO_PIN_SET);
HAL_Delay(2);
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_SET);
if(HAL_SPI_Transmit(hspi,(uint8_t *) zeroes, 1, HAL_MAX_DELAY) != HAL_OK) return 0;
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_RESET);
if(HAL_SPI_Transmit(hspi,(uint8_t *) bitstream, sizeof(fpga_bin), HAL_MAX_DELAY) != HAL_OK) return 0;
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_SET);
if(HAL_SPI_Transmit(hspi,(uint8_t *) zeroes, 13, HAL_MAX_DELAY) != HAL_OK) return 0;
retval = HAL_GPIO_ReadPin(CDONE_GPIO_Port, CDONE_Pin);
if(HAL_SPI_Transmit(hspi,(uint8_t *) zeroes, 7, HAL_MAX_DELAY) != HAL_OK) return 0;
return retval;
}

Toolchain FPGA

Pliki wsadowe można otrzymać również z darmowego toolchaina pod Linux. Ja sprawdziłem na maszynie wirtualnej z Lubuntu 22.

https://mcmayer.net/first-steps-with-the-icestorm-toolchain/

W tej linii dostosowałem swój układ FPGA:

arachne-pnr -d 384 -P qn32 -o build/blinky.asc -p blinky.pcf build/blinky.blif

Mój plik Makefile:

all: build/blinky.bin
cp build/blinky.bin /media/sf_share/fpga.bin
python3 /media/sf_share/bin2header.py /media/sf_share/fpga.bin

build/blinky.bin: build/blinky.asc
icepack $< $@

build/blinky.asc: blinky.pcf build/blinky.blif
arachne-pnr -d 384 -P qn32 -o $@ -p $^

build/blinky.blif: blinky.v
yosys -p "synth_ice40 -top top -blif $@" $^

prog: build/blinky.bin
iceprog build/blinky.bin

clean:
rm build/*

.PHONY: prog clean

Timing

Czas programowania układu wynosi ok. 30 ms

Wgrywanie wsadu do FPGA Lattice ice40 przez SPI z STM32 #1

Opis

Układy FPGA firmy Lattice można skonfigurować poprzez interface SPI z poziomu podłączonego mikrokontrolera. Układ FPGA pracuje wtedy jako Slave, a mikrokontroler jako master magistrali. Wejście w ten tryb uzyskuje się przytrzymując linię SS w stanie niskim podczas wychodzenia z resetu kontrolera FPGA. Szczegóły opisuje dokument:

iCE40_Programming_Configuration_2022.pdf

Do układu wgrywamy wsad w postaci strumienia bajtów z pliku binarnego uzyskanego z procesu syntezy kodu VHDL/Verilog. Co ciekawe, plik binarny oprócz samej konfiguracji komórek programowalnych zawiera także metadane, które jednakże są ignorowane przez sam układ programowalny:

Zaznaczone bajty 0x7EAA997E są wzorcem synchronizacyjnym, po wykryciu którego układ zaczyna kolejne bajty interpretować jako użyteczne dane. Również na końcu ciągu znajduje się specjalna sekwencja 0x010600 sygnalizująca koniec strumienia (https://github.com/TiNredmc/OpeniCELink/blob/master/Core/Src/main.c).

Podobno można również zaprogramować FPGA na stałe, jednak datasheet nie ujawnia jak 🙁

Setup testowy

Nucleo G031K8
http://e.vt0.pl/products/ice40-board/
Analizator stanów logicznych Saleae

Kod

W STM32Cube został skonfigurowany interface SPI w trybie Master 2MHz MSB First na wybranych pinach + dodatkowe piny GPIO:

PA7 MOSI (SPI)
PA6 MISO (SPI)
PA11 SS (GPIO output)
PA12 CRESETB (GPIO output)
PA5 SCK (SPI)
PA4 CDONE (GPIO input)

Dodatkowo podczas dalszych prób wykorzystano kanał DMA do transferu strumienia danych.

Wsad z pliku .bin przekonwertowano jako tablicę bajtów w formacie języka C i umieszczono w kodzie programu. Do konwersji zostało użyte narzędzie https://notisrac.github.io/FileToCArray/

Co ciekawe, plik ma rozmiar 7413B, gdzie datasheet wpomina, że powinien mieć 7417B – skąd ta różnica 4 bajtów? Nie wiem, ale na razie działa 😉

Kluczowy kod (zakomentowane funkcje SPI niewykorzystujące DMA):

 const uint8_t zero = 0;
HAL_GPIO_WritePin(CRESET_B_GPIO_Port, CRESET_B_Pin, GPIO_PIN_RESET);
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_RESET);
HAL_Delay(1);
HAL_GPIO_WritePin(CRESET_B_GPIO_Port, CRESET_B_Pin, GPIO_PIN_SET);
HAL_Delay(2);
printf("FPGA in slave mode\r\n");
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_SET);

//HAL_SPI_Transmit(&hspi1,(uint8_t *) &zero, 1, HAL_MAX_DELAY);
done = 0;
HAL_SPI_Transmit_DMA(&hspi1,(uint8_t *) &zero, 1);
while(done==0);
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_RESET);
//HAL_SPI_Transmit(&hspi1,(uint8_t *) not_gate_bitmap, sizeof(not_gate_bitmap), HAL_MAX_DELAY);
done = 0;
HAL_SPI_Transmit_DMA(&hspi1,(uint8_t *) not_gate_bitmap, sizeof(not_gate_bitmap));
while(done==0);
HAL_GPIO_WritePin(SS_GPIO_Port, SS_Pin, GPIO_PIN_SET);

const uint8_t zeroes[] = {0,0,0,0,0,0,0,0,0,0,0,0,0};
//HAL_SPI_Transmit(&hspi1,(uint8_t *) zeroes, 13, HAL_MAX_DELAY);
done = 0;
HAL_SPI_Transmit_DMA(&hspi1,(uint8_t *) zeroes, 13);
while(done==0);
if(HAL_GPIO_ReadPin(CDONE_GPIO_Port, CDONE_Pin) == GPIO_PIN_SET){
printf("Programming succesful!\r\n");
}
else{
printf("Programming failed!\r\n");
}
//HAL_SPI_Transmit(&hspi1,(uint8_t *) zeroes, 7, HAL_MAX_DELAY);
done = 0;
HAL_SPI_Transmit_DMA(&hspi1,(uint8_t *) zeroes, 7);
while(done==0);
printf("Finished!\r\n");

Przebiegi

Można zauważyć podniesienie linii CRESETB przy opuszczonej linii SS, Sygnał SCK podczas transferu strumienia, podniesienie linii CDONE sygnalizującej przez układ FPGA poprawne skonfigurowanie, oraz dodatkowe stany na liniach wymagane przez dokumentację – chociaż nie wiem czy w praktyce niezbędne, skoro linia CDONE osiąga stan wysoki wcześniej.

WCH CH32V003 – RISC-V MCU – pierwsze kroki

Kupiłem:

1. Procek w obudowie so8 CH32V003J4M6 https://www.aliexpress.com/item/1005005143221495.html

2. Procek w obudowie so16 CH32V003A4M6

3. Programator WCH LinkE https://www.aliexpress.com/item/1005006295056343.html

Narzędzia:

1. https://www.wch.cn/downloads/WCH-LinkUtility_ZIP.html

2. https://www.wch.cn/products/WCH-Link.html

Pomocny opis: https://oshwlab.com/wagiminator/ch32v003j4m6-game-console

WCH-LinkUtility zagadał:

Trzeba było przestawić najpierw tryb z „ARM” na „RISC-V” wybierając z listy na dole „WCH-LinkRV”.

IDE

Trzeba zainstalować wersję „MounRiver_Studio_Setup”, nie „Community”.

Po instalacji ustawić generowanie plików hex oraz bin:

Jeżeli procesor zachowuje się jakby „zdechł”, „uceglił się”, należy wybrać:

Przykładowy „blink” na pinie PA2:

Pobór prądu: 1,8 mA @ 3,3V @ 8 MHz HSI. Brak obciążonych GPIO, pracujący TIM1 w trybie PWM na prescalerze=0. + prosty kod w pętli main.

Microstrip bandpass filter – wykonanie i pomiary

Serdeczne podziękowania dla mgr inż. Piotra Kwiatkowskiego, za wykonanie pomiarów na profesjonalnym analizatorze wektorowym.

Filtr projektowany na pasmo 434 MHz (420..470 MHz) wg kalkulatora jak niżej:

Płytkę zaprojektowałem w Eagle, rysując bez schematu struktury mikropaskowe. Płytka 4-warstwowa, na zwykłym laminacie FR-4. Wykonana w JLCPCB.

Wyniki pomiarów pierwszej wersji:

Jak widać, pasmo przepustowe w zakresie -3db trafiło na zakres 373..430 MHz przy szczycie na 402 MHz – czyli na sporo niższe częstotliwości, niż pierwotnie zakładane.

Pomiary analizatorem wektorowym:

Na podstawie powyższych wyników, przyjąłem „na oko” proporcjonalną poprawkę na częstotliwości. Wiadomo – krótsze elementy – wyższa częstotliwość.

Ponownie użyłem kalkulatora, ze zmodyfikowanymi parametrami:

Płytka wykonana jak poprzednio. Tym razem pasmo zmierzone analizatorem widma z generatorem śledzącym:

Pasmo nieco szersze niż zakładane, ale trafione w oczekiwany zakres: 406 .. 486 MHz ze środkiem w 446 MHz.

Jak widać, filtr niestety w paśmie przepustowym nadal celuje się względnie dużym tłumieniem na poziomie -6,5 dB. Nie wiem, czy wynika to z kiepskiego dopasowania, stratności w laminacie FR-4 czy ogólnie z nie najlepszej topologii.
Pomiary analizatorem wektorowym:

Excel podświetlanie aktywnego wiersza

Zaznaczamy obszar
Formatowanie warunkowe -> Nowa reguła -> Użyj formuły…
Formuła:
```
=WIERSZ()=KOMÓRKA("wiersz")
```
Formatuj -> Wypełnienie -> Deseń
Prawym na arkusz->Wyświetl kod
Zamiast (General) -> Worksheet
Wpisujemy w procedurę
```
Target.Calculate
```
Zamykamy okno bez zapisywania

Test NanoVNA za 100zł

NanoVNA-H 3.4 kupiony powystawowy za 100zł.

Wersja 50 kHz – 1.5 GHz.

Wgrany najnowszy firmware NanoVNA-H-SI_20240220. https://github.com/hugen79/NanoVNA-H/releases/

Trzeba zainstalować ze strony ST.COM DfuSe_Demo_V3.0.6_Setup.exe, wybrać sterownik DFU w Managerze urządzeń (zamiast domyślnego STM BOOTLOADER), i można wgrywać. Wybrałę wersję „SI” bo zakładałem, że mój NanoVNA jest oparty o oscylator SiliconLabs. Można to potem zmienić w menu. Ważne, żeby wgrać wersję pod wyświetlacz 2,4″.

Dla testów użyłem aplikacji NanoVNA.App.exe – by OneOfEleven: https://nanovna.com/?page_id=141

Zmierzony włączony szeregowo filtr kwarcowy 10.3 MHz:

Działa to zacnie, za taką kwotę.

VS:Code Jupyter – interaktywne wykresy z matplotlib

Należy zainstalować pakiet „ipympl”

I na początku dokumentu Jupyter dodać magiczną komendę:

Możemy się cieszyć wykresami które można zoomować, przesuwać itp:

N-path filter by Bram Nauta – prosty układ – pomiary

Serdeczne podziękowania dla Mgr Inż. Piotra Kwiatkowskiego za udostępnienie aparatury i pomoc w wykonaniu pomiarów.

Sygnał zegarowy z układu NE555 o częstotliwości ok. 120 kHz

Transmitancja filtra. Zaznaczone 2 szczyty pasm przepustowych, dla częstotliwości ok. 30 kHz (1/4 częstotliwości zegarowej) oraz ok. 60 kHz.

Zawężenie prezentacji transmitancji do jednego prążka o częstotliwości środkowej 30 kHz.

Widać dużą dobroć filtra. Pasmo przepustowe -3dB ma szerokość ok. 300 Hz, co daje dobroć ok. 100.

Jeszcze prezentacja czasowa sygnału na wejściu i na wyjściu filtra. Pomiar zrobiono podając na wejście sygnał sinusoidalny o częstotliwości zbliżonej jak to tylko było możliwe do częstotliwości środkowej filtra

Źródła:

Budowa i pomiary transformatora izolacyjnego do pomiarów Bode

Podziękowania za wsparcie w realizacji oraz konsultacje dla inż. Michała Karasia – eksperta w zakresie badań obwodów i stabilności.

Inspiracja: https://electronicprojectsforfun.wordpress.com/injection-transformers/

Materiały:

2x rdzenie VAC T60006-L2030-W514
Para skrętki pozyskana z kabla Ethernet BitLAN 2x23AWG (użyta długość poniżej 3m, z wyliczeń ok. 95mmb/zwój)

25 uzwojeń nawiniętych bifilarnie na 2 połączone rdzenie (sklejone dla wygody nawijania)

Zgrubne pomiary przy użyciu „testera tranzystorów” dały wyniki ok. 60 mH dla każdego z uzwojeń. Po zwarciu przeciwnego uzwojenia, miernik nie był w stanie określić indukcyjności, co sugeruje wysoki współczynnik sprzężenia (coupling factor), oceniam na powyżej 0,99.

Wyniki pomiaru charakterystyki w zakresie 10Hz – 25 MHz:

vac0.csv

Wykres przy użyciu Python+Matplotlib (pominięte ostatnie próbki które „leciały w kosmos”, dla czytelności skali):

vac0parsed.csv

python.zip

Dla ok. 6-7 MHz amplituda „ucieka” na +3dB, czyli tutaj można uznać koniec sensownego pasma transformatora.

Całe pasmo jest bardzo liniowe. Z jakiegoś powodu jednak Rigol jest upierdliwy w pomiarach – trwają bardzo długo, i nieraz trzeba je powtarzać, bo pojawiają się losowe zakłócenia.

Zdjęcie stanowiska pomiarowego: