HN Theater @HNTheaterMonth

Ben Eater has some videos showing the USB protocol on an oscilloscope.

https://www.youtube.com/watch?v=wdgULBpRoXk

https://www.youtube.com/watch?v=N0O5Uwc3C0o

And some videos on using chips and breadboards to meet protocols- https://www.youtube.com/watch?v=l7rce6IQDWs

And a digital protocol too- https://www.youtube.com/watch?v=MCi7dCBhVpQ

⬐ bri3d

With existing USB devices you don't usually need to go nearly this low level to reverse engineer them - just enumerating the endpoints and then using Wireshark and USB packet capture is plenty sufficient.

Understanding how the USB wire protocol works is definitely valuable knowledge in some arenas, but not at all important for the kind of reverse engineering task OP is trying to perform, as they can generally speaking trust the electrical layer is standard and only need to operate at a level above it.

Same for the "write 3 bytes to a USB device" hypothetical from upthread - electrical understanding of USB is interesting but ultimately unimportant if you're using an existing USB stack - higher level knowledge of USB endpoint types and transport mechanisms is the name of the game there.

If I were given this task and I had to produce a driver with source code (rather than just get things working), I'd start with a combination of USB sniffing and static decompilation (Ghidra/IDA) of the Canon binaries, followed by perhaps some dynamic analysis (logging shims) if things turned out very complex.

If I just had to get things working, I'd just use one of the many approaches to mix 32/64-bit userland binaries in order to shim the 32 bit Canon binaries into a 64-bit CUPS driver.

⬐ MerelyMortal

That was a very interesting, thank you for sharing.

⬐ asadhaider

Part two: https://www.youtube.com/watch?v=uqY3FMuMuRo

Schematics/kit: https://eater.net/vga (and more building)

Previous HN discussion: https://news.ycombinator.com/item?id=20375702

Ben Eater did it with breadboards: https://youtu.be/l7rce6IQDWs

Any Ben Eater videos really, but this is a good one.

Building a VGA video card

https://m.youtube.com/watch?v=l7rce6IQDWs

Ben Eater has a great video[1] about building a video card from simple gates and other basic components. It goes into some detail about how a VGA signal is generated.

[1]: https://www.youtube.com/watch?v=l7rce6IQDWs

⬐ amock

There's also https://odysee.com/@JamesSharman:b/introduction-vga-from-scr... by James Sharman that goes over the first steps of how he is adding VGA to his customer computer.

Even further to that end of the spectrum is "The World's Worst Graphics Card"[1] on a breadboard with mostly discrete logic. Fascinating.

[1] https://www.youtube.com/watch?v=l7rce6IQDWs&vl=en

To clarify further, Nvidia and AMD (and probably other small players like ARM, Quallcomm, Imagination) own the patents on core shader tech, which are the building blocks of any modern GPU design.

If you want to design a GPU IP that works around all their patents, you probably can, but unless you're a John Carmack x10, your resulting design would be horribly inefficient and not competitive enough to be worth the expensive silicon it will be etched on and probably not compatible to any modern API like Vulcan or DirectX.

But if you just want to build your own meme GPU for education/shits and giggles, that doesn't follow any patents or APIs, then you can and some people already did:

https://www.youtube.com/watch?v=l7rce6IQDWs

Reminds me of Ben Eater's Youtube videos where he builds everything using basic gates on a breadboard. He made a video-card using ICs on a breadboard that fascinated me: https://www.youtube.com/watch?v=l7rce6IQDWs

> Chips that didn't exist in 1978. The overall point you're making is that technology from several years later was better.

Not relevant. Years later, even the Apple IIc (1984) wasn't close to a C64, not to mention an Amiga.

The thing you're missing is, Commodore had purchased MOS Technology, just like Apple purchased PA Semi to make their own iPhone SoCs, and had spent years investing in custom silicon going back to the VIC in 1979. The Apple II did not have a "video chip". Wozniak had cobbled together a video chip out of a bunch of 74LS TTL chips. Here, learn to built one yourself: https://www.youtube.com/watch?v=l7rce6IQDWs

That's what I meant by "superior design". Commodore actually had integrated CMOS chips for video, audio, I/O, that they had designed in house and fabbed themselves. The Apple 2, well into the IIc days, was built like a semi-decent Arduino project. Even the Mac had gfx and DMA cobbled out of TTL chips.

⬐ simonh

>Not relevant.

OK, explain to me how technology released in 1982 and 1984, and the sales of products not yet released, are relevant to statements about the then current state of affairs in 1978? You know, the topic of this whole thread. Maybe that's what I'm not understanding. Please enlighten me.

⬐ jhbadger

And yet there's a reason why Woz is known to this day as a brilliant engineer. He basically did the impossible, designing color graphics and disk controllers without custom hardware. Obviously the design of a computer is much easier given custom chips.

⬐ cromwellian

I love Woz, but he did so, because of what he was given. Apple was raking in tens of millions from the Apple 2, why didn't they give Woz a team of chip designers for the follow on products? I mean, the Mac was launched similarly with TTL based logic "GPU", compared with the Commodore Amiga 1 year later which launched with 3 custom ASICs just like the C64.

⬐ quietbritishjim

I think maybe you have some interesting information that's buried in a very confusing presentation - at least that's my best guess of what's going on.

If you'd started your original comment with something like "Just a few years later, in 1984, Apple's new offering the IIc was barely any better than the original while C64 had a far superior (...) but Apples continued to sell better because of shallow marketing" it would've made it clear you were switching to a related but different subject. As it was, you seemed to just directly compare the original Apple against something much later. You don't seem to get why people keep making seemingly unrelated comments - it's because we're still applying your comments to the original Apple II, but you're actually not talking about that any more.

This one might be interesting to you: https://youtu.be/l7rce6IQDWs “The world’s worst video card?” Ben builds a framebuffer display device on a bread board from scratch, you’ll understand what every transistor does at a high level in an hour (don’t miss part 2).

That is abstractly what first principles graphics looked like some time ago - pixels were represented by a block of main memory, and the video system simply scanned that memory at the same frequency as the CRT monitor’s beam.

I’d say it’s pretty important to remember that what counts as “first principles” graphics has changed over time, and there was a time before frame buffers (the first Pong game was displayed on an oscilloscope) and the way we use framebuffers today is completely different - there is no more direct access to pixels in the same way old terminals used to work. The article here is detailing how we use a higher level API to draw higher level primitives, and the hardware takes care of the pixels.

I’d love to hear a little more about your goal... what’s driving you to study the old terminals?

Maybe something like Ben Eater's video card series?

https://youtu.be/l7rce6IQDWs

If i remember correctly he assembles a gfx card on a bread board. So its fairly fundamental

Not the same thing, but you reminded me of this since it's in a similar vein. Ben Eater went through the entire process of building a VGA "video card." Anyone with a basic understanding of logic circuits has enough background to understand it. Worth a watch. Part 1: https://www.youtube.com/watch?v=l7rce6IQDWs Part 2: https://www.youtube.com/watch?v=uqY3FMuMuRo

I'm actually more excited to see a new Ben Eater video on youtube than anything else.

His stuff is just fantastic. Even though it's lower level than I've ever worked, it's extremely entertaining and educational.

His 6502 series is just great, but I want to highlight another couple of videos he did:

"Let's build a circuit that displays an image on a VGA monitor! In this video, I talk about how VGA signals work and build a circuit that provides the correct timing of sync signals so that a monitor recognizes the signal."

https://www.youtube.com/watch?v=l7rce6IQDWs

⬐ aidos

Thanks for posting. That‘s wonderful.

⬐ ravedave5

His video series was very enlightening. Seeing absolute lowest level how that stuff is done is a wonderful insight into why stuff is the way it is today.

Ben Eater did a video on driving a VGA display using a breaboard circuit. He builds up to it in his usual amazing teaching style, highly recommend:

https://youtu.be/l7rce6IQDWs

⬐ Lowkeyloki

Depending on the definition of the word "image" in this context, I'd love to see people play the electronics component version of code golf to see what the fewest number of basic components would be required to put an "image" on a screen. No SOACs allowed.

⬐ rasz

You can get this to display "image" by just adding one wire between clock source and one/all of VGA analog inputs. It will be a random checkerboard, but still an image.

⬐ benj111

Isn't 'random checkerboard' an oxymoron?

Or do you mean the top left square is randomly black/white?

⬐ abdullahkhalids

He meant to say that each pixel will be randomly black or white. What will really happen is that the color choice for each pixel will not be random, but can actually be predicted by the various clock frequencies he used.

⬐ forgotmypw3

Let's just cut out the middle and build the minimum required board to project an image onto a retina. Or a signal into optic nerve ))

⬐ Cheyana

Nah, let’s cut that out too and go even further: https://www.independent.co.uk/news/science/blindness-cure-br...

⬐ jacquesm

> Or a signal into optic nerve ))

That you can do with a single LED.

⬐ makapuf

Id try with a led illuminating the back of a pcb ? Still, nice project. The code golf fewest components to display a face is tempting ...

⬐ nitrogen

Laser, spinning mirror, and a mask to draw a mouth at the bottom and two eyelids at the top.

⬐ atum47

I've been following ben eater for about 2 years now. I've learned so much from his well explained well illustrated videos. Right now it's kinda hard for me to get my hands on every component he uses, but soon I'll take a shot at building a 8 bit computer as well. I'll may start with a full adder built with transistors only.

⬐ dreamcompiler

That's gonna take a lot of transistors. I suggest doing it with gates instead. Using transistors is like programming a computer with machine language; using gates is more like a good macro assembler.

Building yourself one NAND gate with transistors and resistors would be a valuable learning experience, but building 100 of them won't teach you anything new.

⬐ atum47

I see, I just think it will be cool to have one on my desk. Take a look a this video (https://www.youtube.com/watch?v=xISG4nGTQYE) I got the idea from it.

⬐ dreamcompiler

I agree the end result would be cool. I just wouldn't have the attention span for that much low-level dinking :-)

⬐ eatonphil

Yes that's hard to debate. But if you want to get the experience without the physical complexity you can always build an 8-bit computer in a simulator like they do in many college courses. I used Logisim [0] at college for this following the Harris and Harris [1] textbook and it was a straightforward experience.

[0] http://www.cburch.com/logisim/

[1] https://www.goodreads.com/author/show/13816512.David_Money_H...

⬐ lnsru

Hi, I don’t know your background, but why are you not building your 8 bit computer in FPGA? There are many nice cheap boards like MAX1000 from Arrow or Lattice. It’s really cool learning project! Transistor only design will have many problems: transistors are bigger than you think and small ones in VML0806 package are almost impossible to solder by hand.

⬐ atum47

I'm a software engineer undergrad, I do most high level stuff. I took digital circuits on college, cause I like electronics. One day watching videos on YouTube I saw ben eater project and loved it. I thinker with Arduino and Raspberry pi, but never built anything cool like that. I just want to give it a try, I guess

⬐ tyingq

Somewhat related, here's a video card for a MAC SE done with a BeagleBone and it's microcontroller like PRU secondary processors: https://trmm.net/Mac-SE_video

⬐ TheRealPomax

Why isn't this titled "let's build a video card [youtube]"?

⬐ mepian

Because it's not a video card yet, it's a circuit that syncs the monitor.

⬐ peter_d_sherman

Designing a VGA card precursor on breadboards -- Brilliant!

Should be the very first video any would-be VGA card designer views... (I want to design one in the future...)

⬐ rkagerer

Am I the only one frustrated with how difficult YouTube makes it to find Part 2? Am I missing something obvious?

⬐ xorfish

Part 2 isn't out yet

⬐ rkagerer

Thanks. It took way too long for me to figure that out :-).

⬐ glouwbug

Why not with an AVR? https://youtu.be/sNCqrylNY-0

⬐ exar0815

I can only recommend the "Veronica"-Series of Quinn Dunki, where she builds a complete graphics card for her 8-Bit-computer, as well as the computer itself

http://quinndunki.com/blondihacks/?page_id=1761

⬐ jaak

Not to take away from Quinn Dunki's accomplishments, one big difference is the Veronica used an ATmega 324PA - basically an 8 bit 20 MIPS RISC CPU.

Generating a VGA signal is trivial for this powerful chip. Entire retro game consoles have been built with similar ATmega chips alone

Ben Eater is building a VGA card from discrete components, a somewhat more difficult task. The first part covers building the H/V timing sync circuit (no programmable clock source here!). It's worth taking a look if you're into this kind of thing.

⬐ userbinator

Generating a VGA signal is trivial for this powerful chip. Entire retro game consoles have been built with similar ATmega chips alone

For comparison, a slightly less powerful microcontroller can do this:

https://www.linusakesson.net/scene/craft/

⬐ mrob

>Ben Eater is building a VGA card from discrete components

From 7400 series devices, which are very simple integrated circuits by modern standards, but still integrated circuits.

⬐ deaddodo

To be fair, it's almost impossible to build anything out of fully discrete components these days. If you use a TO series transistor, you could argue those are also ICs and vacuum tubes/relays aren't cheap or too easily accessible.

⬐ lopmotr

Transistors in individual packages are called discrete components. Even if they use the same technology as ICs, they're still discrete. You can certainly build useful analog and power circuits with only discrete components. Somebody even made a CPU from them [1] which was a much bigger circuit than TFA's IC video card will be so it's worth distinguishing truly discrete from simple ICs.

[1] https://monster6502.com/

⬐ deelowe

"Hold my beer" - https://monster6502.com/

⬐ mrob

Chip photography site zeptobars.com has some photographs of modern transistors, and while some have interesting geometry, I didn't see anything that I'd consider an integrated circuit, i.e. something that would be drawn as more than a single transistor symbol on a schematic.

https://zeptobars.com/en/read/NXP-PMST3904-NPN-BJT

https://zeptobars.com/en/read/NXP-MMBT3904-npn-bjt

https://zeptobars.com/en/read/NXP-2N7002-TrenchMOS-N-Channel...

There are some "discrete" transistors with built-in ESD protection, e.g. NCV8440A, but those are unusual, and under normal operating conditions they work just like a normal transistor so I'd still count them as discrete components.

⬐ h2odragon

Similar to the difference between asm (discrete), C (low level logic ICs), and Python (ATmega).

⬐ tyingq

"From 7400 series devices, which are very simple integrated circuits by modern standards"

So it's clear, a 74xx is just a bunch of NAND gates. Nothing at all higher level than that.

⬐ mrob

Although NAND gates are universal gates (any combinatorial boolean logic function can be built from nothing but NAND gates), in practice it's usually more space efficient to use a mixture of different gates.

⬐ dreamcompiler

And usually more power-efficient and faster in execution speed.

⬐ yitchelle

Among my group of SW engineering circle, we had a running joke that software is a series of 1s and 0s, it is the sequence that is important.

⬐ metaphor

Except they're not. He's using 74161 counters; that's a MSI device, not just primitive combinatorial logic and flip flops.

⬐ pas

Counters are a series of flip-flops anyway, right? And a few latches for reset and load.

https://easyeda.com/normal/74161X2-4qkCwOIZh.png

⬐ tyingq

Ahh, good catch. I was distracted with the 7400 description. Though a 4 bit counter isn't terribly high level either.

⬐ kazen44

Also, his video makes it seem rather easy aswell. The scanline circuitry is quite simple.

⬐ prvc

>Also, his video makes it seem rather easy aswell. The scanline circuitry is quite simple.

Making it seem easy != easy

⬐ amelius

Generating a completely given digital signal should be easy, no?

⬐ dotancohen

Even more amazing, after watching Ben's video, I was thinking too myself "That wasn't so hard". Other than a few Arduino projects I've never used an IC, but I was able to follow along with Ben completely.

In fact, I think that a tutorial dedicated just to explain the VGA standard, the same length as Ben's tutorial, would have been less clear and informative.