Hackaday
Dial Up a Tune On the Jukephone

https://hackaday.com/wp-content/uploads/2023/10/jukephone-800.jpg?w=800
What do you do when you find a nice corded phone with giant buttons out in the wild? You could pay $80/month for a landline, use a VOIP or Bluetooth solution instead, or do something a million times cooler and turn it into a jukebox.

https://hackaday.com/wp-content/uploads/2023/10/jukephone-directory.jpeg?w=400 Now when the receiver is lifted, [Turi] hears music instead of a dial tone or a voice on the other end. But playback isn’t limited to the handset — there’s a headphone jack around back.

To listen to a track, he can either dial one in directly, or call up a random track using one of the smaller buttons below. A handy directory organizes the tunes by the hundreds, putting children’s tracks between 1-99 and the intriguing category “hits” between 900-999.

The phone’s new guts are commanded by a Raspberry Pi Pico, which is a great choice for handling the key matrix plus the rest of the buttons. As you may have guessed, there’s an DF Player Mini mp3 player that reads the tracks from an SD card. Everything is powered by a rechargeable 18650 battery.

Jukephone is open source, and you’ll find more pictures on [Turi]’s blog post. Be sure to check out the very brief build and demo video after the break.

➖ @hardwareHack ➖

Hackaday
Pocket CO2 Sensor Doubles as SMD Proving Ground

https://hackaday.com/wp-content/uploads/2023/10/co2smd_feat.jpg?w=800
While for some of us it’s a distant memory, every serious electronics hobbyist must at some point make the leap from working with through-hole components to Surface Mount Devices (SMD). At first glance, the diminutive components can be quite intimidating — how can you possibly work with parts that are literally smaller than a grain of rice? But of course, like anything else, with practice comes proficiency.

It’s at this silicon precipice that [Larry Bank] recently found himself. While better known on these pages for his software exploits, he recently decided to add SMD electronics to his repertoire by designing and assembling a pocket-sized CO2 monitor. While the monitor itself is a neat gadget that would be worthy of these pages on its own, what’s really compelling about this write-up is how it documents the journey from SMD skeptic to convert in a very personal way.
https://hackaday.com/wp-content/uploads/2023/10/co2smd_detail.jpg?w=400 A fine-tipped applicator will get the solder paste where it needs to go.
At first, [Larry] admits to being put off by projects using SMD parts, assuming (not unreasonably) that it would require a significant investment in time and money. But eventually he realized that he could start small and work his way up; for less than $100 USD he was able to pick up both a hot air rework station and a hotplate, which is more than enough to get started with a wide range of SMD components. He experimented with using solder stencils, but even there, ultimately found them to be an unnecessary expense for many projects.

While the bulk of the page details the process of assembling the board, [Larry] does provide some technical details on the device itself. It’s powered by the incredibly cheap CH32V003 microcontroller — they cost him less than twenty cents each for fifty of the things — paired with the ubiquitous 128×64 SSD1306 OLED, TP4057 charge controller, and a SCD40 CO2 sensor.

Whether you want to build your own portable CO2 sensor (which judging from the video below, is quite nice), or you’re just looking for some tips on how to leave those through-hole parts in the past, [Larry] has you covered. We’re particularly eager to see more of his work with the CH32V003, which is quickly becoming a must-have in the modern hardware hacker’s arsenal.

➖ @hardwareHack ➖

Hackaday
How The 2022 CEZ Event Shows The Fragility of Environmental Sensors in High-Risk Areas

https://hackaday.com/wp-content/uploads/2023/10/CEZ_monitoring_station.jpg?w=800
In what reads somewhat like a convoluted detective story, the events unfolding at the Chornobyl Exclusion Zone (CEZ) in Ukraine during late February had the media channels lighting up with chatter about ‘elevated gamma radiation levels’, which showed up on the public CEZ radiation monitoring dashboard for a handful of gamma radiation sensors. This happened right before this reporting system went off-line, leaving outside observers guessing at what was going on. By the time occupying forces had been driven out of the CEZ, the gamma radiation levels were reported as being similar to before the invasion, yet the computer hardware which was part of the monitoring system had vanished along with the occupying forces. After considering many explanations, this left security researchers like [Ruben Santamarta] to consider that the high values had been spoofed.
During the Black Hat event held in August of 2023, [Ruben] presented his reasoning in a series of slides. Much of this comes down to applying Occam’s Razor. The original theory was that driving heavy vehicles around the CEZ caused radioactive dust to get suspended (resuspension) into the air, causing the ten-fold jump in gamma radiation readings, yet as demonstrated by M.D. Wood and colleagues in the Journal of Environmental Radioactivity in September 2023, this is physically impossible, as disturbing even the top 10 cm of soil in which the 137Cs isotope is concentrated would not have a meaningful difference in gamma reading. A fact which is also demonstrated with the regular wildfires in the CEZ that cause massive resuspension of 137Cs-containing soil, yet which do not lead to massive gamma radiation spikes. Measurements afterwards by the IAEA also confirmed no significant increase in radiation, though widespread damage to the monitoring equipment was reported. https://hackaday.com/wp-content/uploads/2023/10/skylink_radiation_monitoring_system.jpg?w=400 Unidrectional transmitting of recorded radiation values and subsequent processing as performed at the CEZ. (Credit: Ruben Santamarta)
This conclusion then led to other considerations, such as whether electromagnetic interference or even electronic warfare (EW, including jamming) systems could have caused the clearly incorrect data to appear in the reporting system. Yet due to the highly distributed number of elevated sensor readings despite the limited range of EW and similar sources of interference, as well as the very specific increase in reported values on the public-facing dashboard, such a scenario would be essentially impossible.

Shifting the focus to willful manipulation of the values at some level of the system offers a number of interesting options. Spoofing a monitoring station is one option, or if one has access to the server that accumulates the data received from individual monitoring stations, this data can be altered or spoofed at this level.

Although proving anything definitively here is impossible, since all of the forensic data was destroyed by the occupying forces, [Ruben] postulates that either the SkyLINK wireless transmitters were spoofed at these specific locations in the CEZ (possibly after their willful destruction), or the server processing the incoming data was directly manipulated. To what end would be anyone’s guess, since the forensic evidence that existed is gone, and all that is left is conjecture.

What is most telling here, however, is that despite the dual-layered nature of the monitoring system at the CEZ, with the old (wired) and new wireless system, physical violence against monitoring equipment and the single point of failure of a relatively unprotected processing server meant that for weeks nobody knew what was[...]

Hackaday
Antennas Can Be a Total Mystery

https://hackaday.com/wp-content/uploads/2023/10/antenna-main.png?w=766
The real action in the world of ham radio is generally in the high frequency bands. Despite the name, these are relatively low-frequency bands by modern standards and the antenna sizes can get a little extreme. After all, not everyone can put up an 80-meter dipole, but ham radio operators have come up with a number of interesting ways of getting on the air anyway. The only problem is that a lot of these antennas don’t seem as though they should work half as well as they do, and [MIKROWAVE1] takes a look back on some of the more exotic radiators.

He does note that for a new ham radio operator it’s best to keep it simple, beginning work with a dipole, but there are still a number of options to keep the size down. A few examples are given using helically-wound vertical antennas or antennas with tuned sections of coaxial cable. From there the more esoteric antennas are explored, such as underground antennas, complex loops and other ways of making a long wire fit in a small space, and even simpler designs like throwing a weight with a piece of wire attached out the window of an apartment building.

While antenna theory is certainly a good start for building antennas, a lot of the design of antennas strays into artistry and even folklore as various hams will have successes with certain types and others won’t. It’s not a one-size-fits-all situation so the important thing is to keep experimenting and try anything that comes to mind as long as it helps get on the air. A good starting point is [Dan Maloney]’s $50 Ham Guide series, and one piece specifically dealing with HF antennas.

➖ @hardwareHack ➖

going on inside the CEZ, other than those mysteriously high values on a public dashboard before the system went offline.

Extrapolating this scenario to industrial, natural and other disasters, it’s not hard to see how other environmental sensor networks are equally fragile, with essential information from whichever sensors are still online unable to make it out of the disaster zone due to a lack of redundancy here. Since in many disaster scenarios such sensor information can be essential in planning a rescue or repair mission, hardening an environmental sensor network and adding redundancy at each level can make all the difference in the world. Whether your single-point-of-failure server system was tossed into the back of a military truck or crushed by tons of collapsing building is merely academic in that context.

(Heading image: A monitoring station as set up in the CEZ, featuring both the legacy (ARMS) and new wireless monitoring system.)

➖ @hardwareHack ➖

Hackaday
Tiny Tape Cartridge Remembered and a Teardown

https://hackaday.com/wp-content/uploads/2023/10/tape.png?w=800
If you want to add sound to something these days, you usually store it digitally. Microcontrollers are cheap and fast, and you can hold a lot of audio on a small flash card or in a ROM. But back “in the day,” storing audio was often done with tape. If you wanted something you could automate, you often turned to an endless loop tape. They had the advantage of not needing rewinding and had a way to sense spots on the tape (usually the start). The 8-track, for example, was an endless loop tape, and radio stations used “carts” (technically Fedelipak cartridges). But what if you wanted to build something tiny? Bandai had the answer, and [Tech Moan] shows the 1986-era tiny carts.

In the US, these appear to be mainly in the realm of novelty items. [Tech Moan] has an Elvis figurine that sings thanks to the tape and a diminutive jukebox. He suspects these must have been used in something else, perhaps in the Japanese market.
A quick teardown identified some of the problems he noted with the jukebox. However, figuring out why some of the tapes wouldn’t play required tearing apart one of the tapes. He transferred the tape to a standard cassette shell, and it played, so the implication is the tapes inside are just standard cassette media. For 8 tracks, special tape prevents the tape from sticking together, and it appears that, after 40 years, the Bandai carts were sticking. Probably, the designers didn’t think anyone would be playing these in 2023.

There isn’t much about these, although they have an entry in the Museum of Obsolete Media. These are truly tiny compared to an 8-track tape and even smaller than the tiny endless loop tape that was in an old phone answering machine.. Too bad you can’t convert Elvis into a police scanner.

➖ @hardwareHack ➖

Hackaday
Dumping Spacecraft In The Middle Of Nowhere

https://hackaday.com/wp-content/uploads/2023/10/map1.jpg?w=600
The BBC has an interesting article on Point Nemo, AKA the Oceanic Pole of Inaccessibility, AKA the spacecraft graveyard. This is the place in the ocean that is furthest from land, in the middle of the usually stormy South Pacific. It’s as far out there as you can get without leaving the planet: about 2,688 kilometers (1670 miles) from the nearest dry land. Even the ocean floor is 4 km (2.5 miles) down; the closest human life is the International Space Station (ISS) astronauts flying 415 km (260 miles) above it. It is not near any shipping lanes or transport routes. It is, to put it bluntly, the middle of goddam nowhere. So, it is a perfect place to dump derelict spacecraft.

Since 1971, over 160 spacecraft have met their end in these chilly waters, from the fiery public end of the Mir space station to the secret death of numerous secret spy satellites. The article in question focuses on the Soviet satellites, but plenty of other countries dump their end-of-life satellites there, including trash from the ISS. The Chinese Taingong-1 space station crashed nearby, although that was more by accident than design. The ISS is scheduled to join its trash in a few years: the current plan is that the massive space station will be de-orbited and crashed near Point Nemo in 2030.

Will there be anyone to see it? When the Mir space station was de-orbited, some entrepreneurial companies offered flights to the area to catch a glimpse, but the best view was from the island of Fiji. So, start planning your trip now…

➖ @hardwareHack ➖

Hackaday
Meshtastic and Owntracks to Kick your Google Habit

https://hackaday.com/wp-content/uploads/2023/06/Meshtatic.jpg?w=800
I have an admission to make. I have a Google addiction. Not the normal addiction — I have a problem with Google Maps, and the timeline feature. I know, I’m giving my location data to Google, who does who-knows-what-all with it. But it’s convenient to have an easy way to share location with my wife, and very useful to track my business related travel for each month. What we could really use is a self-hosted, open source system to track locations and display location history. And for bonus points, let’s include some extra features, like the ability to track vehicles, kids, and pets that aren’t carrying a dedicated Internet connection.

You can read the title — you know where we’re going with this. We’re setting up an Owntracks service, and then tying it to Meshtastic for off-Internet usability. The backbone that makes this work is MQTT, a network message bus that has really found its niche in the Home Assistant project among others. It’s a simple protocol, where clients send brief messages labeled by topic, and can also subscribe to specific topics. For this little endeavor we’ll use the Mosquito MQTT broker.

One of the nice things about MQTT is that the messages are all text strings, and often take the form of JSON. When trying to get two applications to talking using a shared MQTT server, there may need to be a bit of translation. One application may label a field "latitude", and the other shortens it to "lat". The glue code to put these together is often known as an MQTT translator, or sometimes an MQTT bridge. This is a program that listens to a given topic, ingests each message, and sends it back to the MQTT server in a different format and topic name.

The last piece is Owntracks, which has a recorder project, which pulls locations from the MQTT server, and stores it locally. Then there’s Owntracks Frontend, which is a much nicer user interface, with some nice features like viewing movement a day at a time. Getting started

So up first, pick a machine to host the service. We’ll use Docker-compose to build our mini-cluster of services. A Linux machine is a great choice, though it should be possible to run on Windows through either Docker desktop, or WSL. But if you go that route, you’re a bit on your own. You’ll need Docker and docker-compose, with the Docker service running — ideally set to autostart via systemd. And reminder, you’ll probably need to add your user to the “docker” group, with "sudo gpasswd -a $USER docker".

Now just a quick note: I’m going to describe the process of setting this up from scratch. At the end of this article there will be a link to a Github repository, where you can grab nearly everything all at once.
It’ll help to read through the details at least once, to understand what we’re building, so hang in there.

We start by creating a folder in /etc, called owntracks-meshtastic. In that folder, we want to create a directory called mosquitto, and then create the mosquitto configuration file. We want to add two lines to that file, instructing our MQTT server to listen on port 1883, and to accept unauthenticated connections.
sudo mkdir /etc/owntracks-meshtastic
cd /etc/owntracks-meshtastic
sudo mkdir mosquitto
sudo touch mosquitto/mosquitto.conf
echo "allow_anonymous true" | sudo tee -a mosquitto/mosquitto.conf
echo "listener 1883" | sudo tee -a mosquitto/mosquitto.conf
With the configuration file in place, it’s time to start on our docker-compose.yml file, using "sudo nano /etc/owntracks-meshtastic/docker-compose.yml". A docker compose file is really pretty simple once you break it down into parts. We start with a services heading, and under that will be a block for each docker service we want to run. Each block starts with a service name, and includes the Docker image itself, what fil[...]

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[...]