Is Your Tape Dispenser Radioactive?

Do you have anything radioactive in your house? Most people will say no, but they are probably wrong. A host of things ranging from glow-in-the dark timepieces to smoke detectors have some amount of radioactivity. But as [Wheeler Scientific] points out, so do some old Scotch tape dispensers. You can watch the video, below.

The dispenser in question is the C-15 which was very common around offices, military bases, and homes for years. They were made up until the 1980s. You have to wonder why a tape dispenser would be radioactive, and [Wheeler] has the explanation.

When you pull tape from the dispenser, you don’t want the dispenser to slide around the desk, so it needs to be heavy. But no one wants to have a giant dispenser nor do you want to pay for one made from a dense metal. So the plastic dispenser contains a ballast to make it heavier. In the case of the C-15 that ballast is thorium-containing monazite sand. A vintage counter shows the radioactivity which isn’t much, of course, but still way less than the ordinary sand used in newer models. You can also see in the video that the material is paramagnetic.

Monazite used to be a primary source of lanthanides but getting rid of the thorium led to alternate sources in the 1960s although it is still used as an ore for thorium. We know some lenses are radioactive. If you want to search your home for radioactivity and you don’t have a Geiger counter, you don’t need much to build one.

Continue reading “Is Your Tape Dispenser Radioactive?” →

Short Circuit Tracer For A Buck

Almost every meter you find today will have a continuity tester. Connect the probes and it will beep if there is a short and won’t if there isn’t. But where is the short? That’s another problem when trying to measure a component that is connected to many other components. [Learn Electronics Repair] wanted to have a tool to find shorts on a board and wanted to build a tester that uses 4-wire resistance measurement to isolate the device under test without having to do surgery on the circuit. His $1 build appears in the video below.

The first part of the video talks about the theory behind resistance measurement with two and four wires. Let shows several diagrams, but he mentions that at one point he shows an incorrect schematic (at 12:03) instead of the early correct one (at 10:35) and mentions it, but if you are skimming the video, you might get confused.

Continue reading “Short Circuit Tracer For A Buck” →

Fumik: An Arduino Wall Drawing Robot Jellyfish

If you’ve ever wanted to build a large format plotter but didn’t have the floor space, maybe put it up against the wall and make it cute. That’s the idea behind Fumik, the wall-drawing robot. As you might expect, the little device is just a motion base with a pen. We hope there’s paper against the wall since not everyone wants computer-generated art on their drywall.

The maximum size is apparently 5 m wide by 3 m tall, plenty of room to express yourself. The controller is an Arduino Mega, and stepper motors with a CNC shield drive the whole assembly. Interestingly, the motor and electronics are all onboard the jellyfish itself, rather than the wall.

The device only holds one pen at a time, but you can draw with one color and then manually change the pen. The files on GitHub are good, but you’ll need to intuit some of the mechanics from the videos. However, since it uses off-the-shelf hardware, it should be pretty easy to figure it out. This looks like a cheap and cheerful wall plotter, and the results speak for themselves.

We have seen similar wall plotters. More than once, even.

Continue reading “Fumik: An Arduino Wall Drawing Robot Jellyfish” →

Reflow Hotplate Teardown Uncovers The Bare Minimum

[EEforEveryone] is trying to find a good hot plate for reflow soldering. After trying one cheap unit, he got another one. He was a bit underwhelmed. The grounding was suspect and the bed wasn’t totally flat. He tore it apart and was surprised that there was very little inside. While the construction wasn’t perfect, it was better than the previous unit. You can see a video of the teardown and review below.

Before powering it up, the first order of business was to rewire the ground system. After that, it was time to try it. However, by confusing Fahrenheit and Centigrade, he set the temperature much higher than necessary which creating a little smoke. Fixing the temperature helped, but there was still a bit of a smoky smell that eventually subsided.

The verdict? The hot plate worked well enough, but you probably do want to check the ground wiring before using it. That’s often a good idea where cheap equipment is concerned, anyway. But the real takeaway is that it looks like you could homebrew something equivalent without much trouble. The controller is an off-the-shelf module. A switch and a plug aren’t hard to figure out. The heating element could be a silicone heater or PCB heater meant for a 3D printer.

Of course, there are other options. You could use a wok. Or why not a waffle iron? You can also make a custom PCB.

Continue reading “Reflow Hotplate Teardown Uncovers The Bare Minimum” →

WebGPU… Better Than WebGL?

As the browser becomes more like an operating system, we are seeing more deep features being built into them. For example, you can now do a form of assembly language for the browser. Sophisticated graphics have been around using WebGL since around 2011, but some people find it hard to use. [Surma] was one of those people and tried a new method that is just surfacing to do the same thing: WebGPU.

[Surma] liked it better and shares a lot of information in the post and — oddly — the post doesn’t use WebGPU for graphics very much. Instead, the post focuses on using GPU cores for fast computation, something else you can do with WebGPU. If your goal is to draw on the screen, though, you need to know the basics and the post links to a site with examples of doing this.

Continue reading “WebGPU… Better Than WebGL?” →

Class A Amplifiers, Virtually

If you didn’t know better, you might think the phrase “class A amplifier” was a marketing term to help sell amplifiers. But it is, of course, actually a technical description of an amplifier that doesn’t distort the input waveform because it doesn’t depend on multiple elements to handle different areas of the input waveform. Want to know more? [FesZ] has a new video covering the basics of class A amplifiers including some great simulations. You can see the video below.

A class A amplifier uses a transistor that is always biased on. It never saturates or switches off. This is good for linearity, but not always the best for efficiency so there are other classes of amplifiers, too. However, for many applications, class A is the most common configuration.

There are a number of trade-offs involved with each type of amplifier and [FesZ] covers them in detail. But the real interesting part is the simulations in Spice. Sure, you can build the circuits and look at everything with a meter or scope, but using Spice is much handier.

There is a second video upcoming. We hope he covers other amplifier types too, as you really do want to understand the differences when you need to design something. If you want more Spice stuff, check out some of our previous posts. If for some reason, you don’t like LTSpice, there’s always Micro-Cap 12.

Continue reading “Class A Amplifiers, Virtually” →

Modern CPUs Are Smarter Than You Might Realize

When it comes to programming, most of us write code at a level of abstraction that could be for a computer from the 1960s. Input comes in, you process it, and you produce output. Sure, a call to strcpy might work better on a modern CPU than on an older one, but your basic algorithms are the same. But what if there were ways to define your programs that would work better on modern hardware? That’s what a pre-print book from [Sergey Slotin] answers.

As a simple example, consider the effects of branching on pipelining. Nearly all modern computers pipeline. That is, one instruction is fetching data while an older instruction is computing something, while an even older instruction is storing its results. The problem arises when you already have an instruction partially executed when you realize that an earlier instruction caused a branch to another part of your code. Now the pipeline has to be backed out and performance suffers while the pipeline refills. Anything that had an effect has to reverse and everything else needs to be discarded.

That’s bad for performance. Because of this, some CPUs try to predict if a branch is likely to occur or not and then speculatively fill the pipeline for the predicted case. However, you can structure your code, for example, so that it is more obvious how branching will occur or even, for some compilers, explicitly inform the compiler if the branch is likely or not.

As you might expect, techniques like this depend on your CPU and you’ll need to benchmark to show what’s really going on. The text is full of graphs of execution times and an analysis of the generated assembly code for x86 to explain the results. Even something you think is a pretty good algorithm — like binary search, for example, suffers on modern architectures and you can improve its performance with some tricks. Actually, it is interesting that the tricks work on GCC, but don’t make a difference on Clang. Again, you have to measure these things.

Probably 90% of us will never need to use any of the kind of optimization you’ll find in this book. But it is a marvelous book if you enjoy solving puzzles and analyzing complex details. Of course, if you need to squeeze those extra microseconds out of a loop or you are writing a library where performance is important, this might be just the book you are looking for. Although it doesn’t cover many different CPUs, the ideas and techniques will apply to many modern CPU architectures. You’ll just have to do the work to figure out how if you use a different CPU.

We’ve looked at pieces of this sort of thing before. Pipelining, for example. Sometimes, though, optimizing your algorithm isn’t as effective as just changing it for a better one.