Pretty Petite Picolibc Powers Processors

Many times when someone tells you that language X is “better” at something they really mean that it has better built-in libraries for that task. Java is a great example. The language isn’t all that different from C++ outside of garbage collection and multiple inheritance, but the standard libraries are super powerful, especially for networking.  Even C relies on a library to provide a lot of functions people think of as part of the language — printf, for example. That’s not really part of the C language, but just part of the standard library. When you are writing for a tiny processor, the choice of library is critical and [Keith Packard] offers you one choice: picolibc.

The library has its genesis from two other diminutive libraries: Newlib and the AVR version of libc. It provides support for ARC, ARM, i386, m68k, MIPS, MSP430, Nios II, PPC, RISC-V, Sparc64, x86_64, and the ESP8266/ESP32.

Continue reading “Pretty Petite Picolibc Powers Processors”

3D Printer Z Sensor Claims 0.01 Mm Resolution

Early 3D printers usually had a microswitch that let you know when the Z axis was at the zero point. There was usually an adjustment screw so you could tune for just the right layer height. But these days, you most often see some sort of sensor. There are inductive sensors that work with a metal bed and a few other styles, as well. However, the most common is the “BL touch” style sensor that drops a probe below the nozzle level, measures, and then retracts the probe. However, nearly all of these sensors work by detecting a certain height over the bed and that’s it.

A new probe called BDsensor is inductive but can read the height over the bed in real time. According to information from the developer, it achieves a resolution of 0.01 mm and a repeatability of +/- 0.005mm. We don’t know if that’s true or not, but being able to take real-time soundings of the nozzle height leads to some interesting possibilities such as real-time adjustments of Z height, as seen in the video below.

Continue reading “3D Printer Z Sensor Claims 0.01 Mm Resolution”

Oh Snap! 3D Printing Snapping Parts Without Breakage

One of the great things about plastic is that it can be relatively flexible. We see things all the time that snap together, but when 3D printing, you don’t often run into snap fit designs. [Engineers Grow] has a video to help you design snap fittings that don’t break.

In the first video that you can see below, he covers three parameters that can help. The first is the length of the snap element. Secondly, the undercut size can be reduced. You can also try making the snap; as thin as possible, although in the example he went too thin and wound up breaking the snap anyway.

The final suggestion, covered in detail in the second video below, is to change the material you use. The key parameter is known as elongation at break. For PLA the typical value for this is 8%. ABS is 10%, PETG is 24% and Nylon is 100%. Simplistically, you could assume that a PETG piece could deform up to 25% before breaking. That may be true, but it will permanently deform long before that. The video suggests using 10 or 15% of the value to assure the part doesn’t lose its shape.

In the third video, you’ll learn, too, that print orientation counts. Making the hooks grow off the build plate leads to a weak hook as you might expect.

We’ve looked at the mechanics behind these before. You can find a lot of detailed technical data about joints, too.

Continue reading “Oh Snap! 3D Printing Snapping Parts Without Breakage”

The Importance Of Physical Models: How Not To Shoot Yourself In The Foot Or Anywhere Else

We take shortcuts all the time with our physical models. We rarely consider that wire has any resistance, for example, or that batteries have a source impedance. That’s fine up until the point that it isn’t. Take the case of the Navy’s Grumman F11F Tiger aircraft. The supersonic aircraft was impressive, although it suffered from some fatal flaws. But it also has the distinction of being the first plane ever to shoot itself down.

So here’s the simple math. A plane traveling Mach 1 is moving about 1,200 km/h — the exact number depends on a few things like your altitude and the humidity. Let’s say about 333 m/s. Bullets from a 20 mm gun, on the other hand, move at more than 1000 m/second. So when the bullet leaves the plane it would take the plane over three seconds to catch up with it, by which time it has moved ever further away, right?

Continue reading “The Importance Of Physical Models: How Not To Shoot Yourself In The Foot Or Anywhere Else”

Old 6809 Computer Lives Again On Breadboards

Among old CPUs, the 6809 never got as much attention as some of its cousins. The Radio Shack CoCo used it and so did a construction article in Wireless World Magazine. Now [Dave] has reconstructed that computer on breadboards and it looks great. The files are on GitHub and there is even a series of videos about the machine. You can watch the first one below.

You can even read the original articles in the January 1981 Wireless World where the board used a 6802. The upgrade to a 6809 appears in the July 1981 issue. The magazine promised you could build the system for £100. Besides the 6809 there were only a few chips. A PROM, two RAM chips, A 6821 PIA, and a 74LS138 decoder for address selection. An MC1413 transistor array also allowed for a 7-segment display and a keypad along with a 7442 BCD decoder.

Continue reading “Old 6809 Computer Lives Again On Breadboards”

$1 POV Display Goes Round And Round

You don’t need much to do a persistence of vision display. A few LEDs and a processor is all it really takes. [B45i] made a simple PC board with five LEDs and an ATtiny CPU. There’s a battery and it connects to a fan to spin around.

While the project is pretty simple, we liked two aspects of it. First, he provides very detailed explanations about how to use an Arduino to program the Tiny using the Arduino IDE.

Continue reading “$1 POV Display Goes Round And Round”

Retrotechtacular: Programming By Card

The recent Supercon 6 badge, if you haven’t seen it, was an old-fashioned type computer with a blinky light front panel. It was reminiscent of an Altair 8800, a PDP-11, or DG Nova. However, even back in the day, only a few people really programmed a computer with switches. Typically, you might use the switches to toggle in a first-level bootloader that would then load a better bootloader from some kind of storage like magnetic or paper tape. Most people didn’t really use the switches.

What most people did do, however, was punch cards.  Technically, Hollerith cards, although we mostly just called them cards, punched cards, or IBM cards. There were a lot of different machines you could use to punch cards, but none were as popular, I would guess, as the IBM 029. Certainly, the models in the series were overwhelmingly what people used to punch cards.

For the uninitiated, a card was about the size of an old-fashioned dollar bill — the ones in style when Herman Hollerith invented them. The card was made of material not quite as thick as a standard file folder and was divided into 80 columns and 12 rows. Later cards had more columns, but those never really caught on to the same scale as the classic 80-column card. Continue reading “Retrotechtacular: Programming By Card”