Thermal Monocular Brings The Heat At 10X

[Project 326] is following up on his thermal microscope with a thermal telescope or, more precisely, a thermal monocular. In fact, many of the components and lenses in this project are the same as those in the microscope, so you could cannibalize that project for this one, if you wanted.

During the microscope project, [Project 326] noted that first-surface mirrors reflect IR as well as visible light. The plan was to make a Newtonian telescope for IR instead of light. While the resulting telescope worked with visible light, the diffraction limit prevented it from working for its intended purpose.

Continue reading “Thermal Monocular Brings The Heat At 10X”

Remembering Memory: EMS, And TSRs

You often hear that Bill Gates once proclaimed, “640 kB is enough for anyone,” but, apparently, that’s a myth — he never said it. On the other hand, early PCs did have that limit, and, at first, that limit was mostly theoretical.

After all, earlier computers often topped out at 64 kB or less, or — if you had some fancy bank switching — maybe 128 kB. It was hard to justify the cost, though. Before long, though, 640 kB became a limit, and the industry found workarounds. Mercifully, the need for these eventually evaporated, but for a number of years, they were a part of configuring and using a PC.

Why 640 kB?

The original IBM PC sported an Intel 8088 processor. This was essentially an 8086 16-bit processor with an 8-bit external data bus. This allowed for cheaper computers, but both chips had a strange memory addressing scheme and could access up to 1 MB of memory.

In fact, the 8088 instructions could only address 64 kB, very much like the old 8080 and Z80 computers. What made things different is that they included a number of 16-bit segment registers. This was almost like bank switching. The 1 MB space could be used 64 kB at a time on 16-byte boundaries.

So a full address was a 16-bit segment and a 16-bit offset. Segment 0x600D, offset 0xF00D would be written as 600D:F00D. Because each segment started 16-bytes after the previous one, 0000:0020, 0001:0010, and 0002:0000 were all the same memory location. Confused? Yeah, you aren’t the only one.

Continue reading “Remembering Memory: EMS, And TSRs”

The ZX Spectrum Logic Analyzer

We know [Happy Little Diodes] frequently works with logic analyzer projects. His recent wireless logic analyzer for the ZX Spectrum is one of the oddest ones we’ve seen in a while. The heart of the system is an RP2040, and there are two boards. One board interfaces with the computer, and another hosts the controller.

The logic analyzer core is powered by a common open-source analyzer from [Eldrgusman]. This is one of the nice things about open source tools. Most people probably don’t need a logic analyzer that plugs directly into a ZX Spectrum. But if you do, it is fairly simple to repurpose a more generic piece of code and rework the hardware, if necessary.

Continue reading “The ZX Spectrum Logic Analyzer”

Unwinding An Unusual Slide Rule

If the Otis King slide rule in [Chris Staecker’s] latest video looks a bit familiar, you might be getting up there in age, or you might remember seeing us talk about one in our collection. Actually, we have two floating around one of the Hackaday bunkers, and they are quite the conversation piece. You can watch the video below.

The device is often mistaken for a spyglass, but it is really a huge slide rule with the scale wrapped around in a rod-shaped form factor. The video says the scale is the same as a 30-inch scale, but we think it is closer to 66 inches.

Continue reading “Unwinding An Unusual Slide Rule”

Semiconductor Simulator Lets You Play IC Designer

For circuit simulation, we have always been enthralled with the Falstad simulator which is a simple, Spice-like simulator that runs in the browser. [Brandon] has a simulator, too, but it simulates semiconductor devices. With help from [Paul Falstad], that simulator also runs in the browser.

This simulator takes a little thinking and lets you build devices as you might on an IC die. The key is to use the drop-down that initially says “Interact” to select a tool. Then, the drop-down below lets you select what you are drawing, which can be a voltage source, metal, or various materials you find in semiconductor devices, like n-type or a dielectric.

It is a bit tricky, but if you check out the examples first (like this diode), it gets easier. The main page has many examples. You can even build up entire subsystems like a ring oscillator or a DRAM cell.

Designing at this level has its own quirks. For example, in the real world, you think of resistors as something you can use with great precision, and capacitors are often “sloppy.” On an IC substrate, resistors are often the sloppy component. While capacitor values might not be exact, it is very easy to get an extremely precise ratio of two capacitors because the plate size is tightly controlled. This leads to a different mindset than you are used to when designing with discrete components.

Of course, this is just a simulation, so everything can be perfect. If, for some reason, you don’t know about the Falstad simulator, check it out now.

What’s In A Washer?

Some things are so common you forget about them. How often do you think about an ordinary resistor, for example? Yet if you have a bad resistor, you’ll find it can be a big problem. Plus, how can you really understand electronics if you don’t know all the subtle details of a resistor? In the mechanical world, you could make the same arguments about the washer, and [New Mind] is ready to explain the history and the gory details of using washers in a recent video that you can see below.

The simple answer is that washers allow a bolt to fit in a hole otherwise too large, but that’s only a small part of the story. Technically, what you are really doing is distributing the load of a threaded fastener. However, washers can also act as spacers or springs. Some washers can lock, and some indicate various things like wear or preloading conditions.

Continue reading “What’s In A Washer?”

Simulating Cable TV

[Wrongdog Recons] suffers from a severe case of nostalgia. His earlier project simulated broadcast TV, and he was a little surprised at how popular the project was on GitHub. As people requested features, he realized that he could create a simulated cable box and emulate a 1990s-era cable TV system. Of course, you also needed a physical box, which turned into another project. You can see more about the project in the video below.

Inside is, unsurprisingly, a Raspberry Pi. Then you have to pretend to be a cable TV scheduler and organize your different video files for channels. You can interleave commercials and station breaks.

One addition was a scheduler so you could set up things like football games only play during football season. You can also control timing so you don’t get beer commercials during Saturday morning cartoons.

Continue reading “Simulating Cable TV”