Hameg HM8042 curve tracer module : rom dump

Heb je trouwens een specifieke reden om de hele voeding nog lineair te maken, in plaats van switchers?

UPDATE

- Voeding overgezet naar switchers. De kost van transfo's is verschrikkelijk. 4 transfo's ( +/-5v +/-15v 48v en 5v logica) alleen al (zonder al de regalaars,gelijkrichters en andere meuk ) , was meer dan 50$... en je moet transfo's hebben met gescheiden primaire (115/230, ik wil dit ding universeel houden) , een schakelaar om om te schakelen. Er zat dan nog eens bijna 30$ aan spanningsregelaars (7805x3, 7905 7815 7915, een LM317HV) condensatoren en koelplaten in.

Omgezet naar Meanwell switchers. 72...265AC naar 48v DC. Dan twee switchers van 48VDC naar +/-5 en +/-15
Een aparte switcher die 5V maakt voor relais/processor
Totale kost : 41$

Ik heb een flink stuk al gesimuleerd (LTspice en nu overgestapt naar Microcap.) en gebreadboard.

Opamps omgeschakeld naar TL081H / 82H / 84H. Die LF412 zijn duur en achterhaald. Zelfde offset specs maar beter tempco voor offset em kleinere biasstroom. De TL08xH <- let op het achtervoegsel 'H' zijn de laatste generatie van de TL08x familie

Sweepgenerator compleet herwerkt. Wat een draak was me dat zeg... En geneens een linaire zaagtand.

Stroombron vanuit een referentie diode (ATL431) die een condensator laadt. Low soakage filmcap 100nF (PolyPropyleen Wima ding)
Comparator TLV7211 met een push-pull output en hysteresis circuit tussen 0v en 2v zodat je een proper 2v zaagtand krijgt. Zaagtand is 20mS voor 5 sweeps. zo krijg je een "50Hz beeld" op je scoop. geen geflikker meer.

Overload geheugen met een echte flipflop ( geen misbruikte 555 meer). Bij overload word the collector spanning afgeknepen en de beam onderdrukt ( Z blanking) . zo stop je curve op de horizontale as bij een overload en krijg je geen terugslag artifacten meer.
Beam wordt ook onderdrukt bij terugslag van de sweep

In STOP word de beam ook onderdrukt , zo brandt je scoop niet in.
Er is een "beamfinder". Als je in STOP op de rotary encoder drukt zet je de beam op.

Z polariteit is omschakelbaar. Sommig scoops zijn actief hoog, andere actief laag.

X Y en Z zijn afgebufferd, ESD protected en kortsluitvast.

Gans de reutemeteut met analog multiplexers en weerstandsdeler om 4V 10V en 40V ranges te maken is er uit. Vervangen door een digitale potmeter op i2c. Ik behoud de presets maar je kan vrij regelen. het 40V bereik is te hoog voor veel moderne fets. Die halen 20 of 30 volt max. Zet daar 40 volt op en ze slaan door.
Je kan de spanning vrij instellen.

Er is alleen een range knop die schakelt tussen de "voorgeprogrammeerde" bereiken (eenrichting). de andere toets is nu gebruikt als "Limit" die je vrij kan instellen

De poweramp laat ik voorlopig gerust. Alhoewl ik daar waarschijnlijk ook die analog muxen voor polariteit ga uitzwieren. Je kan een opamp omschakelen tussen +1 en -1 gain door middel van een simpele mosfet. Scheelt de helft aan opamps en die analoge mux. Die potentimeteres voor offset compensatie worden ook waarschijnlijk overbodig. De afregeling is nodig door zommige "kromme" weerstandwaardes. Aangezien alle weerstanden 0.1% zijn en ik de waardes verander kan ik er waarschijnlijk ook vanaf. multiturn trimmertje zijn tegenwoordig ook verschrikkelijk duur.

In de limit detector heb ook ook geschoten. In plaats van een harde compartor limiet is die nu ook instelbaar door middel van een digitale potmeter. ( die digitale pots kosten 1.2$ voor een 2 kanaal. een Bourns Trimpotje kost 2.54! zonder Trump-tarief ! Da's meer dan 4x zoveel 5.08$ tegen 1.2 $)

Voorlopig staat de processor keuze nog op een AtmegaX64D3
- 5 volt
- UPDI programmeren over een simpele UART. geen nood aan speciale programmers.

Ik ga een Silabs CP2102 er aan hangen met een schakelaar : UPDI/UART. Geen geklooi met drivers , geen nood aan foefelarij met dingen zoals Zadig.
Je kan firmware laden over USB. Als er ook firmware komt met remote bediening is de UART beschikbaar.

In de IB driver zitten ook een paar opamps (en analog muxen) teveel. daar ga ik ook een +1/-1 gain opamp maken.

Er is een betere Marker generator. De Y uitgang heeft nu een sommeerversterker. Een analog schakelaar kan een positieve en een negatieve spanning (+/-0.5v) injecteren in de sommeerversterker. Dit geeft een mooie piek die boven en onder de curve vliegt.

Er zijn 4 sample/hold versterkers voor de analog parameters. Zo hoef ik niet telkens de zelfde sweep afwachten om 1 parameter te digitaliseren. Als de timer overloopt springen die dingen in HOLD en heb ik 4 samples op het zelfde moment. Ik heb dan meer tijd om de processor die te laten digitaliseren. simpele 4066 , 4 condensatoren en een TL084. kost haast niks.

Het princiepe loopt nog grotendeels gelijk met de 8042 maar de uitwerking is anders. Ik wil niet zomaar een klakkeloze kopie maken.

nieuwe PDF

https://github.com/vincent-himpe/CurveTraceNew/blob/main/CT8042/PDF/CT…

Ik ben, zoals gewoonlijk, weer zwaar onder de indruk van je aanpak!!
Je upgrade lijkt een beetje op wat Hameg met de HM8018 heeft gedaan: versie 1 heeft nog een mechanische draaischakelaar voor de bereiken en mechanische drukschakelaars, terwijl versie 2 volledig met drukknopjes en indicatie LED's is uitgevoerd. (Helaas nog geen schema's van de HM8018-2 kunnen vinden.) De HM8018-2 is een prachtig apparaat dat ik ook graag aan mijn collectie meetapparatuur zit willen toevoegen.

FLATER GEVONDEN. de lm393 comparators trekken naar -5 volt. ( onderste rail hangt aan -5v. ). in het origineel systeem werkte dat aangezien de 555 "flipflop" ook aan de -5v hangt. Mijn flipflop hangt aan 0v. dus hij werd een "flif-plop" ( net geen rook ontwikkeling, maar wel dood. een cd4013 overleeft dat niet)

Een extra PNP transistor ( emitter aan +5 , basis via weerstand naar de lm393 uitgang ) lost dat op.
Extra invertertje erachter (schmitt-trigger 40106) en we hebben weer een active low. Geen nood om de logica om te gooien. ik had toch nog 2 inverters over van de pulse-stretcher.

Or is een wired-or met twee diodes om Ilimit en Plimit te combineren naar 1 "overload" signaal wat de sweep afbreekt. De LM393 is open collector dus daar kreeg je een wired-or cadeau. met de extra transistor/schmit-trigger is dat verloren. 2 diodes lossen dat op.

het Ilimit en Plimit signaal (voor de wired-or) gaan naar een "pulse stretcher" twee schmitt-triggers met een r-c constante die de impulse verlengen ( als de sweep afgebroken wordt verdwijnt ook de fout conditie, dus die "limit" pulsjes zijn heel kort. De flipflop stockeert die voor de sweep, maar ik wil tegelijk twee langere pulsen om een led te sturen.

Op het forntpaneel zijn 2 extra leds nu. Ilimit en Plimit.
Bij overstroom of oververmogen gaan die aan.

frontpaneel layout is iets aangpast.

De Vmax en IMax instellingen zijn van plaats gewisseld zodat de "limit leds" oplijnen.
De power knop ( eerder "standby" nu , de echte schakelaar zit achteraan ) is verplaatst. hij kwam te dicht bij de LCD connector.

Functie van de toetsen :

Bipolar en P/N laten je kiezen tussen fet en bipolair en npn/nmos of pnp/pmos aangegeven door leds

Setup laat je toe om instellingen te maken en in het calibratie menu te gaan

A en B selecteren een van de DUT kanalen aangegeven door leds

de "Range" toetsen voor vmax,imax en pmax selectern een van de "presets" aangegeven door leds

de "Limit" toetsen voor vmax,imax en pmax staan je toe de limiten voor de functie te verlagen door middel van de rotary encoder.

Bij een overload op imax/pmag gaat de led naast de "limit" toets voor die functie aan

Run/stop stuurt de sweep aan of uit (dut blijft geselecteerd , maar drivers gaan af alsook de beam op de scoop gaat uit. in STOP kan je een beamfind doen door op de rotary encoder te drukken)

ALT schakelt de alternating mode in ( als je in RUN gaat). dit werkt alleen als je de optomossen geinstalleerd hebt en niet de mechanische relais. Er wordt automatisch geschakeld tussen de twee DUT's. hoe ik de alternering precies ga doen weet ik nog niet. 10 curves op de scoop ( 5 per dut) wordt een warboel. Ik denk er aan om de trace te laten kiezen met de "Select knop". Je kan dan 1 van de 5 traces laten zien. Zo krijg je slechts 2 curves: 1 per DUT. kan je mooi vergelijken of ze samenvallen. je kan dan manueel de trace keuze veranderen.

Ik twijfel of ik de "count" knop behoud. ik wil de software zo klein mogelijk houden. de gebruiker het aantal curves laten kiezen is weer te veel aan keuze. er zijn er 5, en that's it. no more, no less.

Naast de grote rotary encoder zijn nog 3 knoppen.

1/2 laat je een van de 2 markers kiezen (je kan delta-metingen doen tussen twee punten op de zelfde trace)
A/B laat je de markers verzetten tussen DUT A en B (alleen in ALT mode, in single mode volten de markers automatisch de DUT keuze)

display:
In single mode staan op de bovenste lijn de parameters van de actieve marker
onderste lijn toont de delta waardes tussen de markers.
de page knop kan dan de limit voor imax en pmax tonen als je ze verandert hebt

in alt mode is bovenste lijn DUT A en onderste lijn DUT B
de PAGE knop schakelt dan naar de delta waardes ( weer bovenste lijn DUT A en onderste lijn DUT B)
nogmaals page knop toont de limitien voor imax en pmax

de preciese software uitwerking komt er nadat ik de finale hardware versie heb.

ik ben er nog altijd niet uit welke processor ik wil gebruiken.... er zijn geen echte eval borden voor x64d3 om eens te zien hoe BASCOM om kan met de hardware.
Ik twijfel om een RP2040 te gebruiken en er MMBasic op te laten draaien. Dat is een interpreter en staat je toe om heels snel software to ontwikkelen zonder eindeloze compile loops...
Probleem is dat een rp2040 te veel rotzooi meebrengt... is een QFN dus lastig te solderen, extern memory nodig... De 2350B nieuwe versie heeft het i/o probleem opgelost en komt met interne flash. dus die is aantrekkelijk, maar ook alleen weer in qfn... en dan nog 0.4mm.

de kant en klaar moduletje zijn voor mij geen optie. ik hou niet van die "arduino" torens met shields, capes, shoes , hats en andere kledingstukken. dat is soep.

ik probeer zoveel mogelijk met "grote" componenten te werken. geen tssop als ik het kan vermijden. SO verpakkingen werken heel makkelijk ( DIP en thru-hole passiven is no-go. er zijn haast geen nieuwe component meer en wat er nog is is duur tov SMD )

Op zondag 7 september 2025 09:23:26 schreef MNM(tm):
De HM8018-2 is een prachtig apparaat dat ik ook graag aan mijn collectie meetapparatuur zit willen toevoegen.

Ik heb de 8018-1 en 2 en drie 8000 units (ik heb ook de 1GHz counter, 2 FG's, 20MHz pulse gen, de 3 kanaal voeding en een door Rene Beckers gebouwde 10 MHz standaard.

Ik heb ook een brochure, user manual en service manual(met schema's) in pdf vorm. Wil je die hebben?
Ik zou die 8042 ook wel willen.

Vincent, ga je die PCB's + firmware verkopen?

Open source. Alles staat op github
Noot dat dit geen klakkeloze kopie is van de 8042. Ik heb het circuit van de 8042 ( en 6042) grondig bestudeerd, bepaalde stukken gebouwd en of gesimuleerd (Ltspice en Microcap) om te kijken hoe ze werken.
Ik heb nog steeds geen ROM gevonden en ben nu op het punt waar ik die eigenlijk niet meer nodig heb. Met de video op het internet die de werking toont , en de schema's heb ik haast alles kunnen uitvlooien.

Het ontwerp , zoals het nu is, is grondig gewijzigd van het originele ontwerp.

Het idee is dat je de printen besteld bij JLCPCB en (eventueel) door hen het klein grut er op laat zetten. Spaart een hoop werk. Er zijn bepaalde ic's die zij niet hebben zoals sommige analog muxen, de DAC , de power opamp en nog wat ander spul wat makkelijk soldeerbaar is.

het ontwerp bestaat uit 3 printplaten : 2 "actieve" en 1 frontpaneel. In plaats van zelf aluminium te zitten zagen en dat dan zelf te kunnen beletteren laat je gewoon een dubbelzijdige prinplaat etsen met zwart soldeermasker en witte opdruk. Etsen is een groot woord ... is gewoon volledig koper beide kanten met openingen in het masker achteraan of er afstandsbussen op te solderen zodat je het echt paneel kan vastzetten. Printjes uit china zijn zo goedkoop dat je er zelf geen tijd kan aan gaan hangen.

zoals gezegd : Alles is beschikbaar op github als Altium project en het gans production pack ( gerber,drill,pick en place, bom ) onder Creative Common Zero. Doe er mee wat je wilt.

Dat het een Altium project is is geen probleem voor Open Source . KiCad kan dat inlezen zonder problemen. De enige reden dat ik het niet direct in KiCad doe is dat ik al 30+ jaar met Altium werk en geen zin heb om mij dood te vloeken om iets anders te leren.

Zelfde reden waarom ik nog steeds twijfel over de processor keuze. Ik wil me niet vastzetten op iets met een enorme leercurve waar ik meer tijd ga aan verpselen met opzetten van een toolchain, libraries en klooierij met programmers die niet werken, debuggen met printf (komaan, t'is 2025. Kunnen we even een echte debugger of zelf een hardware emulator hebben ja?) dan dat ik effectief aan iets werk.

Ik begin meer en meer naar MMbasic te neigen nu. Ondanks ik een hekel heb aan "moduletjes stapelen", zoals de meest projectjes tegenwoordig zijn: stapels schoenen, hoeden, mantels en andere neuspeuterij, verlakt in kilometers aan libraries waar geen mens een fluit van snapt, aangestuur door een triestige IDE met een haperende compiler.

Misschien is de RP2350 module nog zo slecht niet. (zelf neerpoten is geen optie. ding is in QFN en de 2354 met ingebouwde flash is onvindbaar) . Ik probeer het makkelijk bouwbaar te houden. QFN is problematisch. En dat gedoe met die externe flash is ook een miserie. Als je niet exact het juiste type hebt is er ook niks anders dan problemen. Eigenlijk kan het met een 2040 maar die zijn ADc is noisy ... misschien dat ik de ADC ook gewoon op i2c zet.

- ingebouwde USB mass storage, geen nood aan FTDI , CH340 of CP2101 geklooi met drivers. Ding is gewoon DFU ,drag en drop. werkt op alle platformen
- geen nood aan een specifieke programmer , die dan ook weer zijn eigen controle software en driver geklooi meebrengt.
- niet gebonden aan 1 programmeeromgeving. Je kan je eigen ding doen, in je eigen omgeving en programmeertaal naar keuze, op je eigen operating systeem.
- geen vereiste voor 1 bepaalde compiler die geld kost.

De keuze voor MMBasic brengt dan mee dat je een interpreter runt zodat je niks extern nodig hebt voor ontwikkeling. hang het aan de computer, lanceer een terminal en go.

Waarom dan geen python ? Da's voor mij weer een bron van frustratie waar ik geen zin in heb. Zelfde reden waarom ik Altium gebruik. Ik ken dat door en door.

Al de bovenstaande dingen zijn niet voor discussie vatbaar. Altium , Basic . Done
Ik geef het gewoon mee om ellenlange discussies te vermijden.

Het ganse project is open source. Je kan het zelf porteren naar micropython of arduino of whatever. Een 5 jarige kan Basic leren en begrijpen.

Op zondag 7 september 2025 22:35:36 schreef fred101:
[...]Ik heb de 8018-1 en 2 en drie 8000 units (ik heb ook de 1GHz counter, 2 FG's, 20MHz pulse gen, de 3 kanaal voeding en een door Rene Beckers gebouwde 10 MHz standaard.

Ik heb ook een brochure, user manual en service manual(met schema's) in pdf vorm. Wil je die hebben?

Weet je zeker dat in de service manual van de 8018-2 ook echt de schema's van de -2 staan?
De SM's van de 8018-2 die op het internet te vinden zijn, hebben wel de afbeelding van de -2 op de voorpagina staan, maar zowel de schema's als de PCB layouts zijn gewoon van de -1.
Als jouw SM voor de 8018-2 ook echt voor de -2 zijn, dan wil ik die heel graag hebben, ja!

Verrek, je hebt gelijk, dat moet het schema van de 1 zijn want de 2 heeft een PCB wat hooguit 1/3e van de plugin-kast inneemt terwijl de tekening van het PCB in het manual grofweg net zo lang is als de plugin.

BRONNEN VAN HAMEG INFORMATIE :

https://www.sm5cbw.se/hameg/hm80/hm8001.htm
https://www.youtube.com/watch?v=DfAZMpOWE6g

Een update : printjes zijn onderweg van china (jlcpcb)

Frontpaneel is een dubbelzijdige print met zwart masker en witte opdruk. Kost haast niks en is de moeite niet om zelf te gaan vijlen in aluminium of plastic en dan zelf te gaan prutsen om dat te beletteren. Kostte 11$ voor 5 printen...
Het koper is intact voor en achter. Langs achter zijn er openingen in het soldeermasker om er afstandsbussen op te solderen. Wurth 9775066360R. Dit zijn afstandsbusjes voor SMD montage. Ze zijn gemaakt om te solderen. Zo heb je geen gaatjes nodig die het frontpaneel ontsieren. M3 schroefdraad.

https://github.com/vincent-himpe/CurveTraceNew/blob/main/finalfront.pn…
https://github.com/vincent-himpe/CurveTraceNew/blob/main/finalfront-ba…

Het voorpaneel zelf is een 4 lagen print. Kost ook haast niks meer tegenwoordig...

https://github.com/vincent-himpe/CurveTraceNew/blob/main/finalfrontboa…

Drukknopjes zijn E-switch TL1105 met bijhorende kapjes (1RLGY) die er op klikken. De leds zijn Sunled. met een 2mm flatt-top. Alles is courant te krijgen bij digikey/mouser en waarschijnlijk ook op TME.
Encoder is Bourns PC12 familie. de aslengte weet ik niet precies. hangt van de knop af , maar ze zijn beschikbaar in 15 17 20 22 25 en 30 lengte.. ik denk 22 of 25 moet het doen.

Let niet op die pinheader links van het display. die bestaat niet. is alleen om de mechanische uitlijning te doen. In werkelijkheid soldeer je daar afgeknipe weerstand poten in
Het display hangt achter het bord om de juiste afstand te krijgen voor de leds en drukknoppen
Deze print schroeft in het voorpaneel

https://github.com/vincent-himpe/CurveTraceNew/blob/main/finalfrontboa…
https://github.com/vincent-himpe/CurveTraceNew/blob/main/finalfrontboa…

Er zijn alleen weerstanden voor de leds, wat pullups en de I2C i/o expanders. (NXP of TI PCAL9555)
Deze expanders hebben interrupt mogelijkheid en heel wat programmeermogelijkheden. het zijn upgrades van de PCA9555. Een specialiteit is de programmeerbare state-latch. Als ene pin van toestand verandert krijg je een interrupt en de toestand wordt opgeslagen. Als je dus op een knopje drukt en weer loslaat is die wijziging opgeslagen. Je krijgt alleen een interrupt bij het indrukken, niet bij loslaten maar de toets-aanslag is opgeslagen.

Het idee is om de keyboard scan toe doen tijdens de sweep retract. Aangezien een nieuwe sweep start om de 4milliseconde kan ik gewoonweg de i2c bus lezen na de start. ( als er ene interrupt is van het keyboard).

Ik had origineel slechts 3 expanders. 1 voor leds, 1 voor toetsen en 1 50/50 ( er zijn 16 kanalen in 2 banken op die dingen) . Maar om de softwar eeenvoudiger te maken heb ik de middenste afgesplitst. Het is overkill en er zijn 9 kanalen niet in gebruik , maar het maakt de software ene flink stuk makkelijker.

De software architectuur heeft de leds en de toetsen beide als een 32 bit value opgeslagen. De transport routing hoeft dus enkel blokken van 16 bit per expander te schuiven. We gaan niet voor elke prul read/modify/writes gaan doen. Das veel te veel dataverkeer. De software zet of leest de bits van de twee variabelen, en de interrupt handler schuift alles in 1 keer door ,om de 4 milliseconden.

Die expanders kosten 1.2$ ... ik ga niet in software gaan prutsen en daar complexe routines voor gaan schrijven.

LCD display is in 4 bit mode. Dit is een Display van Eastrising : BuyDisplay.com. Eastrising is een van de grootste lcd module fabrikanten ter wereld. Het enig probleem is dat je ze alleen bij hen kan bestellen ( buydisplay.com) maar ze zijn spotgoedkoop. 7$ tegen 20$ bij digikey. En ze hebben allerhande kleuren (als je per-se een blauwe wilt... yuckkk ) Het speciale is de backlight module. Die zit verzonken en de displays zijn een flink pak dunner dan normale.

Je kan ze ook vinden op amazon en ebay.

De processor wordt een AVR64DA64 ( je kan ook de 64DB64 gebruiken. zelfde ding maar heeft hardware multiplier)

De processor keuze heeft heel wat voeten in de aarde gehad.
- makkelijk te krijgen
- makkelijk te solderen (geen QFN of BGA)
- goedkoop
- 5 volt voeding (5volt tolerantie alleen is niet genoeg, geen gepruts met level shifters)
- flink wat ram en rom (64kflash en 2k ram) meer dan genoeg.
- eenvoudig te begrijpen preripherals. ( zommige van die cortex dingen zijn een drama om uit te vlooien)

En de twee belangrijkste :
1) geen gepruts met programmeerkabels en dongles en avrdude and andere rotzooi . Ik haat dat gedoe met drivers die niet werken en klooierij met dingen zoals "Zadig". Ik heb een lade vol jtag probes, segger, u-links, j-links, avrisps, Stlinks and andere rommel in wel 10 versies die net meer werkt omdat ze te oud zijn, de fabrikant verdwenen is of de software niet werkt op platform xyz of de ieuwe versie van de software de oudere hardware niet ondersteunt.

De AVR64 programmeert en debug't via UPDI. Dit is een domme USB<>uart. Je kan een FTDI of CP2102 of CH340 er aan hangen en het werkt.

Ik zet gewoonweg een ch340 en een usb connector op het moederbord. USB kabel er in en vort met de geit. Er zit een switch die UPDI loskoppelt en omleidt naar een uart.

2) de beschikbaarheid van een BASIC compiler. Geen gepruts met 'C' of 'Python'
- Bascom-AVR
- Great-Cow Basic
Great-cow is gratis. Bascom is betalend. Ik heb de licentie voor Bascom . Werkt lekker en de simulator heeft LCD display simulatie.

Er waren nog een pak andere factoren zoals de nood aan een spannings referentie voor de a/d. Ze zijn slim geweest bij deze processor en hebben een 2.048 volt referentie aan boord. Dit maakt dat je geen floating point nodig hebt ! Geen gedoe met kromme waarden zoals bij een 1.2 volt of 2.5 volt referentie spanning.

Aangezien de analoge hardware met spanningen tussen 0 en 2 volt werkt (zowel voor aansturen als meten) landt dit netjes in het 2.048 volt bereik. Als ik de 12 bit omzetter uitlees en daar een shift-right van 1 bit op uitvoer heb ik direct de gemeten waarde in volt. als ik 2000 lees is dat 2 volt. geen berekeningen van doen !
Schaal dat omhoog met 8 bit (x256) en stop dat in een 32 bit variabele en je kan alles doen met integer math. eenmaal klaar : deel door 256 en je hebt je waardes.

Ik heb een testbord gemaakt voor de AVR64.
https://github.com/vincent-himpe/AVR64DA64-Breakout/blob/main/breakout…

Geinspireerd op de mikroe borden. Elke I/O pin heeft ene led/drukknop en pinheader. die in en uitschakelbaar zijn. er zijn 3 pinheader pinnetjes + 1 grond per i/o poort. zo kan je 2 draadjes op een poort zetten en heb je nog eentje over voor je scoop of logic analyser + een grond voor je probe

dit bord is universeel maar ik heb er twee extra connectors op gezet : 1 voor een los LCD display en de connector met de pinout voor het forntpaneel van de curvetracer. zo kan ik direct aan de slag.
Er staat ook een i2c digitale potmeter en een dac op alsook een FRAM (eeprom zonder schrijf cyclus. ferro-electric ram. RAM maar nonvolatile)

De updi programmer en updi/uart schakelaar is ook aan boord. plug en play.CH340B gebaseerd. Ik heb specifiek de B versie gekozen omdat die een eeprom aan boord heeft waar je een serienummer kan inzetten. Geen gevloek om uit te vlooien op welke compoort het ding nu weer zit ... Windows registreert het serienummer en koppelt daar de bijhorende poort aan. USB devices die geen serienummer dragen zijn first-come first serve. ALs je dus twee van die dingen aankoppelt weet je noiit wie op welke poort landt. Bij devices met een serienummer blijft de "poort" bij het nummer. je mag ze dus in en uit trekken : de poort is altijd de zelfde.

Volgende week zou ik de printjes moeten hebben. Ik heb het development bord laten bestuken door JLCPCB (alleen de SMD componenten) 72 ledjes, 72 drukknopjes ... en de bijhorende weerstandjes ... laat ze er maar op schieten. T'was iets van 140$ bestukt voor 5 borden. das 28$ per bord. Ik ga er mijn tijd niet aan hangen.

Zoho ... iemand is druk geweest ...

Ik heb in het verleden wel wat geprutst met bascom ... de free versie was historisch een tikje buggy, en de editor is ... tja, niet heel ver verwijderd van notepad. Het ding doet amper wat voor je.
Great-Cow ken ik niet, dat is wellicht nog eens een blik waard.

In wat voor een behuizing wil je het geheel gaan lepelen?

Dag Vincent,

Al je links doen het behalve deze :
https://github.com/vincent-himpe/AVR64DA64-Breakout/blob/main/breakout…

how. die stond private.. open gezet.
De documentatie van dat bord volgt.

Great-cow gebruikt gewoon een C-compiler als backend.

De behuizing is ene standaard Hammond RM2095M kastje
Ze zijn goedkoop , makkelijk te krijgen en handig. Desktop model. Denk "bench multimeter"

Heel vele wikken en wegen in dit project. Ik probeer iets te maken wat makkelijk na te bouwen is en geen exotische onderdelen gebruikt. Met exoten bedoel ik BGA en QFN en 042 componenten : dingen die niet makkelijk te verwerken zijn.

0603 werkt lekker met ee moderne soldeerbout ditto voor TQFP.
Dingen laten maken in china ( printen en bestukking) vie JLCPCB of PCBWAY is tegenwoordig zo goedkoop. Laat al die passieven er daar op schieten en zet er zelf de ic's op.

Ze hanteren een system van "basic" componenten. Als je die gebruikt rekenen ze geen kosten aan. Hun machienes staan geladen met die onderdelen. De meest 1% weerstanden, een pak condensatoren , diodes etc.

Bij het maken van dat AV bord heb ik daar mee rekening gehouden. Voor elk component dat niet in dat "basic" gamma zit rekeken ze 3 dollar handarbeid aan om een operator de rol te laten halen en op de machine te zetten. De leds, drukknopjes en weerstanden zijn haast allemaal "basic". De thru-hole rekeken ze ook handenarbeid aan. Ondanks dit bord gemaakt is voor wave soldering ( er staan geen SMd op de achterkant) doen ze dat toch met de hand. Dus dat heb ik ze laten overslaan. hun connectors zijn wel spotgoedkoop dus als je geen pinheaders in huis hebt loont het wel om ze daar te latne plaatsen. Maar ik heb toevallig een ganse emmer van die pinheaders staan ( een zak os 10 van elk 250 stuks ...) Die zet ik wel zelf.

De productie BOM van dat bord heeft de juiste JLCPCB codes aan boord en je kan dat zo inlezen daar. De processor moet je omzetten naar een 64DB64 omdat ze de DA niet in voorraad hebben. Hij kost een paar dollar meer. Het enige verchil is die multiply unit maar die gebruik ik toch niet.

Dingen zoals de DAC, potmeter , encoders etc zitten niet in de BOM. Die zitten niet in hun BASIC pakket en je hebt die niet altijd nodig. Ik heb ze op het bord gezet om te kunnen experimenteren met bepaalde zaken vooraleer ik de hoofdprint laat maken.

Die PWM generator maakt een 4mS puls met een 99.5% duty cycle. De bedoeling is de "sweep" te emuleren. Door dat signaal aan de interrupt te hangen kan ik de scoop nabootsen. de potmeter staat me toe de duty cycle te veranderen. Als ik zie dat de interrupt afwerking te lang duurt kan ik spelen met de duty cycle van de sweep. ( door de terugslag langer te maken krijgt de interrupt handler meer tijd om alles klaar te zetten voor de volgende sweep.)

[Bericht gewijzigd door free_electron op dinsdag 23 september 2025 16:59:30 (89%)]

kleine update ..

Achterkant frontpaneel:

voorkant frontpaneel :

Nice! Dat zijn zo te zien zelfs foto's en geen renders.

jup. fotos van voorpaneel
ik moet er nog de SMD onderdelen op zetten. Maar het mechanische werk past alvast in het kastje.

Een update. Verlof achter de rug (2 weken digitale detox).

Na wat ge-experimenteer in software blijkt dat er te veel jitter zit op verschillende dingen en er veel te veel gepruts nodig is in de interrupt afhandeling. Een deel van het probleem is de analoge sweepgenerator met comparatoren. Dat spul drift....

De ganse logica heeft veel kunst en vliegwerk nodig in de software om alles op tijd te kunnen afhaspelen.

Tijd om de sweepgenerator digitaal te maken.

Eerste idee : een vrijlopende teller (8 bit) die een dac (voor x) aanstuurt. dit maakt een mooie zaagtand. Hang daar een paar 74688 8 bit comparatorne achter en je hebt triggers voor de cursors. De waardes worden opgeslagen in 74574 registers.
Werkt mooi.

De software kan die updaten. Cursor generatie heeft wat extra flipflops nodig (7474) en wat gates...
Verrek. als ik die cursor registers omzet naar 8 bit up/down counter met laad mogelijkheid kan ik de encoders daar direkt aan hangen.... scheelt weer software werk. laat de hardware al dat spul doen.
En ik kan het zelfde doen voor trace selectie....
En sinds die nu ook in de hardware wereld leeft kan ik de verticale step dac daar ook sturen. Maar daar heb ik 5 registers voor nodig. Dit wordt een flinke bak TTL....

hmmm. -lightbulb- : een CPLD ! ideaal voor dit soort werk. voor 6$ heb ik een 5M160 die al dat werk aankan.
Blijk dat de MAX V simpelweg kan geprogrammeerd worden met een FTDI in MPSSE mode (JTAG).
Als ik de FTDI232 vervag door een 2232 ( 2 poorten) . heb ik er eentje voor communicatie / programmering van de microprocessor (Atmel UPDI) , en de tweede voor de cpld. Er is dus geen nood aan externe dongles.... mooi.

Maar we gaan de logica niet meer met schematjes ontwerpen.... SystemVerilog to the rescue !

Effe Quartus II 13.xx downloaden en installeren.

wat experimenterne later en we krijgen dit :

/* NOTE : this code uses the principle of scheduled logic. If you don't know what that is : the verilog (and als VHDL) standard mandate that code shall be evaluated in the order it is written. The practical aspect is that a later line of statements takes precedence over an earlier one.

Example:
  x <= x+;
 .... some more stuff ...
if (reset)  x <= 0;

The reset now has priority. There is no need for if-then-else constructs. Since the last line gets evaluated last , it determines the final outcome.

Scheduled logic eliminates undefined states completely and removes the complexity of nested if-then-else constructs)
*/
module sweepcontrol 
(
   // ----------------------- inputs ---------------------

   // master clock
   input logic clk,
	
	// data and address bus
	input logic [7:0]  data_in,
	input logic [3:0]  address_in,
	input logic write,
	
	// rotary encoder signals
	input logic rot_phase_a , rot_phase_b,
	
	// sampling enable
	input logic enable_sampling,
	
	// ----------------------- outputs ---------------------

	// dac output
	output logic [7:0] dac,
		
   // sampler gate signals		
	output reg sample_gate_a , sample_gate_b ,
	
	// channel selection
	output reg [1:0] channel_select,   // drives relays or multiplexer
	output reg channel_ab,       // notifies cpu what channel is sampled
	
	// sampling done 
	output reg sample_ready,     // notifies cpu samples have been collected
	
	// cursor generation
	output reg [1:0] cursor_state,
   
	// voltage dac
	output reg [7:0] dac_y,
	
	// general purpose encoder
	output reg [7:0] encoder_value
);


// internal registers  

reg [7:0] cursor_a , cursor_b ;
reg [7:0] rotary_limit;
reg [11:0] loopcounter;
reg auto_channel;
reg [2:0] selected_trace;
reg [7:0] step1;
reg [7:0] step2;
reg [7:0] step3;
reg [7:0] step4;
reg [7:0] step5;
reg [3:0] edge_detector;
reg [1:0] rotary_binding;

// This is a pure combinatorial block 
// We bring out the lowest 8 bit of the loopcounter to drive the dac

always_comb begin
   dac[7:0] <=loopcounter [7:0];
end

always_ff @(posedge clk) begin
   
	// Always running upcounter. on counter overrun increment sweep counter
	loopcounter <= loopcounter +11'd1;
	if (loopcounter == 11'b100_11111111) begin
		loopcounter <=0;
		if (auto_channel ==1) begin
		   case (channel_select)
			  2'b00 : channel_select <= 2'b00;
			  2'b01 : channel_select <= 2'b10;
			  2'b10 : channel_select <= 2'b01;
			  2'b11 : channel_select <= 2'b00;   // this can't happen , but if it does : turn all off
			endcase
		end
	end	
	
	// this can run always too : update vertical dac 
	case (loopcounter[10:8])
	   3'b000 : dac_y <= step1;
		3'b001 : dac_y <= step2;
		3'b010 : dac_y <= step3;
		3'b011 : dac_y <= step4;
		3'b100 : dac_y <= step5;
	endcase
	
	
	if (channel_select == 2'b10) channel_ab <=1;
	if (channel_select == 2'b01) channel_ab <=0;
	
	// rotary encoder edge detector
	
	edge_detector[3:0] <= { edge_detector [2:0],rot_phase_a};
	
	// sampling logic
	
	if (loopcounter[10:8] == selected_trace) begin
	   if (sample_ready == 1'b0) begin
			if (loopcounter[7:0] == 8'b0) begin
				 sample_gate_a <= 1'b1;
				 sample_gate_b <= 1'b1;
			end
			case (cursor_state)
			2'b00   :	begin
								if (loopcounter [7:0] == cursor_a) begin
									cursor_state  <= 2'b01;
									sample_gate_a <= 1'b0;
								end
								if (loopcounter [7:0] == cursor_b)begin
									cursor_state  <= 2'b01;
									sample_gate_b <= 1'b0;
									sample_ready  <= 1'b1;
								end;	
							end 
			2'b01   :   cursor_state <= 2'b11;
			2'b11   :   cursor_state <= 2'b00;
			default :   cursor_state <= 2'b00;
			endcase
		end
		else begin
			if (enable_sampling == 1'b1) sample_ready <=1'b0;
		end
	end	
	
	// cursor control
	if (edge_detector == 4'b0111) begin
		case (rotary_binding)
		2'b00 :  if (rot_phase_b ==0) begin
		            if (cursor_b !=255) cursor_a <= cursor_a+ 8'd1;
					end
					else begin
					   if (cursor_a !=0) cursor_a <= cursor_a-8'd1;
					end
					
		2'b01 :  if (rot_phase_b ==0) begin
		            if (cursor_b !=255) cursor_b <= cursor_b+8'd1;
					end
					else begin
					   if (cursor_b !=0) cursor_b <= cursor_b-8'd1;
					end
		2'b10 : 	if (rot_phase_b ==0) begin
		            if (selected_trace != 3'b100) selected_trace <= selected_trace+3'd1;
					end
					else begin
					   if (selected_trace !=0) selected_trace <= selected_trace-3'd1;
					end	
		2'b11 :	if (rot_phase_b ==0) begin
		            if (encoder_value != rotary_limit) encoder_value <= encoder_value + 8'd1;
					end
					else begin
					   if (encoder_value !=0) encoder_value <= encoder_value -8'd1;
					end	
		
		endcase
	end
	
	
	
	// process the register writes. Since this happens later it takes priority (scheduled logic)
	if (write ==1) begin
		case (address_in)
			4'b0000 : cursor_a       <= data_in;
			4'b0001 : cursor_b       <= data_in;
			4'b0010 : selected_trace <= data_in [2:0];
			4'b0011 : rotary_limit   <= data_in;
			4'b0100 : begin
							if (auto_channel==0) begin                                     // don't allow this when in autochannel
								if (data_in[1:0] != 2'b11) channel_select <= data_in[1:0];  // protect from user stupidity. block enabling both channels
							end	
						end	
			4'b0101 : auto_channel   <= data_in[0];
         4'b0110 : rotary_binding [1:0] <= data_in[1:0];
			4'b0111 : begin                                                             // reset command
							sample_ready <=1'b0;                                            // force sample write register
							cursor_state <=2'b0;
							channel_select <=2'b0;
							sample_gate_a <=1'b0;
							sample_gate_b <=1'b0;
							loopcounter <=0;
							dac_y <=0;
						 end	
			
			4'b1000 : step1 <= data_in;
			4'b1001 : step2 <= data_in;
			4'b1010 : step3 <= data_in;
			4'b1011 : step4 <= data_in;
			4'b1100 : step5 <= data_in;
			5'b1111 : encoder_value <=data_in;
		endcase
	end
	
end

endmodule

Dit ding draait autonoom.
De software laadt de 5 waardes voor de step generator. en de boel werkt vanzelf.
De software kan de cursors positioneren, maar kan ook de encoder koppelen aan een van de cursors / trace selectie. De encoder bedient dan de cursor of trace autonoom.
De samplers worden gestuurd vanuit de cursor logica. Als de juiste trace voorbij komt vuren de samplers af. Als de tweede sampler klaar is krijgt de processor een interrupt en kan die de a/d conversie doen. De processor heeft alle tijd van de wereld om dat te voltooien. Zolang de processor de samplers niet vrijgeeft vuren die niet opnieuw af. Aangezien een 5-trace sweep minstens 20 milliseconden (50 sweep/seconde om geflikker tegen te gaan) duurt is dat flink tijd zat.

De harde logica kan ook multiplexen tussen de kanalen. zo krijg je 10 traces ( 5 van kanaal a, en 5 van kanaal b) ter zelfder tijd te zien. ideaal om 2 transistors te matchen. De cursors verdubbelen dan ook maar volgen elkaar ( er is slechts 1 positie , identiek voor de twee traces) . de software kan dan op het display de delta laten zien tussen de kanalen alsook tussen de cursors.

Het kan in princiepe allemaal in software gedaan worden maar alles is onderhavig aan interrupts. Er gebeurt te veel en de software wordt een warboel. Het simuleert ook niet makkelijk. De meeste software simulatoren hebben geen ondersteuning voor interrupt werk. De CPLD omgeving kan dat wel.

ik ben nu een maal veel sterker in hardware dan in software....

Andersom zal het denk ook wel gebeuren dat een software programeur te moeilijk aan het doen is met software terwijl daar een CPLD bij moet.

Ben nog altijd van plan om ooit iets een keer met een CLPD te gaan doen maar hoe en waar begen je dan.

Als ik zo naar je stuk software kijk dan zie het er haast makkelijk uit.
Een aantal dingen herken ik wel van Arduino met C/C++. Niet dat het hetzelfde is maar het is wel te herkennen wat de blokken doen.

Voor mij een nogal spannende ontwikkeling. Ik heb wel al lange tijd de wens gehad om eens iets met CPLD's en/of FPGA's te gaan doen, maar het is er nooit van gekomen. Dit is wel een mooie nieuwe motivatie!
Ik zie nu ook meer mogelijkheid voor een optionele hard-copy functie (
Hameg HM8148 ?)

CPLD / FPGA is makkelijk ... als je de juist omgeving hebt !
Altera Quartus is gratis en je kan schematjes tekenen met TTL ic'tjes. Je kan ook Verilog / VHDL / systemverilog maken. En het kan schematjes omzetten naar verilog ! heel leuk om te leren hoe je iets maakt.

Als je daar mee weg wilt : Van 0 en 1 tot FPGA (shameless plug )

20 jaar geleden was al dat spul peperduur ne had je dongles nodig (byteblaster). nog vroeger was die software niet gratis... en de devices zelf zeer duur.

Nu heb je al een dikke cpld voor 5$ ... en ze programmeren met een simpele ftdi uart/mpsse chip. De software is gratis en heeft schema , hdl en simulator aan boord (toch die van Altera. Lattice is nog steeds een kreng en zielinks ligt ook nog beter links )

[Bericht gewijzigd door free_electron op zaterdag 8 november 2025 20:15:47 (30%)]

Zo'n 27 jaar geleden heb ik op de HTS wel kennis gemaakt met het fenomeen FPGA, maar dat was programmeren in VHDL en dat was voor mij eigenlijk meteen een dooddoener: VHDL vond ik toen te ingewikkeld (Hoewel ik wel alle opdrachten succesvol heb afgerond). Verilog schijnt veel begrijpelijker te zijn.

Misschien toch eerst maar eens beginnen bij het begin: PAL's/GAL's ?

ahh. very hard design language ... past gelijk een tang op een varken....

VHDL is een generic hardware language (je kan daar zelfs een vijs mee beschrijven) waar ze via een library logica kunnen mee beschrijven. Het is een "afterthought"

Verilog is iets wat van meet-af-aan gemaakt is om logica mee te beschrijven. het is flexibeler. zeker nu Verilog 2005 en systemverilog bestaan. Veel van het keyboard werk is verdwenen.

De vergelijking met c : je moet een header file maken om je functies foward te declareren. Dat is onnozel. De compiler moet dat zelf kunnen vinden. Die miserie bestond ook in verilog : je maakt een definitie met all in in en uitgangen , en dan moet je later gans die reutemeteut herhalen om het type te definieren (combinatorisch of register). Dat is allemaal extra tikwerk en het leidt tot "fauten" die je dan eerst moet corrigeren vooraleer het wil compileren.

Met systemverilog is dat allemaal weg. je schrijft het 1 keer. geen nood aan headers en dergelijke.

De Altera ide helpt je met autocomplete.

En als je leert hoe een synthesizer werkt en het princiepe van scheduling werkt dan is logic maken heel makkelijk , voorspelbaar en haast bullet proof (zonder verborgen of missing condities).

Scheduling is iets wat eigen is aan de standaard voor Verilog en VHDL, maar het wordt haast nergens duidelijk uitgelegd. De focus ligt altijd op een "software" benadering. Het is HARDWARE !

in kort : wat i scheduled logic ?

de standaarden van verilog en vhdl definieren dat "statements will be evaluated in the order they are written".

Voorbeeld :
x <= x+1;
blablabla..
if (reset) x<=0;

x telt altijd op.
Als reset hoog is (in systemverilog geen nood om te schrijven "reset ==1") : zet x op 0.

Aangezien dat laatste statement later komt , krijgt het voorrang. ( zie het zo : het staat laatst in de volgorde van instructies, dus dichter bij de uitgang. Dat is ook hoe de synthesizer werkt. dat eerste statement maakt een register (flipflops) aan, voert de uitgang terug naar een blok wat +1 doet. en van dat +1 blok gaan we terug naar dat register. dat tweede statement knipt die verbinding van dat +1 blok naar de registers door en zet daar een multiplexer. Dat reset signaal controleert de multiplexer. als reset nul is wordt het +1 blok aan de ingang van het register gehangen. Als reset 1 is hangen we de waarde '0' aan het register.

Er zijn geen onafgedekte paden in dergelijk systeem.

Voorbeeld : maak een teller met enable , up/down , reset en parallel load.

 reg [7:0] counter;   // maak een 8 bit register.


always @(posedge clk) begin  // wanneer we een clock krijgen :

if (updown) counter <=counter +1 else counter <= counter -1;  // we gaan op of neer afhankelijk van het updown signaal
if (!enable) counter <=counter  // als we niet enabled zijn tellen we niet.. we blijven de huidige waarde houden.
if (load) counter <= parallel_in // als we moeten laden : haal data op
if (reset) counter <=0; // reset heeft prioriteit (staat lager)

het eerste statement telt op / af onder controle van het updown signaal.
het tweede statement blokkeert het tellen als enable nul is ( ! enable). die eerste lijn mag staan dansen wat het wil , die teller verandert niet.
het derde statement kan de counter laden. ook al is de teller aan het dansen , of disabled : het register moet en zal laden.
en het laatste statement heeft het meeste macht : als die reset komt gaat die counter onverbiddelijk op nul.

Er is geen enkel nood aan if then else constructies. Er zijn geen ongedefinieerde paden. je hoeft dit zelfs niet te simuleren. Het zal werken.

Al die multiplexers and adders/subtractors zijn een grote wolk combinatorische logica. dat word ta llemaal gesimplifieerd naar wat and en or gates.
En dergelijke logica mapt nu eenmaal perfect op een cpld/fpga. Die is namelijk ook zo gebouwd : een bank flipflops met een enorme wolk and/or poorten ervoor.

Geen idee hoe je het doet, maar zoals jij het uitlegt, komt het als eenvoudig en duidelijk over! Ik krijg er zin in!

Waarschijnlijk is je boek op dezelfde wijze geschreven?

stap voor stap hoe de synthesizer dat uitwerkt.

een multiplexer is niks anders dan een simpele booleaanse vergelijking ((a & !control)+(b & control)).

Dus gans die logica wolk is niks anders dan domme AND en OR poorten wat inverters om te schakelen tussen a en b. Die formules worden lang maar de logic reducer (een super duper karnaugh kaart motor. egenlijk het Quine - McKlusky algorithme) perst dat samen.

Een adder en subtractor is ook niks anders dan wat AND en OR poorten. dus daar hoe je ook niet bang van te zijn. Voor elke tak is dat een karnaugh kaart van 5 x 4.

5 aan linkerkant:
+1
-1
counter
data_in
0

4 bovenaan:
updown
enable
load
reset

En je hebt dat voor elke flipflop, dus 8 keer.
Een CPLD lacht daar mee, een FPGA giert het uit.