Category Archives: MCU

Blogas GCC arba x86 bėdos

Papuolė į rankas tokia maža ISA PCB su keliais čipais. Su magišku užrašu “Y2000”. Ir iškarto trenkė nostalgija, apie tai, kaip visi panikavo, kad kompiuteriai 2000-taisiais metais išprotės, nes metai tik dviženklis skaičius. Aišku buvo bėdų su tais metais, bet daugelis panikuotojų nepagalvojo, kad technologija smarkiai tobulėja ir kompai pradėjo labai greitai morališkai senti.

O tiems, kurie strigo su sena technika, atsirado visokie BIOS pataisymai. O jei nėra BIOS pataisymo, va jums papildoma plokštė su ROM. (Kitos mikroschemos tik supaprastina ROM pajungimą prie ISA linijų)

Nutariau pažiūrėti, kas tos mikroschemos viduje. Viduje labai mažai kodo, tai buvo kaip tik, kad pasimokinti Hidros (GHIDRA) programos vartojimo.

ISA PCB yra 8 bitų. Vadinasi suderinama su pačiais primityviausiais x86 procesoriais. Vadinasi kiek rimtesni procesoriai turi veikti “REAL MODE” režime. x86 procesoriaus kodas vos vos panašus į Z80 ir tikrai panašus į 8086. Hidra išardė kodą. O internetai padėjo atpažinti- pirmi trys baitai tai 55 AA 10. “55AA” tai signatūra, o 10 tai programos ROM dydis (kart 512 baitų, h100). O nuo 4 baito prasideda pati programa.

Konkreti Y2K PCB darė šitą: išvalo ekraną (rodos), parašo užrašą, nuskaito dalį RAM ir kažką paskaičiuoją ir jei nepavyko, sako error ir išeina, nuskaito RTC per BIOS, nuskaito RTC tiesiogai, palygina, ir jei kažkas gaunasi arba rašo, kad kompas suderinamas su Y2K arba bando (?) pačinti BIOSą. Čia jau spėlioju, nes mano žinio gana trumpos čia.

Kilo mintis padaryti va taip:

Copy-paste kažkiek asemblerio mnemonikų… ir kaip sukompiliuoti? Internetai sako, kad standartinis GCC, su raktažodžiais tipo “-m16 -nostdlib -ffreestanding” turi gaminti x86, 16bitų, REAL kodą. Ir tikrai, kopijuotas kodas iš Hidros susikompiliavo. Toliau teko kankintis su LD.exe ir visokiais loaderiais, kad gautųsi ROM image, o ne exe failas. Tai irgi buvo pilnas nuotykių žaidimas kuris nepavyko iki galo.

Tačiau kodas neveikė realiuose kompiuteriuose.

Ir pasirodo, kad JOKS GCC nesugeba generuoti teisingą 16 bitų, REAL MODE kodą. Iš principo. Binarinių failų palyginimas parodė, kad CALL, RETF ir gal kitokios instrukcijos generuojamas 32 bitų. Tas 32 bitų kodas “kaip ir suderinamas”, bet kai paleidi iš BIOSo, tai tikrai nesuderinamas. Ir nesvarbu koks procesorius- 486DX irgi nesuprato.

Rašyti softą be CALL kaip ir sunkoka. Gerai, kad čia tik kelios eilutės- išvalyti ekraną, per BIOSą (TTY režime) išspjauti tekstą ir nuskaityti ANYKEY iš klaviatūros. Teko viską perrašyti tiesiogiai. Ir rankutėmis įkelti “RETF” teisingą kodą programos gale. Kodu nesidalinu, nes jis baisus, nesuprantamas ir ten per daug POP/PUSH (kopijavau iš tikrų paprogramių, kur išsaugoja registrus). Svarbu veikia.

ROMas turi primityviausią kontrolinę, 8 bitų, sumą. Todėl reikią paskutinį baitą ROMe kaitalioti tol, kol suma nepasidaro 00.

O dar radau keistą PCI plokštę iš Izraelio- kažkoks tipo “security”. Pati PCB tai kastruota tinklo plokštė su BOOT ROM. Jei bus azarto, bus galima pasinagrinėti šitą kodą.

Taigi, be normalaus asemblerio, koduoti ROMą labai sunku. O tiek turėjau planų- panaudoti C kalbą ROMe ir PC kompiuterį panaudoti kaip mikrokontrolerį. Kam? Ogi smalsu. Nebent PCI kompiuteriai jau tikrai valgo 32 bitus ROMe.

O grynai asembleris tai NASM. Jam puikiausiai kompiliuojasi. Tikriausiai komentaruose bus pilnas komplektas NASM kompiliatoriui.

P.S. Originalus Y2000 ROMas.

Spalis 24

Spalio mėnesio fotopostas. Biški nėra ką rašyti.

Fazendos gargulija
Chamiška lapė pas kaimynus kieme
Truko SiC kaitinimo elementas- daug įtampos, mažai srovės ir temperatūros
O ši juostelė nenusiskaitė. Pelėsiai- blogis.
Šis šūdas ėda mano nervus. Kodėl vienas solenoidas DC? Ir kodėl jis nutrūko?
Manau tai manija. Kam man tiek juostelių
Nauja universali NIXIE plokštė. Kiek didesnė ir beveik SPI. Iki 2×8 lempų. Hipsterinių laikrodžių gamybai.

makefile (užrašai sau)

Makefile tai specifinis instrukcijų rinkinys kuris gali pats paleisti kitas instrukcijas ir pats save ir panašiai. Naudojamas automatizuoti programų kūrybą ir gal dar ką nors. Ši žinutė skirta man pačiam, nes atmintis labai blogai dirba. O jei kitiems tiks, ar bus kokių nors patarimų- welcome.

  1. PROJECT = $(notdir $(CURDIR))
  2. SRC = $(wildcard *.c)
  3. BDIR = build
  4. OBJ = $(patsubst %.c, $(BDIR)/%.o, $(SRC))
  8. .PHONY:	clean all hex
  9. #phony - komandos (jei netycia sutaptu su failo pavadinimu)
  11. all:
  12. 	@echo "all" $(PROJECT)
  13. #all pasileidzia kai paleidziamas make be komandu
  15. levas:
  16. 	@echo $(SRC) $(OBJ)
  17. 	
  18. #pirmas iki: objektas komanda arba failas, antras -kokiems failams galioja
  20. $(BDIR)/%.o:	%.c
  21. 	echo $@
  22. 	mkdir -p $(BDIR)
  23. 	cp $< $@
  24. 	
  25. objects: $(OBJ)
  27. elf:	$(BDIR)/$(PROJECT).elf 
  28. #sutrumpinta komanda, kad nereiketu ivesti pilno failo pavadinimo
  30. $(BDIR)/$(PROJECT).elf: $(OBJ)
  31. 	cat $(OBJ) > $(BDIR)/$(PROJECT).elf
  32. 	
  33. clean:
  34. 	rm -f $(BDIR)/*.o $(BDIR)/*.hex $(BDIR)/*.bin $(BDIR)/*.elf
  35.

Komentarai:
Eilutės 1-4: paprasčiausi kintamieji ir kelios operacijos su jais. 1) kintamasis “PROJECT” pasidaro naudojamo folderio pavadinimu, 2) “SRC” – visų failų su išplėtimu masyvas. 3) paprasčiausias priskyrimas. 4) vieno masyvo konvertavimas į kitokį.
Eilutė 8: make visiškai nesvarbu ar dirbama su failais, komandomis ar “kažkokiais objektais”. Jei folderyje bus failas “clean” ir jis nekis, make pasitikrins tai ir nebevykdys komandos. Phony pasako, kad čia ne failas.
Eilutė 11: “all” pasileidžia, kai make paleidžiamas be parametrų, čia kaip “main()” funkcija.
Eilutė 15: komanda gali vadintis bet kaip. Tik turi užsibaigti dvitaškių. O jos atliekamos komandos turi būti “atitrauktos” per tabą.
Eilutė 20: komanda gali būti failo pavadinimas, kad ir iš komentaro, o antras žodis po dvitaškio kaip ir filtras kokius failus galima naudoti. Čia biški nesuprantu.
Eilutė 25: komanda “daryk objektus” pasiima visus būsimus “O” failus ir generuoja pagal 20 eilutę iš “C” failų. Jei “O” failai jau sugeneruoti ir jų “šaltinis” toks pats, failai ignoruojami.
Eilutė 27: Kad nereikėtų nurodyti kokį “ELF” failą generuojam, čia parašom supaprastinimą.
Eilutė 30: Kai reikia generuoti kokį “ELF“, kad ir iš 27 eilutės, naudojam tokią instrukciją ir gaminam iš “O” failų. Savo ruožtu, jei nėra “O” failų, tai juos generuojam iš “C” failų (20 eilutė). Ir kartu stebim, ar kas nepasikeitė
Eilutė 33: Paprasčiausiai ištrinam viską ką sugeneruojam.

Atrodo viskas siaubingai ir keistai. Ir net nesuprantu kaip tai veikia. Tačiau teisingai parašytas makefile viską labai palengvina, nes nebereikia galvoti, kas ten su kuo jungiasi ir kas iš ko darosi. Iš principo tai gana specifinė “skripto” kalba.

P.S. Jei dirbat su windows ir jus užkniso, kad kiekvieną kartą paspaudus ant “makefile” windows klausia su kokia programa ją atidaryti, darykite taip:

assoc .="No_Extension"
ftype "No_Extension"="C:\WinAVR\pn\pn.exe" "%1"

Tiktai “path” iki savo redaktoriaus pasikeiskit.

Pareigūnų sirena

Toks beveik vandalizacinis straipsnis. Tarp utilizuojamos technikos pasitaikė sirenos generatorius. Dar prie jo reikėtu ir aukštavolčio garsiakalbio, bet jo neturim.

Tokias sirenas naudoja įvairių šalių pareigūnai. Musiškiai naudoja tokią- dviejų melodijų ir beep-beep (air horn) imitacija.

Schemos nesinagrinėjau, bet spėju, kad tai bus gryna skaitmena stiprintuve- nemanau, kad du tranzistoriai su tokiu mažu aušinimu dirba kokiam nors kitokiam režime nei D. Trafukas švelniai groja sirenas, prie išėjimo pabandžiau paprastą gasiakalbį ir kelių šimtų omų rezistorių. Iškarto rezistorius pakaito- galios turi daug.

Tik trys mikroschemos. PICas lizdelyje- “operatyviai” galima keisti melodijas. Dar viduje turi būti kažkoks ADC keitimas, nes galima šnekėti per tą “gavarilką”– “vairuotojas, prašom sustoti” 🙂

Jokio panaudojimo nesurandu, nes negalima naudoti. Nebent kaip signalizacijos triukšmo šaltinį.

27C400 arba Amiga Kickstart readeris

Biški gliučino mano remontuojamos Amigos, tai teko greituoju būdu pasidaryti 27C400 skaitytuvą nes pasirodo, nei vienas mano turimas EPROM skaitytuvas 256Kb x16 nevirškina. Nutariau pasinaudoti eiline STM32F103VGT plokšte. Dėmesio! Čipas VGT turi 96kb RAM, kiti gali netikti, nes programa naudoja 64K buferį mikroschemos skaitymui. Ir dar kažkiek užima USB procedūros.

STM32F103 yra tolerantiška 5V logikai, o šios ROM mikroschemos visiškai tolerantiškos kiek žemesnio potencialo logikai. Gal, jei šitą plokštę perdaryti iki programatoriaus, tai Vcc ten 6V (Vpp-12.5V). Jei tie 6V nutekės iki kojyčių, tai STM gali ir nugeibti.

Net ir naudojant GPIO valdymą, STM labai greitai nuskaito informaciją. O va greičio USB perdavimui tai labai labai trūksta. Kažkur skaičiau, kad STM32F1 gali iki 700kbit/s greitį pasiekti. Man kogero nepavyko- pagal LED matosi, kad iš čipo skaito gal ketvirtį sekundės, o poto ilgai ir nuobodžiai pumpuoja informaciją.

Viduje žalių laidelių žarnynas. Bet viskas veikia. Palaidas kondensatorius reikalingas- pasirodo, mano kompiuterio USB maitinimas visiškai blogas ir duomenų skaitymas labai jau matosi ant Vusb linijos.

Pasitikrinau visus Kickstartus, ir visi buvo geri.

Programinėje įrangoje daug nesąmonių. Bet gal kam nors bus įdomu. Yra tikras CRC32 skaičiavimas, hardwarinis CDC valdymas, IntelHex duomenų skaitymas ir rašymas. Viską galima valdyti per terminalinę programą. Savo reikmėm pasirašiau VB.NET programą, bet ja nesidalinsiu, nes ten viskas labai baisu ir vienintelė iki galo padaryta funkcija- nuskaityti čipą, paskaičiuoti CRC32 ir įrašyti čipo turinį į failą.

Visas STM32F103 27C400 ar Amiga Kickstart čipų skaitymo įrankio (ROM READER) source code ir CubeMX darbinis failas.

P.S. programa daro “byte swap”, nes visi Amiga kickstartai internete taip surašyti. O čipuose baitai sukeisti vietomis. Nedarašytas šios funkcijos valdymas ( reikia išjungti n = __builtin_bswap16(n); ). Sukeitimas tikriausiai susijęs su 68000 ir Intel MSB-LSB ar panašiai ideologija…

ARM48: USB HID host

Jei naudojamas STM32 čipas palaiko USB HOST režimą, tai prijungti USB įrenginį labai paprasta. Mano hardwarė labai paprasta- čipas ir dvi USB jungtys. Viena jungtis suprogramuota kaip virtualus COM portas skirta peržiūrėti rezultatus, o kita USB jungtis tai USB host. Čia galima prijungti pelę ir klavietūrą. Kiti HID įrenginiai nepalaikomi.
Primenu, kad HID klavietūra palaiko iki 6 klavišų nuspaudimus (neįskaitant modifikatorius: shift, control, alt…) ir atskirai siunčiami klavišų paspaudimai ir atleidimai.
Kad viskas veiktu, tereikia savo programoje pasirašyti callbacką:

  1. void USBH_HID_EventCallback(USBH_HandleTypeDef *phost)
  2. {
  3. char txt_buf[100];
  4. char t[4];
  5.  
  6. strcpy(t,"[x]");
  7. 	if(USBH_HID_GetDeviceType(phost) == HID_MOUSE)  // if the HID is Mouse
  8. 	{
  9. 		HID_MOUSE_Info_TypeDef *Mouse_Info;
  10. 		Mouse_Info = USBH_HID_GetMouseInfo(phost);  // Get the info
  11. 		int8_t dX_Val = Mouse_Info->x;  // get the delta x value (note unsigned - signed conversion)
  12. 		int8_t dY_Val = Mouse_Info->y;  // get the delta y value
  13.  
  14. 		int len = sprintf (txt_buf, "dX=%d, dY=%d, Button1=%d, Button2=%d, Button3=%d\r\n", dX_Val, dY_Val, Mouse_Info->buttons[0],Mouse_Info->buttons[1], Mouse_Info->buttons[2]);
  15. 		user_usb_tx((uint8_t *) txt_buf,len);
  16. 	}
  17. 	if(USBH_HID_GetDeviceType(phost) == HID_KEYBOARD)
  18. 	{
  19.  
  20. 		HID_KEYBD_Info_TypeDef *Keyboard_Info;
  21. 		Keyboard_Info = USBH_HID_GetKeybdInfo(phost);  // get the info
  22. 		txt_buf[0]=0;
  23. 		unsigned char i;
  24. 		for(i=0;i<6;i++)
  25. 		{
  26. 		if(Keyboard_Info->keys[i] != OLDKEYS[i] )
  27. 			{
  28. 				if (Keyboard_Info->keys[i]==0) {strcat(txt_buf,"UPKEY:"); hex8(txt_buf,OLDKEYS[i]);t[1]=Scan2Char(OLDKEYS[i]); strcat(txt_buf,t);}
  29. 				else if (OLDKEYS[i]==0) {strcat(txt_buf,"DOWNKEY:"); hex8(txt_buf,Keyboard_Info->keys[i]);t[1]=Scan2Char(Keyboard_Info->keys[i]); strcat(txt_buf,t);}
  30. 				else {strcat(txt_buf,"ERR:"); hex8(txt_buf,Keyboard_Info->keys[i]); strcat(txt_buf,"-");hex8(txt_buf,OLDKEYS[i]);}
  31. 			}
  32. 			OLDKEYS[i]=Keyboard_Info->keys[i];
  33. 		}
  34. 		strcat(txt_buf,"\r\n");
  35. 		user_print_usb( txt_buf);
  36. 	}
  37. }

Pačiam HID reporte visada transliuojami visi nuspausti klavišai, todėl, jei reikia susiderinti su PS2 ar senesniu standartu, reikia tikrinti, koks klavišas nuspaustas ir koks paleistas. Ta daro ciklas 24-33 eilutėse.
Rezultatas:


UPKEY:12[o]
DOWNKEY:13[p]
UPKEY:13[p]
DOWNKEY:2F[[]
UPKEY:2F[[]
DOWNKEY:30[]]
UPKEY:30[]]
DOWNKEY:31[\]
UPKEY:31[\]
DOWNKEY:04[q]
DOWNKEY:16[s]
DOWNKEY:07[d]
DOWNKEY:09[f]


DOWNKEY:2C[ ]
UPKEY:16[s]
UPKEY:07[d]
UPKEY:09[f]
UPKEY:04[q]
UPKEY:2C[ ]
DOWNKEY:0B[h]
UPKEY:0B[h]

Visas demo softo source code čia: STM32CubeMX USB host HID demo source code.

Su Naujais, 2024 metais!

Sveikinu visus su Naujais Metais!

(Nu nepatinka mano telefonui ta bjauri mėlyna spalva. Pakeisti negaliu, o nenaudoti irgi negaliu, nes turiu ekraniukų gal 100 vienetų.)

Ką čia palinkėti? Kaip senas diedas- laimės ir sveikatos! Kaip elektronikos megėjas- mažiau magiškų dūmų, ir nepaimti lituoklio už ne to galo. Kaip kompiuteristas- kad mažiau reikėtu migruoti visą softą į kitos kartos OS. Kaip chemikas- kad nusėstu kai reikia nusodinti, kad ištirptu kai reikia ištirpinti. Kaip megėjas statybininkas- kad nereikėtu bendrauti su tikrais statybininkais.

ARM47 ir PID dalis #4

O dabar pašnekėsim apie STM32F4 serijos variantą ir source code. Pirmiausia- kodėl 4 serija? Todėl, kad tokia PCB pasitaikė po ranka. Ir tikrai ne dėl kažkokio mistinio FPU ar net DSP. Ir dar neaišku, ar mano turimas MCU yra originalas, o ne koks nors permarkiruotas šlamštas. Šaltinis solidus, bet kodėl jie juos išmetė? Reikia surasti kur nors panaudotą procesorių ir palyginti.

Source code yra sugeneruotas su CubeMX programa, kompiliuota su gcc. Ryšiai su kubiko paprogramėm tik per callback. Ir tai tik naudojam USB biblioteką (virtualus COM portas) ir taimerių pertraukimus. ADC skaitom blokavimo režime.

Pats PID skaičiavimas, float variantas visiškai toks pats kaip ir teoriniam variante:

float pid_generic(float measured, float setpoint, float amplif)
{
float output;
float deritative;
float error;
float proportional;
 
error = (setpoint - measured)/10;
proportional = error;
 
integral=integral + error * pid_dt;
deritative = (error - old_error) / pid_dt;
old_error = error;
 
output = (PID_KP * proportional + PID_KI * integral + PID_KD * deritative) * amplif;
 
return output;
}

Atsirado papildomas parametras “amplif” – tai bendro rezultato daugiklis, kaip ir sustiprinimas (ar susilpninimas). Teoriškai tą patį galima atlikti su pagrindiniais parametrais (P, I, D), bet taip lengviau priderinti prie “krosnelės” galingumo: kaitinimas dirba su integer skaičiais, ir PID rezultatas apsiapvalina. Taip prarandam “jautrumą”. Ir dar temperatūros parodymus pasmulkinam- tik dėl koeficientų.

uint32_t CalcTemp(void)
{
uint32_t a;
a=median_filter(adc_read_blocking(ADC_CHANNEL_4));
a=median_filter(adc_read_blocking(ADC_CHANNEL_4));
//a=median_filter(adc_read_blocking(ADC_CHANNEL_4));
// 786 - max t, 0.62V ->1655
// 3529 - kambario t, 2.83V -> 283
return (4096-a)/2; //12 bitų max apverčiam ir pašalinam LSB.
}
 

Dėl ADC blogumo, matuojam kelis kartus, invertuojam (dėl schemotechnikos išėjimas mažėja didėjant temperatūrai) ir pašalinam mažiausią bitą, nes jis rodo kvailystes. Funkcija “median filter” vogta iš interneto. Tai funkcija, kuri teoriškai turi išfiltruoti sporadiškus nukrypimus: jei eina 5, 6, 4, 3, 100 – tai tas šimtas kaip ir ne į temą. Kiek veikia per daug netikrinau. Manau, reikia dar padidinti buferį.

  1. readtemp=CalcTemp();
  2. pwm=PID(readtemp, SETTEMP);
  3. SetPWM(pwm);

O čia pats pagrindinis ciklas, kuris kartojamas sistemingai: 1 – nuskaitom, 2 – paskaičiuojam. 3 – valdom kaitinimą.

Visas likęs source kodas aptarnauja kontrolerio valdymą per terminalą (galima keisti parametrus) ir duomenų išmetimą analizei. Tai tik eksperimentinis variantas- darbiniam trūksta dar visokių apsaugų, normalaus valdymo ir indikacijos. Ir aišku, išėjimas čia PWM, kad tinkama mažam rezistoriui, bet ne tikram šildytuvui. Dar nesugalvojau, kaip padaryti korektiškai proporcinį valdymą realiai rėlei ar 50Hz simistoriniam reguliatoriui. Jei užteks kantrybės, tema bus vystoma.

Pats pilnas STM32F446 PID controller source code skirtas gcc ir kartu CubeMX projekto failas (versija užrakinta posto datai, galimi patobulinimai). Prie papildų- median filter, ftoa ir usb paprogramės. Visa mano kūryba “USER” aplanke.

PID, dalis #3, FLOAT ir STM32F4

Dabar, apjungiant senesnius straipsnius [0, 1, 2], sumontavau kažką panašaus į PID termokontrolerį.

PID controller STM32F4xx

Ant lentos surinkta mano universali White Pill plokštė, tik su STM32F446 procesorium (toks biški itartinas tas procesoriukas, kažko man taimeriai neteisingai veikia). Dešinėje- mano Pt100 termorezistoriaus stiprintuvas. Geltona plokštė, tai kiek pasvilęs RGB LED “stiprintuvas”- galvaniškai atrišti trys galingi MOSFET valdomi per optoporas. Optoporų rezistorių teko sumažinti, kad nuo 3V procesoriuko pilnai valdytusi. O vienas “RGB LED stiprintuvo” kanalų paprasčiausiai valdo vielinį rezistorių kairėje, į kurį įkištas Pt100 jutiklis- tai mikro krosnelė, kurioje bandysim stabilizuoti temperatūrą.

Šiame eksperimente naudojamas source code su “float” kintamaisiais. Nenorėjau iškarto eksperimentuoti su integer matematika, nes dar nežinojau savo “krosnelės” parametrų.

PID įėjimas- ADC, išėjimas PWM. Panaudojau “prabangų”, 16 bitų PWM, nes norėjau platesnio reguliavimo. O su ADC išėjo biški problematiškai- STM32F446 ADC biški gaidiškas (net jo datašytas tai rašo). Nėra jokio tikslumo ir rezultatai vaikšto. Todėl panaudojau matematinį “filtrą” ir kelis nuskaitymus iš karto. Temperatūra matuojama “papūgomis”1 – 1000 vienetų tai kažkur 40℃, o apie 280 tai kažkur kambario. Užduotis- palaikyti 1000 vienetų temperatūrą viduje rezistoriaus.

Pagrindinė bėda- tiek rezistorius, tiek Pt100 žiauriai lėtai veikia. Todėl teko gana ilgai žaisti su koeficientais, ir dar iki optimalumo jie neprivesti.

PID chart

Mėlynas grafikas- rezistoriaus temperatūra. Raudonas grafikas PWM užpildymas. Matosi periodiniai triukšmai tiek temperatūros nuskaityme, tiek išeinančiam signale. Reikia rimtesnio skaitmeninio filtro. Dar kiek palaikius, paskutinius 400+ skaitymų temperatūros vidurkis buvo lygiai 1000 papūgų. Tačiau signalas nesusistabilizavo. Gal per maža PWM reikšmė:

PID PWM

Vos 2% iš viso. Gal vėliau pabandysiu su aukštesne temperatūra. (PWM signalas iš MOSFETO- žemas lygis reiškia, kad rezistorius prijungtas prie žemės ir kaista). Beja, gal ir siauresnis signalas per siauras šiems kiniškiems mosfetams. Pastebėjau, kad prie mažesnių signalų, PWM dingsta iš oscilografo ekrano.

Pratesimas ir veikiantis source code sekančiam straipsnyje.

  1. Tai santykinis matvimo vienetas iš seno multifilmo, kai matavo smauglio ilgį. ↩︎

PID, dalis #0

Pasišlykštėjęs kiniškų termokontroleriu nutariau kiek pasidomėti PID kontrolerio teorija. O tam reikėjo pasirašyti šildytuvo modelį (emuliatorių).

PID emuliatorius

Gavosi maždaug toks. Tai 100ml vandens kuris neverda (sferinio arklio vakuume) kaitintuvas su stabiliu aušinimu. Man tikrai patiko, kaip kontroleris reaguoja į netikėta aušinimo pastiprinimą ir kaip jis stabilizuojasi.

Kol kas tik tiek. Taip buvo pirmas vakaras. Pratesimas jau čia.