Hackaday
Tiny Linux on a No-MMU RISC-V Microcontroller

https://hackaday.com/wp-content/uploads/2023/04/risc5-esp32-c3-thumbnail.jpg?w=800
In the vast majority of cases, running a Linux-based operating system involves a pretty powerful processor with a lot of memory on hand, and perhaps most importantly, a memory management unit, or MMU. This is a piece of hardware which manages virtual memory, seamlessly giving each process its own memory sandbox in which it shouldn’t be able to rain on its neighbours’ parade. If there’s no MMU all is not lost though, and [Uros Popovic] gives us a complete guide to building the MMU-less μClinux on a RISC-V microcontroller.

The result is something of a Linux-from-scratch for this platform and kernel flavour, but it’s so much more than that aside from its step-by-step explanation. It’s probable that most of us have heard something of μClinux but have little direct knowledge of it, and he leads us through its workings as well as its limitations. As examples, standard ELF binaries aren’t suitable for these systems, and programmers need to use memory-safe techniques.

Whether or not any of you will run with this guide and build a tiny MMU-less Linux system, anything which expands our knowledge on the subject has to be a good thing. it’s not the first time we’ve seen a RISC-V microcontroller turned to this task, with a nifty trick to get round the limitations of a particular architecture.

➖ @hardwareHack ➖

es and folders we want to map into the Docker image, and what ports to expose. For Mosquitto, we just need the configuration file and a pair of ports for sending MQTT data.
services:
mosquitto:
image: eclipse-mosquitto
volumes:
- /etc/owntracks-meshtastic/mosquitto:/mosquitto/config
ports:
- 1883:1883
- 9001:9001 https://hackaday.com/wp-content/uploads/2023/09/mqtt_explorer.png?w=400 Once that file is saved, we start a test-run by running a simple "docker-compose up". This should download the Mosquitto docker image and start it up. Then we can use a simple client like MQTT Explorer to make sure that we’re actually running. If your OS has any firewalls in place, this is the time to add an MQTT exception to the firewall. Once you’re ready to go back to working on configuration, use Ctrl+c and run "docker-compose down" First Real Data

We have enough of our system in place to start sending some real data. For this we need a Meshtastic node to work as a base station. This will need to be a device that can connect to the network, likely over wifi. There are several great options, like a Heltec LoRa32 v3, the Lilygo T-Beam (ideally the one with the SX1262 LoRa chip), or the Station G1 for the increased transmit power. Regardless of which device we choose, we need to connect it to wifi to enable communication with our new MQTT service.

That’s most easily done through the Android or iOS app, through radio configuration, network, and setting the WiFi SSID and PSK. Then it’s on to MQTT Config, to turn on “MQTT Enabled”. Set the “MQTT Server Address” to the machine running Mosquitto, blank out “MQTT Username” and “MQTT Password”, and finally turn on “JSON output enabled”. The device will reboot, and should start sending data to the MQTT server. In MQTT Explorer, we’re looking for the “msh” topic.

Once that’s flowing, it’s time to add the next step, Meshtastic-bridge. We’ll start with creating the config file, "sudo nano /etc/owntracks-meshtastic/config.yaml". We need to inform Meshtastic-bridge which server to use, and then set up a pipeline to convert the Meshtastic data to the MQTT format that Owntracks expects. You’ll need to update the server IP and populate the tid_table with your Meshtastic node IDs, which can be found using "meshtastic --nodes".
mqtt_servers:
- name: external
server: YOURSERVERIP
port: 1883
topic: msh/2/json/#
pipelines:
owntrack:
- owntracks_plugin:
log_level: debug
server_name: external
tid_table:
"!a56f7c45": ["Meshenger", "MS"]
Next we’re going to clone the meshtastic-bridge repository right into this folder, using "sudo git clone https://github.com/jp-bennett/meshtastic-bridge". From there we add another service to our docker-compose.yml file to build a Docker image from that repository. We also pass our config file through as a Docker volume. Again use "sudo nano /etc/owntracks-meshtastic/docker-compose.yml":
services:
mosquitto:
image: eclipse-mosquitto
volumes:
- /etc/owntracks-meshtastic/mosquitto:/mosquitto/config
ports:
- 1883:1883
- 9001:9001
meshtastic-bridge:
build:
context: /etc/owntracks-meshtastic/meshtastic-bridge
dockerfile: Dockerfile
volumes:
- /etc/owntracks-meshtastic/config.yaml:/code/config.yaml Map it!

Believe it or not, we’re nearly done. Up next is adding the Owntracks-recorder Docker image to our compose file. First, we need to create a data directory, using "sudo mkdir store". Then it’s just a matter of adding the owntracks-recorder service to our docker-compose.yml and updating the IP address to our server IP again. Once again, use "sudo nano /etc/owntracks-meshtastic/docker-compose.yml"
services:
mosquitto:
image: eclipse-mosquitto
volumes:
- /etc/owntracks-meshtastic/mosquitto:/mosquitto/config
ports:
- 1883:1883
- 9001:9001
meshtastic-bridge:
build:
conte[...]

xt: /etc/owntracks-meshtastic/meshtastic-bridge
dockerfile: Dockerfile
volumes:
- /etc/owntracks-meshtastic/config.yaml:/code/config.yaml
owntracks-recorder:
image: owntracks/recorder
volumes:
- /etc/owntracks-meshtastic/store:/store
ports:
- 8083:8083
environment:
- OTR_HOST=YOURSEVERIP
From there, you should be able to pull up your owntracks instance at "http://YOURSERVERADDRESS:8083". Once your Meshtastic node broadcasts a location, it should show up in the table of known nodes, and be visible on the map. Now as cool as this is, you may notice that it’s a bit bare-bones. https://hackaday.com/wp-content/uploads/2023/09/owntracks-e1695784656899.png?w=400 There’s one more piece to wire in, and that’s the Owntracks-frontend interface. This is the fancy single-page site that shows location history, heat maps, and more. And it’s pretty easy to add to our setup. Just add it to the bottom of your docker-compose.yml using "sudo nano /etc/owntracks-meshtastic/docker-compose.yml", making the final file look like this:
services:
mosquitto:
image: eclipse-mosquitto
volumes:
- /etc/owntracks-meshtastic/mosquitto:/mosquitto/config
ports:
- 1883:1883
- 9001:9001
meshtastic-bridge:
build:
context: /etc/owntracks-meshtastic/meshtastic-bridge
dockerfile: Dockerfile
volumes:
- /etc/owntracks-meshtastic/config.yaml:/code/config.yaml
owntracks-recorder:
image: owntracks/recorder
volumes:
- /etc/owntracks-meshtastic/store:/store
ports:
- 8083:8083
environment:
- OTR_HOST=YOURSEVERIP
owntracks-frontend:
image: owntracks/frontend
ports:
- 80:80
environment:
- SERVER_HOST=YOURSEVERIP
- SERVER_PORT=8083
And that’s it! Run "docker-compose up -d" to start your miniature swarm of docker instances, and watch your Meshtastic devices populate the map with live data! No dependency on Internet, no sending your location data to Google, it’s just open source data collection goodness. And if you want some added goodies, there is an Owntracks mobile app that can connect directly to your own backend. That app pushes and pulls live location data, ideally over a VPN for security.

Now you may want to set this to run automatically, and there’s a systemd service for that. You’ll just need to save the following with "sudo nano /etc/systemd/system/docker-compose-owntracks.service":
# /etc/systemd/system/docker-compose-owntracks.service
# https://stackoverflow.com/questions/43671482/how-to-run-docker-compose-up-d-at-system-start-up

[Unit]
Description=Docker Compose Owntracks Service
Requires=docker.service
After=docker.service
StartLimitIntervalSec=60

[Service]
WorkingDirectory=/etc/owntracks-meshtastic
ExecStart=/docker-compose up
ExecStop=docker-compose down
TimeoutStartSec=0
Restart=on-failure
StartLimitBurst=3

[Install]
WantedBy=multi-user.target
With that in place, you can use "sudo systemctl enable docker-compose-owntracks --now" to start and enable the whole service.

Now that’s a lot of work. So as promised, we have a quicker way to do it. The whole thing is available as a single repository. All that needs to be done after running the following command is to change the server IP, fill out the tid-table, and deploy the "systemd" service file. "sudo git clone https://github.com/jp-bennett/owntracks-meshtastic --recurse-submodules /etc/owntracks-meshtastic/"

That’s Meshtastic, MQTT, and Owntracks all rolled up into your own location tracking service. Let us know if you follow the instructions and set this up for yourself. And look forward to the third part in this series, how to use Meshtastic to extend your projects with a wireless, encrypted serial connection.

➖ @hardwareHack ➖

Hackaday
Tech in Plain Sight: Skyscrapers

https://hackaday.com/wp-content/uploads/2023/10/skyscrapers-and-cranes-featured-1.jpg?w=800
It is hard to imagine that for thousands of years, the Great Pyramid of Giza was the tallest manmade structure in the world. However, like the Lincoln Cathedral and the Washington Monument, which also held that title, these don’t count as skyscrapers because they didn’t provide living or working space to people. But aside from providing living, retail, or office space, skyscrapers also share a common feature that explains why they are even possible: steel frame construction.

Have you ever wondered why pyramids appear in so many ancient civilizations? The answer is engineering. You build something. Then, you build something on top of it. Then you repeat. It just makes sense. But each upper layer adds weight to all the lower layers, so you must keep getting smaller. Building a 381-meter skyscraper like the Empire State Building using self-supporting walls would mean the ground floor walls would be massive. Steel lets you get around this. In Antiquity

You might think of high-rise buildings as a modern thing, but that’s actually not true. People seem to have built up to the best of their abilities for a very long time. Some Roman structures were as high as ten stories. Romans built so high that Augustus even tried to limit building height to 25 meters — probably after some accidents.  In the 12th century, Bologna had as many as 100 towers, one nearly 100 meters tall.

There are many other examples, including mudbrick structures rising 30 meters in Yemen and 11th-century Egyptian structures rising 14 stories. In some cases, building up was due to the cost or availability of property. In others, it was to stay inside a defensive wall. But whatever the reason, self-supporting walls can only go so high before they are impractical.

So steel and iron frames grabbed the public’s attention with things like Joseph Paxton’s Crystal Palace in 1851, and Gustav Eiffel’s Tower in 1887. Steel Frames https://hackaday.com/wp-content/uploads/2023/10/flax.png?w=250 Google Street View of the Shrewsbury Flax Mill.
Exactly where the first modern skyscraper appears is a topic of hot debate, if you are a skyscraper enthusiast, and a steel frame alone is probably not sufficient. One candidate is the 1797 Flaxmill in Shrewsbury, England. It was only partially iron-framed, but was a hint of what was to come. However, at five stories, it wasn’t what we’d consider a skyscraper. Besides, the iron frame was more to prevent fires in the mill, not to hold a tall structure.

Another early sort of skyscraper showed up in Liverpool in 1864. Oriel Chambers wasn’t particularly tall, at five stories, but it did use a steel frame and, because the walls were not bearing load, it contained many windows. Critics reacted negatively to all the glass, but the future would prove that glass “curtain walls” would be a very successful design. Other Considerations

Just building a tall structure is only part of the problem with making a successful skyscraper. One thing you really need is an elevator. Otis created the safety elevator in 1857, although passenger elevators would wait until 1870. You also need a way to handle water and a plan for fire safety.

Even with steel frames, going taller means thicker metal columns. By the 1960s, a Bangladeshi engineer, Fazlur Rahman Khan, replaced many large interior columns with smaller steel and concrete columns, forming a tube-like structure. This requires less material and improves strength. For example, the Willis Tower (what used to be the Sears Tower) uses about 66% of the steel the Empire State Building uses but is higher by more than 60 meters.

The other issues that arise are from external forces. Wind pushing against a lot of surface area has more force than you think, so some skyscrapers have air gaps to reduce load[...]

Hackaday
How Not to Build an RP2040 Board

https://hackaday.com/wp-content/uploads/2023/10/scale.png?w=800
We love that these days you can buy ready-made microcontroller boards that are very capable. But sometimes you need to — or just want to — do it yourself. Unfortunately, you really should design everything twice: once to figure out where all the problems are, and the second time to do it better. If you want to create your own board for the RP2040 then you are in luck. [Jeremy] has made the first (and second) iteration or an RP2040 board and shares with us what he would not do again.

In all fairness, he also has a blog post talking about what he did, so you might want to start there. However, we think his most valuable advice was his final word: Don’t fail to get started on your design. The longest journey, after all, begins with the first step.

His other advice is good, too. For example, don’t plug your new board into a computer because an error in the power supply could take the whole computer out. He also warns you not to do like he did and forget to order the $10 solder stencil with the PCBs.

Some of it is just good advice in general. For example — buy more small components than you think you need. There’s nothing worse than needing three resistors, having three resistors, and then watching one of the three fly across the room or stick to your soldering iron and melt into a pool of slag. Buy ten and you’ll save money in the long run.

In the end, the board did work and what he learned might help you if you decide to tackle a similar project yourself. [Jeremy’s] board is fairly large, but if you have an appetite for something smaller, check out the RPDot or the RP2040 Stamp.

➖ @hardwareHack ➖

ing. Tiny vibrations at the bottom of the tower can cause large movement at the top, too, so some buildings include mass dampers to reduce swaying.

Dr. Ed Glaeser of Harvard University argues that you couldn’t have skyscrapers without cheap, high-quality metal from industrial advances tied to the steam engines and elevators. He also argues that there isn’t a single creator of the skyscraper, but rather, they are a collaboration of very smart people working to solve a problem. So, The First?

Because “skyscraper” is not a precise term, there’s some debate over what was really the first one. The Home Insurance Building in Chicago is one vote. In 1885, it was a record-setting 42 meters tall. However, some would argue that Manhattan’s Equitable Life Building from 1870 should hold the title. It did have the first commercial passenger elevator and weighed in with nine floors. It was around 40 meters in height. Others argue for the 1889 Tower Building in Manhattan. https://hackaday.com/wp-content/uploads/2023/10/el.jpg?w=195 https://hackaday.com/wp-content/uploads/2023/10/home.jpg?w=188 https://hackaday.com/wp-content/uploads/2023/10/tower.png?w=250 The Tower Building had 11 floors, and the bottom seven were iron framed. It was built from necessity. The available lot on Lower Broadway was only six and a half meters wide. Slender buildings — that is, ones that have a small base-to-length ratio — require special consideration. Skyscrapers Today

Depending on how you define skyscrapers, there are many cities today that boast a skyline full of them. There are 14 cities in the world that have more than 100 buildings taller than 150 meters. Hong Kong leads, and New York City is in third place. The only other US city on the list is where the skyscraper largely originated: Chicago. It is, however, 11 places behind New York. However, many other cities have a respectable number of tall buildings, and there are more built every day.

The tallest in the world, at the moment, is the Burj Khalifa in Dubai, standing at 828 meters. That’s nearly twice the size of the old Sears Tower, the tallest building in the world for many years. Of course, you have to be careful when making comparisons. Some skyscrapers have a “vanity” height because they claim some piece of structure that isn’t really part of the building. For example, the Empire State Building has a 61-meter tall airship mooring that — outside of being used by King Kong — was probably only put there to get taller than the Chrysler Building. That picture of the airship Los Angeles docked there in 1930? Fake, as you can see in the Wall Street Journal video below. Guess you didn’t need PhotoShop to doctor up a picture in 1930. The Goodyear blimp Columbia did manage to lower some newspapers to the top of the building once but could not repeat the feat due to the winds always blowing around the building.
Usually, when we talk about architecture here, we talk about a CPU. But not always. Skyscrapers are a great example of how human design visions sometimes have to wait for engineering to catch up.

➖ @hardwareHack ➖

Hackaday
Micromanipulator Touches The Tiny Things, Cheaply

https://hackaday.com/wp-content/uploads/2023/10/micromanipulator.png?w=800
Some things are small and fragile enough that they cannot be held or touched by even the steadiest of hands. Such cases call for a micromanipulator, and [BYU CMR]’s DIY micromanipulator design can be 3D printed and assembled with the help of some common hardware, and a little CA glue.

You may recall an ultra-tiny Nerf-like blaster recently; clearly such a tiny mechanical device cannot be handled directly, yet needed to be loaded and have its trigger pressed. A micromanipulator is exactly the tool for such a job. This design is in fact the very same one used to move and manipulate that tiny blaster at a microscopic level.

The design doesn’t include any end effectors — those depend on one’s application — but there is a mount point for them and the manipulator can effectively move it in X, Y, and Z axes by turning three different knobs. In addition, because the structural parts can be 3D printed and the hardware is just some common nuts and screws, it’s remarkably economical which is always a welcome thing for a workshop.

➖ @hardwareHack ➖

Hackaday
Tattoo-Removal Laser Brought Out of Retirement for a Megawatt of Fun

https://hackaday.com/wp-content/uploads/2023/10/pew-pew.png?w=800
We’ve got to say that [Les Wright] has the most fun on the internet, at least in terms of megawatts per dollar. Just look at his new video where he turns a $30 eBay tattoo-removal laser into a benchtop beast.

The junk laser in question is a neodymium:YAG pulse laser that clearly has seen better days, both externally and internally. The original pistol-grip enclosure was essentially falling apart, but was superfluous to [Les]’ plans for the laser. Things were better inside the business end of the gun, at least in terms of having all the pieces in place, but the teardown still revealed issues. Chief among these was the gunk and grunge that had accumulated on the laser rod and the flash tube — [Les] blamed this on the previous owner’s use of tap water for cooling rather than deionized water. It was nothing a little elbow grease couldn’t take care of, though. Especially since the rest of the laser bits seemed in good shape, including the chromium:YAG Q-switch, which allows the lasing medium to build up a huge pulse of photons before releasing them in one gigantic pulse.

Cleaned up and with a few special modifications of his own, including a custom high-voltage power supply, [Les]’ laser was ready for tests. The results are impressive; peak optical power is just over a megawatt, which is enough power to have some real fun. We’ll be keen to see what he does with this laser — maybe blasting apart a CCD camera?

➖ @hardwareHack ➖

Hackaday
A Buzzing, Flashing Phone Ringer For the Elderly

https://hackaday.com/wp-content/uploads/2023/10/phone-ringer-800.jpg?w=800
For a lonely person, elderly or otherwise, the sound of a ringing phone can be music to the ears, unless of course it’s another spam call. But what good is a phone when you can’t hear it well enough to answer?

https://hackaday.com/wp-content/uploads/2023/10/phone-ringer-inner.jpg?w=400 [Giovanni Aggiustatutto] was tasked with building an additional ringer for a set of cordless landline phones belonging to an elderly friend. Rather than try to intercept the signal, [Giovanni] chose to simply mic up the phone base that’s connected to the phone port on the router and send a signal over Wi-Fi to a second box which has a loud piezo buzzer and a handful of LEDs.

At the heart of this build is a pair of ESP8266 Wemos D1 minis and an Arduino sound sensor module inside a pair of really nice-looking 3D printed boxen that may or may not have been inspired by an IKEA air quality sensor. On the receiving side, a green LED indicates the system is working, and the red LEDs flash as soon as a call comes in.

All the code, schematics, and STL files are available for this build, and between the Instructable and the build video after the break, you should have no trouble replicating it for the hard-of-hearing in your life.

➖ @hardwareHack ➖

Hackaday
The Wirtz Pump Spins

https://hackaday.com/wp-content/uploads/2023/10/pump.png?w=800
Over the ages, a lot of human activity has been concerned about getting water from where we find it to where we want it. If you want to move water to a lower elevation, there’s no problem. But if you want to move water up, you need a pump. The ancients used what we call Archimedes’ screw to raise water. But a Wirtz pump as [Steve Mould] shows in the video below, is another kind of spiral pump that is also very old and uses the same basic principle as the screw pump.

In a way, the Wirtz is just an Archimedes’ screw in cross-section. Part of what makes it work, however, is air-locking. [Steve] made a small model but found it didn’t work exactly as he expected. Of course, investigating that led to some interesting observations.
To solve the problem, a field trip to see a huge working Wirtz pump was in order. As it turns out, the size of the water channel is a balance. It can’t be too small or too large. Surface tension plays a part, as does the transport of trapped air through the system.

[Steve] learned some lessons and made another pump that — while not as stylish — worked much better. We couldn’t help but think this would be easy to put together post-apocalypse, so probably a good thing to have in your bag of tricks.

If you have electricity and motors, of course, it is easy. You can even 3D print a centrifugal pump.

➖ @hardwareHack ➖

Hackaday
Nifty MIG Welder Built From Scrap

https://hackaday.com/wp-content/uploads/2023/10/This-homemade-welding-machine-will-surprise-you-14-42-screenshot-1.png?w=800
A MIG welder is a great tool to have. With machine fed wire and gas protecting the arc, it can make it easy to weld well without requiring a lot of manual skill from the operator. [PROFESSOR PARDAL BRASIL] decided to build his own MIG welder using scrap parts, and it’s an inspiring bit of work.

The build is along the lines of so many YouTube contraptions, using bits and pieces thrown together in oddball ways. A windscreen wiper motor is used to create a wire feeder, with jammed-up ball bearings acting as rollers. Speed control of the wiper motor appears to be via a variable resistor created by moving two plates closer together in a bath of salt water. This enables the wire feed rate to be easily controlled, albeit in a wet and messy fashion. The build includes a device for producing carbon dioxide for use as shielding gas, too. This is achieved by mixing a solution of water and bicarbonate soda with vinegar, and then pumping the resulting carbon dioxide into an inner tube for storage. The power supply for actually creating an arc comes courtesy of car batteries.

The resulting welder is janky as all heck, but it does successfully weld some steel plates together. Job done, as they say. Video after the break.
Thanks to [Danjovic] for the tip!

➖ @hardwareHack ➖

Hackaday
Error-Correcting RAM on the Desktop

https://hackaday.com/wp-content/uploads/2023/10/memory-main.jpg?w=800
When running a server, especially one with mission-critical applications, it’s common practice to use error-correcting code (ECC) memory. As the name suggests, it uses an error-correcting algorithm to continually check for and fix certain errors in memory. We don’t often see these memory modules on the desktop for plenty of reasons, among which are increased cost and overhead and decreased performance for only marginal gains, but if your data is of upmost importance even when working on a desktop machine, it is possible to get these modules up and running in certain modern AMD computers.

Specifically, this feature was available on AMD Ryzen CPUs, but since the 7000 series with the AM5 socket launched, the feature wasn’t officially supported anymore. [Rain] decided to upgrade their computer anyway, but there were some rumors floating around the Internet that this feature might still be functional. An upgrade to the new motherboard’s UEFI was required, as well as some tweaks to the Linux kernel to make sure there was support for these memory modules. After probing the system’s behavior, it is verified that the ECC RAM is working and properly reporting errors to the operating system.

Reporting to the OS and enabling the correct modules is one thing, actually correcting an error was another. It turns out that introducing errors manually and letting the memory correct them is possible as well, and [Rain] was able to perform this check during this process as well. While ECC RAM may be considered overkill for most desktop users, it offers valuable data integrity for professional or work-related tasks. Just don’t use it for your Super Mario 64 speedruns.

➖ @hardwareHack ➖

Hackaday
You’ve Got Mail: It All Depends on ZIP Code

https://hackaday.com/wp-content/uploads/2023/07/USPS.jpg?w=800
Previously on You’ve Got Mail, we looked at a few services that were designed to speed up the mail at various points along the way. But these improvements were all taking place on the USPS’ side of the the fence. Was there anything the customer could be doing to help out? https://hackaday.com/wp-content/uploads/2023/09/post-card.png?w=400 A post card from my collection.
As it turns out, yes. And it was almost too late. Whereas you could once address a letter or postcard simply to “Fred Minke, Somerset, Wis.” and it would reach him, the volume of mail was getting completely out of hand with the rise of computers, automated billing, and advertising. Something was needed to improve routing and speed up delivery.

We all know enough about ZIP codes to use them, but where did they come from? How many types are out there? What do they even mean? Let’s find out. Mountains of Mail https://hackaday.com/wp-content/uploads/2023/09/zone-codes.jpg?w=400 Image via Smithsonian Postal Museum
Between 1940 and 1960, the volume of mail handled each year went from 27.7 billion to 63.7 billion pieces. Blame the rise of the computer, because it brought about automated billing and invited return payment by mail. It also facilitated credit card transactions via mail. On top of that, the volume of junk mail and magazines was on the rise.

Another problem was that thousands of experienced postal workers left to serve in World War II, leaving behind those who weren’t so familiar with the address and city/state schemes. So in 1943, the post office came up with zone codes that would be used in 124 large cities to help sort the mail faster. Zones were identified on mail by the use of one or two digits between the city and state, for example, "Birmingham 7, Alabama". Eventually, zone codes spread to 131 cities total. Your Mail, Zipping Across the Nation https://hackaday.com/wp-content/uploads/2023/09/ZIP-map.jpg?w=400 Part of a handy guide for businesses. Image via Smithsonian Postal Museum
By the early 1960s, a more organized and robust system was needed. On July 1, 1963, the USPS introduced the non-mandatory ZIP code to the United States. ZIP stands for Zone Improvement Plan, and the implication is that the use of ZIP codes makes your mail zip along quickly. There were 41,702 ZIP codes in the United States as of October 2019.

And how does the ZIP code system work, exactly? Let’s break it down. The first three digits correspond to a Sectional Center Facility (SCF), which is a centrally-located facility for processing mail. The fourth and fifth digits narrow things down to a more precise location. In larger cities, the last two digits are generally carried over from the zone code days.

Although Robert Moon originally thought of and proposed the ZIP code in 1944, he only brought the first three digits to the table. The latter two are credited to Henry Bentley Hahn, Sr.

There are four types of ZIP code:

* Unique: these are assigned to a single, high-volume address like the CIA, NYU, or the Walmart HQ.
* Post office box-only: for example, 22313 is only for PO boxes at the main office in Alexandria, Virginia.
* Military: these are used strictly for Army Post Office/Fleet Post Office (APO/FPO) addresses overseas.
* Standard: this encompasses all other ZIP codes. A Little Bit More: ZIP+4 https://hackaday.com/wp-content/uploads/2023/09/Intelligent_Mail_Barcode_Wiki22.png?w=400 Those lines at the top? Intelligent Mail barcode. Image via Wikipedia
In 1983, the post office introduced the ZIP+4 scheme. This uses the standard ZIP code plus a four-digit code that targets the precise location.

The +4 generally indicates a city block, an apartment building or buildings, a specific post office box, or any other entity that generates a high enough volume of m[...]

Hackaday
Screech Owl is a Tribute to The Eowave Persephone

https://hackaday.com/wp-content/uploads/2023/10/Somewhere-Over-the-Rainbow-0-18-screenshot-e1697080079608.png?w=800
The Eowave Persephone was a beautiful thing—a monophonic ribbon synth capable of producing clean, smoothly varying tones. [Ben Glover] used to own a nice example that formerly belonged to Peter Christopherson, but lost it in the shifting sands of time. His solution was to build one of his own from scratch.
https://hackaday.com/wp-content/uploads/2023/10/image-1.png?w=250 It’s a simple build, but the final result puts out a nice pleasant sound.
Known as the Screech Owl, the build is based around a custom shield designed to suit the Arduino Leonardo. The primary control interface is a Softpot 500 mm membrane potentiometer, layered up with a further thin film pressure sensor which provides aftertouch control. The Leonardo reads these sensors and synthesizes the appropriate frequencies in turn.

All the electronics is wrapped up inside a tidy laser-cut enclosure that roughly approximates the design of the original Eowave device. [Ben] noted the value of services like Fiverr and ChatGPT for helping him with the design, while he also enjoyed getting his first shield design professionally manufactured via JLCPCB.

It’s a tidy build, and in [Ben’s] capable hands, it sounds pretty good, too. We’ve seen some other great ribbon controlled synths before, too. Video after the break.

➖ @hardwareHack ➖

ail to warrant their own zip code.

Don’t bother adding the +4 today, as it is obsolete and will do nothing to speed up delivery times. Nowadays, addresses are read by a multi-line OCR that manages to determine the ZIP code from the address almost instantly, along with a more specific two-digit delivery point. Once this happens, it prints an Intelligent Mail barcode along the bottom. Mr. ZIP https://hackaday.com/wp-content/uploads/2023/09/mr-zip.png?w=250 Image via Wikipedia
It was relatively easy to get businesses to use ZIP codes, because the USPS soon attached their use to lower mass mailing rates. But getting an entire country’s population to adopt a new practice was a different story. In order to help, the post office came up with a mascot named Mr. ZIP (or as his friends called him, Zippy) to encourage people to use ZIP codes.

Mr. ZIP’s origin is only semi-postal. He was based on a design created by Howard Wilcox, who worked for an ad agency and was the son of a letter carrier. Wilcox had designed the sketch of a cartoonish postman for use by a bank in a bank-by-mail program. AT&T got a hold of it somehow, and let the USPS use it for free.

Do yourself a favor and check out the ZIP Code Song performed by the Swingin’ Six below. If you really want to be entertained, spend fifteen minutes with them learning all about ZIP codes. But Wait, There’s a Little Bit More

Stay tuned for that bit of trivia I’ve been promising since the beginning!

➖ @hardwareHack ➖

Hackaday
Hackaday Prize 2023: AC Measurements Made Easy

https://hackaday.com/wp-content/uploads/2023/10/multimeter-main.jpg?w=800
When working on simple DC systems, a small low-cost multimeter from the hardware store will get the job done well enough. Often they have the capability for measuring AC, but this is where cheap meters can get tripped up. Unless the waveform is a perfect sinusoid at a specific frequency, their simple algorithms won’t be able to give accurate readings like a high-quality meter will. [hesam.moshiri] took this as a design challenge, though, and built an AC multimeter to take into account some of the edge cases that come up when working with AC circuits, especially when dealing with inductive loads.

The small meter, an upgrade from a previous Arduino version that is now based on the ESP32, is capable of assessing root mean square (RMS) voltage, RMS current, active power, power factor, and energy consumption after first being calibrated using the included push buttons. Readings are given via a small OLED screen and have an accuracy rate of 0.5% or better. The board also includes modern design considerations such as galvanic isolation between the measurement side of the meter and the user interface side, each with its own isolated power supply.  The schematics and bill-of-materials are also available for anyone looking to recreate or build on this design.

With the project built on an easily-accessible platform like the ESP32, it would be possible to use this as a base to measure other types of signals as well. Square and triangle waves, as well as signals with a large amount of harmonics or with varying frequencies, all need different measurement techniques in order to get accurate readings. Take a look at this classic multimeter to see what that entails.
The HackadayPrize 2023 is Sponsored by:
https://hackaday.com/wp-content/uploads/2023/07/DigiKey_w.png?w=250

https://hackaday.com/wp-content/uploads/2020/05/hackaday-prize2020-sponsors-supplyframe.png?w=250

➖ @hardwareHack ➖

Hackaday
USB-C For Hackers: Build Your Own PSU

https://hackaday.com/wp-content/uploads/2019/07/USB-C.jpg?w=800
What if you wanted to build your own USB-C PSU? Good news – it’s easy enough! If you ever wanted to retrofit a decent DC PSU of yours to the USB-C standard, say, you got a Lenovo/HP/Dell 19V-20V charger brick and you’ve ever wished it were USB-C, today is the day when we do exactly that. To be fair, we will cheat a bit – but only a tiny bit, we won’t be deviating too much from the specification! And, to begin with, I’ll show you some exceptionally easy ways that you can turn your DC PSU into a USB-C compatible one, with a simple module or a few. https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_7.jpg?w=384 Turning a 20 V PSU into a USB-C PSU feels natural if you want to charge a laptop – those tend to request 20 V from a USB-C PSU anyway, so what’s the big deal? However, you can’t just put 20 V onto a USB-C connector – you have to add a fair bit of extra logic to make your newly christened USB-C PSU safe to use with 5 V devices, and this logic also requires you go through a few extra steps before 20 V appears on VBUS. Any USB-C PSU has to output 5 V first and foremost whenever a device is connected, up until a higher voltage is negotiated digitally, and the PSU may only switch to a higher voltage output when it’s requested to do so.

Now, for that, a PSU offers a list of profiles, and we looked into those profiles in the Replying PD article – each profile is four bytes that contain information about the profile voltage, maximum current that the device may draw at that voltage, and a few other details. For a PSU to be USB-C compliant, the USB-C specification says that, in addition to 5 V, you may also offer 9 V, 15 V, and 20 V.

https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_1.png?w=400

Also, the specification says that if a PSU supports certain in-spec voltage like 15 V, it’s also required by the spec to offer all of the spec-defined voltages below the maximum one – for 15 V, that also requires supporting 9 V. Both of these are UX requirements, as opposed to technical requirements – it’s easier for device and PSU manufacturers to work with a small set of pre-defined voltages that majority of the chargers will support, but in reality, you can actually offer any voltage you want in the PSU advertisement; at worst, a device is going to refuse and contend with slowly charging from the 5 V output that you’re required to produce.

I’d like to walk you through how off-the-shelf USB-C PSUs work, all of the options you can use to to create one, and then, let’s build our own USB-C PSU from scratch! All The Off-The-Shelf Options

These few caveats are already baked into USB-C PSUs. After all, with modern controller chips, it doesn’t take much to add USB-C output support to a generic PSU during manufacturing – all you really need is to use a PD controller IC that ties into the PSU’s feedback line, adds an inline current sensor, and controls a MOSFET to switch the power on and off, and this IC also takes care of the USB-C rules and regulations. With the FB pin under its control, the PD controller takes over the PSU’s output voltage regulation process and make the PSU output any voltage it could ever want, within reason. https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_5.jpg?w=238 This made it easy for manufacturers to produce USB-C PSUs – instead of wiring up the FB signal of your SMPS to a voltage divider like you normally would, you just wire it up to a separate block that does the whole PD part, wire that block to a USB-C PSU, and you’re golden! If you want to buy a reliable 12 V / 3 A PSU for your project, instead of working with barrel jack PSUs, it’s becoming way easier and cheaper to just buy a USB-C PSU and a trigger board.

As a benefit, by adjusting the PSUs feedback line, you can get all the interme[...]

diate voltages you could want – so, PSU makers don’t have to limit themselves to weird static voltages like 7.5 V and 11 V anymore. This last part also means that features like PPS (variable voltage and CC/CV) support are not about the way your PSU is built specifically, but merely about whether the PD controller IC in your PSU supports it – and the new generations of PSU-side PD controller ICs tend to support PPS by default, which means that finding a USB-C charger with PPS is soon going to become trivial, if it already isn’t.

Nowadays, there’s a number of such ICs on the market that you can use to seamlessly convert an old or new PSU design to USB-C, just by tapping into the feedback line inside the PSU, and you can get these ICs from Eastern and Western manufacturers alike. If you have an already-working DC PSU, however, you don’t have to disassemble it and solder a USB-C PSU module into the feedback input – there are more and  modules on the market that take a DC input, have a small PD controller chip, and also a buck (or even buck/boost!) converter to produce all the USB-C voltages a device could need! https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_3.jpg?w=400 Such boards are basically the opposite-world version of a PD trigger module – instead of getting DC out of a PD port, you create a PD port out of a DC source, with a buck/boost conversion in the middle that makes the whole ordeal a bit less efficient than direct conversion, but still hits the bullseye. You can find these boards on Aliexpress, and you can still distinguish these boards from PD trigger boards because they’ll have a big inductor on them, something that PD trigger boards don’t need.

If you want keywords, I could find a fair few by using “PD charger module” and then checking the pictures for visible inductors. One small exception is LiIon chargers with USB-C PD input, but it should be easy to filter these out by checking the title for any Lithium-Ion chemistry keyword references.

https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_2.jpg?w=250 In the same vein, if you don’t want to wait for the Aliexpress package and need a USB-C output in a pinch, you can get a USB-C car charger for a lighter socket, as long as it’s got higher than 5 V (15 W) output capability – if the label says it supports higher-than-5 V voltages on USB-C, you should be in the clear. They’re basically the same “PD charger” modules but packaged into a lighter socket adapter, expecting 12 V or 24 V but likely okay with voltages inbetween.

Both the lighter adapter and the Aliexpress options are very technologically similar to the native USB-C PSU option – you get a buck/boost converter with the same IC tapping into its FB signal, or even an all-things-contained IC that does everything for you if you just give it an inductor and a few other parts. But if feeding either 5 V or 20 V is all there is to your usecase, you can get even simpler than that! Specification Versus Reality

If you think that your 20 V PSU should be able to simply put 20 V onto USB-C, or you want to avoid conversion inefficiencies, maybe you’d like to try to make the most straightforward PSU possible, there’s absolutely a way to do it all! In a USB-C PSU, you can technically limit yourself to 5 V and 20 V outputs, switching between them using FETs: if a device can’t work with a 20 V profile, it won’t request it, so you might not be able to charge your Nintendo Switch or smartphone at higher than 5 V, but it will be just right for a laptop. You can even offer custom voltages and leave it it up to devices to accept those! For instance, 12 V is not a voltage defined in the USB-C specifications, but half of PSUs on the market offer it nevertheless, purely because a large amount of the PD PSU controller ICs out there have 12 V programmed into them as an option. So, 12 V is more of a USB-C tradition than an actual profile, and yet devices work with it – it’s a mainstay on trigger boards, too!

https://hackaday.com/wp[...]

Hackaday
Hackaday Superconference 2023: Workshops Announced, Get Tickets Now!

https://hackaday.com/wp-content/uploads/2023/08/supercon2023-250.png?w=800
Last week, we announced just half of our fantastic slate of talks for Supercon. This week, we’re opening up the workshops. The workshops are small, hands-on opportunities to build something or learn something, lead by an expert in the field. Workshops sell out fast, so register now if you’re interested.

And stay tuned for the next round of talk reveals next week! And maybe even the badge reveal? https://hackaday.com/wp-content/uploads/2023/10/AndyGeppert_web_copy-Andy_Geppert_thumbnail.png?w=400 Andy Geppert
Weave Your Own Core Memory – Core16!

This workshop provides you with the opportunity to weave your own core memory! Using 16 authentic ferrite core bits and 16 RGB LEDs, you can play tic-tac-toe, paint with a magnetic stylus, and create your own interactive experiences. Andy Geppert will guide you through the assembly of Core16. The Core16 kit is the little brother of the Core64 kit. The smaller Core16 kit reduces assembly time/cost, enabling more people to experience the challenge and satisfaction of creating their own core memory. https://hackaday.com/wp-content/uploads/2023/10/Travis_Foss_thumbnail.png?w=400 Travis Foss
Presented by DigiKey: Introduction and expansion of the XRP Robotics Platform

In this workshop you will be able to get your hands on the new XRP (Experiential Robotics Platform) and take the basics a step further with a few additional parts. Along with the base kit, participants will have the opportunity to install a RGB twist encoder, a LCD screen, and a buzzer to create a setup that will allow the user to choose a program onboard without being tethered to a computer. https://hackaday.com/wp-content/uploads/2023/10/IMG_0596-Rebecca_Button_thumbnail-1.png?w=400 Becky Button
How to Make a Custom Guitar Pedal

Musical effects are for everybody! Join this workshop and get hands-on experience assembling and programming your musical effects pedals. Walk away from this workshop with the capability of integrating multiple musical effects into 1 device and reprogramming the pedal with any effects you want! https://hackaday.com/wp-content/uploads/2023/10/DanielLindmarkHeadshot_thumbnail.png?w=400 Daniel Lindmark
From Zero to Git: 1 Hour Hardware Git Bootcamp

In this workshop, you will learn all about basic git operations, including how to download and install the client, setting up a repo, synching changes, and much more. Learn how to navigate common issues and take advantage of a live FAQ during the workshop. https://hackaday.com/wp-content/uploads/2023/10/20230725_180757-Jazmin_Hernandez_thumbnail.png?w=400 Jazmin Hernandez
Solder and Learn How to Use Your Own Anti-Skimmer (HunterCat)

Have you ever been vulnerable to data theft? Do you fear using your bank card in ATMs or even in a restaurant? Protect your information from potential skimmers in this workshop while you learn to solder some components of your anti-skimmer/magnetic stripe clone detectors. By the end of the workshop, you’ll have a device to insert before using your bank card to check for potential issues. https://hackaday.com/wp-content/uploads/2023/10/Untitled_design_2-matthew_venn_thumbnail.png?w=400 Matt Venn
Tiny Tapeout – Demystifying Microchip Design and Manufacture

In this workshop, you can design and manufacture your own chip on an ASIC. You will learn the basics of digital logic, how semiconductors are made, the skills needed to use an online digital design tool for simulation, and how to create the GDS file for manufacturing. Participants will also have the option to submit their designs to be manufactured as part of the Tiny Tapeout project.
You can’t attend the workshops without attending Supercon, so get your tickets!  (As we write, there are only ten more…)

➖ @hardwareHack ➖

-content/uploads/2023/09/hadoc_building_psu_4.jpg?w=242 Now, Dell has produced such an adapter, converting a Dell laptop PSU to a USB-C charger, switching between 5 V and 20 V with FETs. I’ve referenced this adapter in my Power Delivery article as the way to convert a DC PSU to USB-C, back when my USB-C knowledge was about 10% of what it is now. You can still buy these adapters, from either Dell or Aliexpress, and they’re an inspiration for what I propose we build!

Let’s build a DC PSU to USB-C PSU adapter that talks to USB-C devices and can offer its high voltage passthrough when they request it – efficient, hackable, and a learning opportunity. For that, you need this adapter to provide 5 V first, at a certain amount of current – but even that amount of current can be custom, you could theoretically offer 500 mA at 5 V and be done with it, so you don’t need to use too powerful of a buck regulator. I’m going to use an AP63200 switching regulator, which can produce up to 5 V / 2 A from a 20 V source. https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_8b.png?w=400 You also want to make sure your 20 V is reasonably noise-free, as the USB-C standard has some requirements for that. I’m going to be using OEM laptop PSUs from HP/Dell/ Lenovo, which tend to be of good quality compared to off-brand copies. Also, you want to know your PSU’s current capability – USB-C devices have a responsibility to monitor and temper their current consumption, so a typical laptop charger will only consume 5 A if your PSU says it can deliver 5 A, but if you tell your device you can deliver 5 A when your 20 V PSU can’t, your device might happily try and draw 5 A, triggering the overcurrent protection in the PSU. Thankfully, with the HP/Dell/Lenovo triad, their chargers have a mechanism to communicate current consumption, and with a few extra GPIOs and ADCs, I can just use that to check what kind of current we can provide! Fast, Exact Transitions

The FET arrangement we need to switch between 5 V and 20 V output implies some requirements – you don’t want 20 V backfeeding into 5 V, and you also want the FETs to handle 3 A – 5 A of current through without breaking a sweat. When switching between 20 V and 5 V, you also want to make sure that 5 V power is not interrupted – the transition between 5 V and 20 V has to be reasonably smooth, without losing VCC. I’m going to use SI4909DY FETs, a pair of P-FETs in comfortable SO8, one pair for 5 V use and one for 20 V use, trying and keep the FETs gate voltage at about 10 V max, since that’s where the datasheet says these FETs work optimally. Let’s go through the wiring, which has some nuances – mind you, you can’t afford to feed 20 V into your 5 V rail! https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_9.png?w=389 https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_10.png?w=400 https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_11.png?w=400 https://hackaday.com/wp-content/uploads/2023/09/hadoc_building_psu_12.png?w=400 You could use an ideal diode circuit of some sort for backfeeding prevention purpose, but I’ll use a pair of back-to-back FETs driven by NPN transistors, with two separate control GPIOs. For 20 V, I’ll use two FETs connected in parallel – that decreases Rds and heat dissipation; remember, as a rule, FETs in parallel balance each other and spread the current equally between themselves! I’m going to wire up one SI4909DY pair in series for 5 V use, and another with both FETs in parallel for 20 V use.

When I first built this circuit, I put the 20 V FETs back-to-back too, thinking that I’d add a protection mechanism in case one of the FETs got shorted, but they ended up dissipating too much power. So, instead, I’m adding a boot-time VBUS measurement check into the code, that will make the PSU shut down and show an error message in case the 20 V or 5 V FETs get shorted out.

Our PSU needs to support three states – no VBUS on its USB-C output port, 5 V VBUS output, and 20 V V[...]

Hackaday
Keypad Interface Module Reverse Engineers Pinouts So You Don’t Have To

https://hackaday.com/wp-content/uploads/2023/10/keygo-feature.png?w=800
If you’ve scavenged some random keypads and want to reuse them in a project without the hassle of figuring out the pinouts, then [Cliff Biffle] has an interface module for you. The Keypad Go connects to the mystery keypad via an 8-pin 0.1 inch header, and talks to your own project using I2C and/or serial.

You could categorize the mechanism at work as machine learning of a sort, though it’s stretching definitions a bit, as there is no ChatGPT or GitHub Copilot wizardry going on here. But you must teach the module during an initial calibration sequence, assigning a 7-bit ASCII character to each key as you press it. Once trained, it responds to key presses by sending the pre-assigned character over the interface. Likewise, key releases send the same character but with the 8th bit set.

The heart of the board is either an STM32G030 or STM32C011/31, depending on parts availability we presume. I2C connectivity is over a four-pin STEMMA connector, and logic-level serial UART data is over a four-pin 0.1 inch pin header. [Cliff] plans to release the firmware and schematics as open source soon, after cleaning up the code a bit. The device is also for sale on Tindie, though it looks like they won’t be back in stock until later on in the month.

Longtime readers might recognize [Cliff] from his impressive m4vga project which we covered back in 2015, where he manages to generate 800×600 VGA signals at 60 Hz from an STM32F4-family microcontroller.

➖ @hardwareHack ➖