Cewka Tesli #2 – obliczenia

http://javatc.teslacoil.co.nz/

J A V A T C version 13.6 - CONSOLIDATED OUTPUT
16.07.2024, 19:51:35

Units = Centimeters
Ambient Temp = 20ºC

----------------------------------------------------
Surrounding Inputs:
----------------------------------------------------
5 = Ground Plane Radius
5 = Wall Radius
10 = Ceiling Height

----------------------------------------------------
Secondary Coil Inputs:
----------------------------------------------------
Current Profile = G.PROFILE_LOADED
5.5 = Radius 1
5.5 = Radius 2
2 = Height 1
37 = Height 2
1400 = Turns
0.025 = Wire Diameter

----------------------------------------------------
Primary Coil Inputs:
----------------------------------------------------
Round Primary Conductor
8 = Radius 1
16 = Radius 2
2 = Height 1
2 = Height 2
6 = Turns
0.6 = Wire Diameter
0 = Ribbon Width 
0 = Ribbon Thickness 
0.1 = Primary Cap (uF)
0 = Total Lead Length
0 = Lead Diameter

----------------------------------------------------
Secondary Coil Outputs:
----------------------------------------------------
157.48 [kHz] = Secondary Resonant Frequency
90 [deg °] = Angle of Secondary
35 [cm] = Length of Winding
40 [cm] = Turns Per Unit
0 [mm] = Space Between Turns (edge to edge)
483.81 [m] = Length of Wire
3.18 [:1] = H/D Aspect Ratio
168.5376 [Ohms] = DC Resistance
43048 [Ohms] = Reactance at Resonance
0.211 [ kg] = Weight of Wire
43.506 [mH] = Les-Effective Series Inductance
59.497 [mH] = Lee-Equivalent Energy Inductance
58.834 [mH] = Ldc-Low Frequency Inductance
23.477 [pF] = Ces-Effective Shunt Capacitance
17.167 [pF] = Cee-Equivalent Energy Capacitance
77.722 [pF] = Cdc-Low Frequency Capacitance
0.1769 [mm] = Skin Depth
13.073 [pF] = Topload Effective Capacitance
265.8284 [Ohms] = Effective AC Resistance
162 [Q] = Quality Factor

----------------------------------------------------
Primary Coil Outputs:
----------------------------------------------------
152.62 [kHz] = Primary Resonant Frequency
3.09 [% high] = Percent Detuned
0 [deg °] = Angle of Primary
452.39 [cm] = Length of Wire
2.76 [mOhms] = DC Resistance
0.733 [cm] = Average spacing between turns (edge to edge)
2.188 [ cm] = Proximity between coils
0 [cm] = Recommended minimum proximity between coils
10.874 [µH] = Ldc-Low Frequency Inductance
0.09393 [µF] = Cap size needed with Primary L (reference)
0 [µH] = Lead Length Inductance
135.502 [µH] = Lm-Mutual Inductance
0.169 [k] = Coupling Coefficient
0.13 [k] = Recommended Coupling Coefficient
5.92 [half cycles] = Number of half cycles for energy transfer at K
19.04 [µs] = Time for total energy transfer

----------------------------------------------------
Top Load Inputs:
----------------------------------------------------
Toroid #1: minor=8, major=35, height=40, topload

 

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

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:

Faza_S21
Faza_S21
Tlumienie_S21_2
Tlumienie_S21_2
Faza_S21_2
Faza_S21_2
S11
S11
S22
S22
Tlumienie_S21
Tlumienie_S21

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:

Faza_S21-1
Faza_S21-1
Faza_S21_2-1
Faza_S21_2-1
S11-1
S11-1
S22-1
S22-1
Tlumienie_S21-1
Tlumienie_S21-1
Tlumienie_S21_2-1
Tlumienie_S21_2-1

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ę.

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: