url stringlengths 37 208 | title stringlengths 4 148 | author stringclasses 173
values | publish_date stringclasses 1
value | categories listlengths 0 12 | tags listlengths 0 27 | featured_image stringlengths 0 272 | content stringlengths 0 56.1k | comments_count int64 0 900 | scraped_comments_count int64 0 50 | comments listlengths 0 50 | scraped_at float64 1.76B 1.76B |
|---|---|---|---|---|---|---|---|---|---|---|---|
https://hackaday.com/2022/05/11/hackaday-prize-2022-vintagephone-links-the-past-to-the-present-and-future/ | Hackaday Prize 2022: Vintagephone Links The Past To The Present (and Future) | Kristina Panos | [
"The Hackaday Prize"
] | [
"2022 Hackaday Prize",
"rotary dial",
"voice assistant"
] | Brrrrrrrring! Movies and TV are one thing, but the siren song of a rotary phone ringing in the same room as you is one of those sounds you carry forever. Not old enough to remember them? Ah, so what? There’s no reason to lose these beauties to the annals of time. In fact, we think more old phones should be repurposed so that present and future generations can experience the finger-hookin’ good time of the rotary dial and the high-voltage peal of those brass bells.
That’s exactly what [Giulio Pons] has done with Vintagephone —
turned a rotary phone into a digital assistant with an analog interface
. He’s reused all the good bits like the rotary dial, the bells, the handset, and the hang-up switch and connected them up to a Wemos ESP8266 development board with a mini motor driver shield and a voltage booster to ring the bells.
When it’s all said and done, [Giulio] will be able to set an alarm by dialing in the time, ring a number to get the current time and date, and ring another number to get the weather forecast. Reminds us of our childhood pastime of calling Time and Temperature to get outside verification that time had, in fact, passed inside the house on those boring rainy days.
Follow along with [Giulio] as the Vintagephone comes to life in the logs, which already have some great instructions for doing a similar number to an old phone you may have lying around. You can find the code on
GitHub
.
Got some old tech lying around? Teach it some new tricks and enter the
Reuse, Recycle, Revamp
round of the 2022 Hackaday Prize!
The
Hackaday
Prize2022
is Sponsored by: | 21 | 7 | [
{
"comment_id": "6472003",
"author": "wibble",
"timestamp": "2022-05-11T19:00:00",
"content": "Can you still get SLIC ICs (Subscriber Line Interface Circuit)? There really isn’t any need to modify the phone’s wiring. I do like the idea of using motor drivers for switching the bell current.",
"pa... | 1,760,372,698.557601 | ||
https://hackaday.com/2022/05/11/animate-your-robot-in-blender/ | Animate Your Robot In Blender | Anne Ogborn | [
"Featured",
"Robots Hacks",
"Skills",
"Slider"
] | [
"blender",
"robot arm",
"robot motion"
] | You’ve built a robot crammed full of servos and now you settle down for the fun part, programming your new dancing animatronic bear! The pain in your life is just beginning. Imagine that you decide the dancing bear should raise it’s arm. If you simply set a servo position, the motor will slew into place as fast as it can. What you need is an animation, and preferably with smooth acceleration.
You
could
work through all the math yourself. After half an hour of fiddling with the numbers, the bear is gracefully raising it’s arm like a one armed zombie. And then you realize that the bear has 34 more servos.
Fortunately for everybody who’s done the above, there’s Blender. It’s all about creating smooth motion for animations and computer graphics. Making robot motion with Blender is, if not easy, at least tolerable. We made
a sample project, a 3-axis robot arm
to illustrate. It has a non-moving pedestal, rotating base, upper arm, and lower arm. We’ll be animating it first in Blender and then translating the file over to something we can use to drive the servos with a little script.
Now, Blender is notorious for a difficult user interface. The good news is that, with revision 2.9, it moved to a
much
more normal interface. It still definitely
is
a large program, with 23 different editors and literally thousands of controls, but we’ll only be using a small subset to make our robot move. We won’t teach you Blender here, because there are thousands of great Blender tutorials online. You want to focus on animation, and the
Humane Rigging series
is particularly recommended.
Here are the major steps to animating a robot:
Make a ‘skeleton’ (armature) that matches your robot
Rig the armature so that it moves like your robot and is convenient to animate
Animate the armature
Export the servo positions to your robot control program
Robot Armature
Generally, computer animations consist of an armature and then the mesh for the body that hangs on it. For a robot, we don’t need the mesh, just the armature, because we’re not making a movie. Still, the armature
does
need to match the hardware size. Import CAD files or build atop a photo or just measure the robot.
The robot’s
rest pose
is the reference position of the joints, where the robot is when the axes are at zero. Ours is pointing the arm straight up.
Rest Pose
Bones pivot about the
tail
, and the
head
is ‘where they are’. Your shinbone’s tail is your knee, and your shinbone’s head is your ankle. Bones can have
parents
. Your shin bone is a child of your thigh bone. If you move your femur (thigh bone), your shin goes with it.
Bones only rotate on certain axes. Knees only swing back and forward, not side to side. You can twist your wrist, but not your fingernails. They also have motion limits. You probably can’t bend your knees backward.
Hinge joints only rotate, but some bones can scale (a soft robot), or translate (a CNC router).
There are even more complex
constraints
. The front wheels of a passenger car steer together. The rods on a steam locomotive stay on their pins. The dog can move freely to the limit of it’s leash.
The animator might not want to pose by positioning the bone. Animating a character’s eyes by setting their angles would be awkward. Far better to have an extra target bone that the character always looks at, and constrain the eyes to look at the target. We usually curl our fingers all at once, and we curl all the joints on a finger at once. So how about an extra bone that controls everything at once?
An armature with all these extra control bones and constraints is called a
rig
. Blender has powerful tools to build rigs like this.
Our example’s first bone,
pedestal,
represents the robot’s pedestal, the part bolted to the floor. Bones are
posable
– that’s the point, you can animate them. But this bone never moves, so we locked everything – the location, rotation, and scale.
The base rotates on the pedestal, so the
base
bone is a child of the
pedestal
bone.
base
‘s head is at the pivot for the upper arm. The base rotates on the
base
bone’s Y axis. That’s it’s only motion, so we locked all the other axes.
The other bones are much the same.
upperarm
is a child of
base
, with its head at the elbow. lowerarm runs from the elbow to the wrist. These joints are oriented to turn along local Z.
The armature now works. Select (pose mode) the
base
and turn it (Y rotation) and the arm bones rotate as well. If you mess the position up experimenting, just undo or set the unlocked axes to zero.
Our sample robot has a simple mesh that moves with the bones so you can see the robot move.
But its still possible to put the robot in positions the hardware can’t do. Lets say our sample hardware robot base can only rotate 90 degrees each side of center. We can keep the animator from making impossible moves with
bone constraints
. We added a
limit rotation constraint
to each bone.
Interacting
This is great, but now we want our robot bear to grab a present. How will the robot interact with the outside world. The solution is
inverse kinematics (IK)
. IK lets us say where we want the wrist, not where the shoulder and elbow joints are. So we added a ball named IK to the scene and added an IK constraint to the lowerarm to try to reach the ball.
If you’re following along, move the sample timeline to frame 120, so the IK is on and you’re not messing up our animations.
The robot wrist now is ‘grabbing’ the IK ball. In object mode, select the ball and use (
g key
) to ‘grab’ it. Drag to move the ball around. The robot neatly follows along, and the joints set themselves to do what’s needed. Much more convenient.
If you want to poke around in the IK constraint, its home is
lowerarm
. In pose mode, select lowerarm and the bone constraints tab in the object properties editor on right. The IK constraint lives here.
A brilliant bit of Blender is that almost anything can be animated. Most values have a small white dot on their right. Clicking that turns it to a diamond and makes the value animated. We did this to “Influence”, which is the ‘strength’ of the constraint.
Animation Time
We’re now ready to animate. 10 FPS is fine for most robots — set this in Render Properties. We just put all the animations one after the other in the timeline, and grab the slice we want, so maybe ‘bear chuckles’ is frame 50 to 70.
IK ball motion. Black dots are keyframes.
Back when we were moving the bear arm by typing in numbers, we had to do every frame. Thankfully not needed now. We only have to pose the robot on enough frames to get the behavior we want. These are
keyframes
. Blender does the frames in between.
By default Blender adds the ease in and ease out, so the servos accelerate smoothly. You can select the IK ball and check the ‘Graph Editor’ if you want to see the curves.
There’s a difference between
posing
and
making a keyframe
.
Posing
the robot doesn’t change the animation. It’s only
making a keyframe
(
i key
) that changes the animation.
In frames 50 to 75 the robot picks something up and moves it. Notice that making the animation was just ‘move ball, make keyframe’ four times. It took under two minutes to make the entire animation. We never animated the actual robot — the inverse kinematics took care of it for us.
From 90 to 105 the robot avoids a nearby table while setting something on it. In practice we would have to run these on the real robot and tweak them a half dozen times. Doing that without software support would be a nightmare.
From Animation to Robot
We’re ready to move our animation to our robot control program. There’s a nifty hack for this. The de facto standard for computer animation files is ‘BioVision Hierarchical’ format (bvh). Blender can export it, though you might need to enable the plugin and select the armature. Here’s a sample.
HIERARCHY
ROOT pedestal
{
OFFSET 0.000000 0.000000 -1.000000
CHANNELS 6 Xposition Yposition Zposition Xrotation Yrotation Zrotation
JOINT base
{
OFFSET 0.000000 0.000000 1.000000
CHANNELS 3 Xrotation Yrotation Zrotation
JOINT upperarm
{
OFFSET 0.000000 0.000000 0.500000
CHANNELS 3 Xrotation Yrotation Zrotation
JOINT lowerarm
{
OFFSET 0.000000 0.000000 3.100000
CHANNELS 3 Xrotation Yrotation Zrotation
End Site
{
OFFSET 0.000000 0.000000 3.100000
}
}
}
}
}
MOTION
Frames: 251
Frame Time: 0.100000
0.000000 0.000000 -1.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000
0.000000 0.000000 -1.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000
0.000000 0.000000 -1.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000 -0.000000 0.000000 -0.000000
... lots of lines of this ...
While this looks unlovely to parse, there’s a hack. We don’t care about the top part (the skeleton). We just want the frames of motion data from the bottom.
Find the line number of the line after ‘Frame Time’, for our file it’s 29, and use
tail -n +29 ./robotarm.bvh | sed --expression='s/ $//g' | sed --expression='s/ /,/g' >robotarm.csv
to get a CSV file of the joint angles for each frame.
Which of all these numbers is what servo? And how do we map these numbers to numbers sent to the servo?
We added an animation (frames 1-6) that exercises each free axis in order — base, upper arm, lower arm — to it’s limits. If we look through the CSV file for which channels change in this order, we find that channel 8 is base, 10 is upperarm, and 13 is lowerarm. If you know the servo position at the limits on the hardware, you can map one to the other.
The actual numbers are the Blender joint positions in degrees, so all that’s left to do is set the servos once every frame time, and your animation will play out in reality.
Don’t forget, if you play animations one after the other, that the second animation needs to start with the robot where the last one left it. And remember that just because you ask for a servo position, you may not get it. If you know your robot moves slowly, asking for snappy action will lose position control. Blender doesn’t know.
Finally, we’d note that the ‘robot’ need not be a robot. Anything that needs scripted animation can be treated this way.
Of course, that’s not all there is to making an intelligent robot assistant. There are other tasks, like vision and grasping, that need real time control, adjusting motion on the fly, making smooth moves between canned animations, easing in and out of animations, and blending animations. But Blender and a simple export routine can get you started.
Half the fun of making robots is playing with them. We hope we’ve inspired you to check out Blender, and maybe inspired some animatronics along the way. | 10 | 5 | [
{
"comment_id": "6471982",
"author": "Rog77",
"timestamp": "2022-05-11T18:16:16",
"content": "https://gazebosim.org/This is cool too.“Gazebo is a collection of open source software libraries designed to simplify development of high-performance applications. The primary audience for Gazebo are robot ... | 1,760,372,698.30704 | ||
https://hackaday.com/2022/05/11/3d-printing-a-carburetor-is-easier-than-you-probably-think/ | 3D Printing A Carburetor Is Easier Than You Probably Think | Al Williams | [
"Engine Hacks"
] | [
"carburetor",
"Venturi"
] | We’ve all been there. You see a cool gadget on the Internet to 3D print and you can’t wait to fire up the old printer. Then you realize it will take 8 different prints over a span of 60 hours, chemical post-processing, drilling, exotic hardware, and paint to get the final result.
[Peter Holderith’s] carburetor design
, however, looks super easy.
If you have experience with real-world carbs, you might wonder how that would work, but as [Peter] points out, carburetors are very simple at the core — nothing more than a venturi. All the extra pieces you think of are for special cases and not necessary for basic operation. We doubt, though, that you could really use the thing in its current form in your car. There are no mounts and since he printed it in PLA, it seems like a hot engine would be a bad idea. However, it does work well with water and an electric blower.
[Peter] mentions that with some more work and the right material, he has no doubt he could create a working practical carb. We think he’s right. But even in this form, it is a great educational project for a budding car enthusiast — like the old transparent V8 engine models, maybe.
Speaking of transparent, we’ve seen — or maybe not seen is a better phrase — a
see-through carburetor
that is also a good demonstrator. If you could perfect a 3D printed carb, it would make
conversion projects
a lot easier. | 27 | 6 | [
{
"comment_id": "6471915",
"author": "Andy Pugh",
"timestamp": "2022-05-11T15:41:54",
"content": "Years ago, at a vintage vehicle rally, a friend of mine bought an old Villiers 2-stroke motorcycle engine in the autojumble.We were there for a few days, and he really wanted to know if the engine would... | 1,760,372,698.778922 | ||
https://hackaday.com/2022/05/11/bare-metal-stm32-using-the-i2c-bus-in-master-transceiver-mode/ | Bare-Metal STM32: Using The I2C Bus In Master-Transceiver Mode | Maya Posch | [
"Hackaday Columns",
"Microcontrollers",
"Slider",
"Software Development"
] | [
"i2c",
"stm32"
] | As one of the most popular buses today for on- and inter-board communication within systems, there’s a good chance you’ll end up using it with an embedded system. I2C offers a variety of speeds while requiring only two wires (clock and data), which makes it significantly easier to handle than alternatives, such as SPI. Within the STM32 family of MCUs, you will find at least one I2C peripheral on each device.
As a shared, half-duplex medium, I2C uses a rather straightforward call-and-response design, where one device controls the clock, and other devices simply wait and listen until their fixed address is sent on the I2C bus. While configuring an STM32 I2C peripheral entails a few steps, it is quite painless to use afterwards, as we will see in this article.
Basic Steps
Assuming that the receiving devices like sensors are wired up properly with the requisite pull-up resistors in place, next we can begin to configure the MCU’s I2C peripheral. We’ll be using the STM32F042 as the target MCU, but other STM32 families are rather similar from an I2C perspective. We’ll also use CMSIS-style peripheral and register references.
First, we set the GPIO pins we wish to use for the I2C peripheral, enabling the appropriate alternate function (AF) mode. This is documented in the datasheet for the target MCU. For the STM23F042 MCU, the standard SCL (clock) pin is on PA11, with AF 5. SDA (data) is found on PA12, with the same AF. For this we need to set the appropriate bits in the GPIO_AFRH (alternate function register high) register:
GPIO_AFRH on STM32F042 with AF values.
By selecting AF 5 for pins 11 & 12 (AFSEL11 & AFSEL12), these pins are then connected internally to the first I2C peripheral (I2C1). This is similar to what we did in a
previous article on the UART
. We also have to enable AF mode for the pin in GPIO_MODER:
STM32F0x2 GPIO_MODER layout (RM0091, 8.4.4).
All of this is done using the following code:
uint8_t pin = 11; // Repeat for pin 12
uint8_t pin2 = pin * 2;
GPIOA->MODER &= ~(0x3 << pin2);
GPIOA->MODER |= (0x2 << pin2); // Set AF mode.
// Set AF mode in appropriate (high/low) register.
if (pin < 8) {
uint8_t pin4 = pin * 4;
GPIOA->AFR[0] &= ~(0xF << pin4);
GPIOA->AFR[0] |= (af << pin4);
}
else {
uint8_t pin4 = (pin - 8) * 4;
GPIOA->AFR[1] &= ~(0xF << pin4);
GPIOA->AFR[1] |= (af << pin4);
}
Note that we want the SCL and SDA pins to be both configured in the GPIO registers to be in a floating state without pullup or pulldown, and in open drain configuration. This matches the properties of the I2C bus, which is designed to be open drain. Effectively this means that the pull-ups on the bus lines keep the signal high, unless pulled down by a master or slave device on the bus.
The clock for the first I2C peripheral is enabled in
RCC_APB1ENR
(enable register) with:
RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;
Some STM32F0 MCUs have only a single I2C peripheral (STM32F03x and F04x), while the others have two. Regardless, if the I2C peripheral exists, after setting its clock enable bit in this register, we can now move on to configuring the I2C peripheral itself as a master.
Clock Configuration
Before we do anything else with the I2C peripheral, we must make sure that it is in a disabled state:
I2C1->CR1 &= ~I2C_CR1_PE;
The clock settings are set in
I2C_ TIMINGR
:
I2C_TIMINGR layout, as per RM0091 (26.7.5)
The reference manual lists a number of tables with timing settings, depending on the I2C clock, e.g. for a 8 MHz I2C clock speed on STM32F0:
IC2_TIMINGR configuration example table. Source: RM0091, 26.4.10.
This table can be converted into a ready-to-use array of values to configure the I2C peripheral with by putting these values into the right order for insertion into I2C_TIMINGR, e.g. for STM32F0:
uint32_t i2c_timings_4[4];
uint32_t i2c_timings_8[4];
uint32_t i2c_timings_16[4];
uint32_t i2c_timings_48[4];
uint32_t i2c_timings_54[4];
i2c_timings_4[0] = 0x004091F3;
i2c_timings_4[1] = 0x00400D10;
i2c_timings_4[2] = 0x00100002;
i2c_timings_4[3] = 0x00000001;
i2c_timings_8[0] = 0x1042C3C7;
i2c_timings_8[1] = 0x10420F13;
i2c_timings_8[2] = 0x00310309;
i2c_timings_8[3] = 0x00100306;
i2c_timings_16[0] = 0x3042C3C7;
i2c_timings_16[1] = 0x30420F13;
i2c_timings_16[2] = 0x10320309;
i2c_timings_16[3] = 0x00200204;
i2c_timings_48[0] = 0xB042C3C7;
i2c_timings_48[1] = 0xB0420F13;
i2c_timings_48[2] = 0x50330309;
i2c_timings_48[3] = 0x50100103;
i2c_timings_54[0] = 0xD0417BFF;
i2c_timings_54[1] = 0x40D32A31;
i2c_timings_54[2] = 0x10A60D20;
i2c_timings_54[3] = 0x00900916;
The other options available here are to let the STMicroelectronic-provided tools (e.g. CubeMX) calculate the values for you, or to use the information in the reference manual to calculate it yourself. At this point in time, the Nodate framework
I2C implementation
for STM32 uses both, with the predefined values as above for STM32F0, and dynamically calculated values for other families.
The advantage of dynamically calculating the timing values is that it doesn’t rely on predefined I2C clock speeds. As a disadvantage there is the additional delay involved in calculating these values, rather than reading them directly out of a table. Whichever approach works best likely depends on the project’s requirements.
With the
I2C_TIMINGR
register thus configured, we can enable the peripheral:
I2C1->CR1 |= I2C_CR1_PE;
Writing Data
With the I2C peripheral ready and waiting, we can begin to send data. Much like with a USART, this is done by writing into a transmission (TX) register and waiting for the transmission to complete. The steps to following here are covered in the helpful flow diagram provided in the reference manual:
Master transmitter flowchart, reproduced from RM0091.
Worthy of note here is that with some checks, such as for I2C_ISR_TC (transfer complete), the idea is not to check once and be done, but rather to wait with a time-out.
For a simple transfer of 1 byte, we would set I2C_CR2 as such:
I2C1->CR2 |= (slaveID << 1) | I2C_CR2_AUTOEND | (uint32_t) (1 << 16) | I2C_CR2_START;
This would start the transfer for a total of 1 byte (left-shifted to the NBYTES position in the I2C_CR2 register), targeting the 7-bit
slaveID
, with the I2C stop condition auto-generated. After the transfer is done (NBYTES transferred), the STOP is generated, which sets a flag in I2C_ISR called STOPF.
When we know we are done with transferring data, we must wait for this flag to be set, followed by clearing the flag in I2C_ICR and clearing the I2C_CR2 register:
instance.regs->ICR |= I2C_ICR_STOPCF;
instance.regs->CR2 = 0x0;
This completes a basic data transfer. For transferring more than a single byte, simply loop the same procedure, writing a single byte into
I2C_TXDR
each cycle and waiting for
I2C_ISR_TXIS
to be set (with requisite time-out). To transfer more than 255 bytes, setting
I2C_CR2_RELOAD
instead of
I2C_CR2_AUTOEND
in I2C_CR2 will allow for a new batch of 255 bytes or less to be transferred.
Reading Data
When reading data from a device, be sure that interrupts are disabled (using
NVIC_DisableIRQ
). Generally, a read request is sent to the device by the microcontroller, with the device responding by sending the requested register contents as reply. For example, if a BME280 MEMS sensor is sent
0xd0
as only payload, it will respond by sending back its (fixed) ID as programmed into that register at the factory.
The basic flowchart for receiving from a device looks as follows:
Master receiver flowchart for STM32F0. Source: RM0091.
The basic idea here is the same as with transmitting data. We configure I2C_CR2 in the same manner as before. Main differences here are that we wait for the I2C_ISR_RXNE flag to become unset, after which we can read the single-byte contents of I2C_RXDR into our buffer.
Just like with writing data, after we read NBYTES, we have to wait for the I2C_ISR_STOPF flag to be set, followed by us clearing it via the I2C_ICR register and clearing the I2C_CR2 register.
Interrupt-based Reads
Setting up interrupts with I2C requires us to activate the interrupts for the I2C peripheral in question. This must be done with the peripheral in a disabled state. After this we can enable the interrupt:
NVIC_SetPriority(I2C1_IRQn, 0);
NVIC_EnableIRQ(I2C1_IRQn);
Interrupts are then enabled on the peripheral by setting the configuration bit:
I2C1->CR1 |= I2C_CR1_RXIE;
Ensure that the appropriately named interrupt handler (ISR) is implemented with the name as specified in the boot-up code:
volatile uint8_t i2c_rxb = 0;
void I2C1_IRQHandler(void) {
// Verify interrupt status.
if ((I2C->ISR & I2C_ISR_RXNE) == I2C_ISR_RXNE) {
// Read byte (which clears RXNE flag).
i2c_rxb = instance.regs->RXDR;
}
}
Don’t forget to add the
extern "C" { }
block around the handler if using a language other than C to prevent function name mangling.
With this code in place, every time the read buffer receives a byte, the ISR will be called and we can copy it into a buffer, or somewhere else.
Multi-Device Usage
As can be surmised at this point, using multiple devices from a single microcontroller transceiver only requires that the correct device identifier is sent before any payload. This is also where clearing the I2C_CR2 register and correctly setting it the next transmit or receive cycle is essential, to prevent any mix-up in device identifiers.
Depending on the code implementation (e.g. with a multi-threaded RTOS), it’s possible that conflicting reads and writes could take place. It’s essential in this case that I2C writes and reads are coordinated so that no data or commands are lost, or sent to the wrong device.
Wrapping up
Using I2C on STM32 is not very complicated, once one clears the hurdle of setting up the clock configuration. That is a topic which may be worthy of its own article, along with advanced topics pertaining to I2C such as clock stretching and noise filtering. By default the I2C peripheral on STM32 MCUs has a noise filter enabled on its I2C inputs, but these can be further configured as well.
As easy as basic reading and writing is with I2C, there is still a whole rabbit hole to explore, also when it comes to implementing your own I2C device on STM32. Stay tuned for further articles on these topics. | 34 | 10 | [
{
"comment_id": "6471901",
"author": "Bobambo",
"timestamp": "2022-05-11T15:11:18",
"content": "Is anybody using a Bus Pirate to talk to I2C devices like this anymore?",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6471912",
"author": "Mike",
"timestam... | 1,760,372,698.716073 | ||
https://hackaday.com/2022/05/10/data-alignment-across-architectures-the-good-the-bad-and-the-ugly/ | Data Alignment Across Architectures: The Good, The Bad And The Ugly | Maya Posch | [
"Hackaday Columns",
"Slider",
"Software Development"
] | [
"data alignment",
"sdram",
"unaligned access"
] | Even though a computer’s memory map looks pretty smooth and very much byte-addressable at first glance, the same memory on a hardware level is a lot more bumpy. An essential term a developer may come across in this context is
data alignment
, which refers to how the hardware accesses the system’s random access memory (RAM). This and others are properties of the RAM and memory bus implementation of the system, with a variety of implications for software developers.
For a 32-bit memory bus, the optimal access type for some data would be a four bytes, aligned exactly on a four-byte border within memory. What happens when unaligned access is attempted – such as reading said four-byte value aligned halfway into a word – is implementation defined. Some hardware platforms have hardware support for unaligned access, others throw an exception that the operating system (OS) can catch and fallback to an unaligned routine in software. Other platforms will generally throw a bus error (SIGBUS in POSIX) if you attempt unaligned access.
Yet even if unaligned memory access is allowed, what is the true performance impact?
A Hardware View
Basic DRAM topology (Credit: Anandtech)
For as nebulous as system memory may seem, its implementation in the form of synchronous dynamic random-access memory (
SDRAM
) is very much bound to physical limitations. A great primer to how SDRAM works is found in a 2010 Anandtech
article by Rajinder Gill
. The essential take-away from this is how the SDRAM modules are addressed.
Each read and write request has to select the target bank on a DIMM (BAn), followed by commands that specify the target row (RAS) and column (CAS). Each row consists out of many thousands of cells, with each SDRAM chip on a DIMM contributing eight bits to the 64-bit data bus found on DDR 3 and DDR 4 DIMMs.
The consequence of this physical configuration is that all access to RAM and intermediate cache(s) is aligned along these physically defined borders. When a memory controller is tasked to retrieve the data for some variable, it is incredibly helpful when this data can be fetched from RAM in a single read operation so that it can be read into a register of the CPU.
What happens when this data is not aligned? It’s possible to read first the initial section of data, then perform a second read to obtain the final section, and then merge the two parts. Naturally, this is an operation that has to be either supported by the memory controller directly, or handled by the operating system.
The memory controller will generate a
bus error
when it is asked to access an invalid address, stumbles across a paging error, or is asked to perform unaligned access when this is unsupported. Platforms such as x86 and derivatives do support unaligned memory access.
When Things Explode
As noted, x86 and also x86_64 are essentially just fine with however you access system RAM with whatever alignment you picked or randomly ended up using. Where things get messier is with other platforms, such as ARM, with the
ARMv7 documentation
listing the properties of the platform in the context of unaligned data access. Essentially, in quite a few cases you will get an alignment fault from the hardware.
In
this IBM article
from 2005, it is covered how the Motorola m68k, MIPS and PowerPC CPUs of that era handled unaligned access. The interesting thing to note here is that until the 68020, unaligned access would always throw a bus error. MIPS CPUs didn’t bother with unaligned access in the name of speed, and PowerPC took a hybrid approach, with 32-bit unaligned access allowed, but 64-bit (floating point) unaligned access resulting a bus error.
When it comes to replicating the SIGBUS alignment error, this is easily done using e.g. the dereferencing of a pointer:
uint8_t* data = binary_blob;
uint32_t val = *((uint32_t*) data);
Here
binary_blob
is assumed to be a collection of variable-sized values, not just 32-bit integers.
While this code will run fine on any x86 platform, on an ARM-based platform such as the Raspberry Pi, dereferencing in this manner is pretty much guaranteed to get you a SIGBUS fault and a very dead process. The problem is namely that when you request to access the
uint8_t
pointer as a 32-bit integer, the chances of this being a properly aligned
uint32_t
are essentially zero.
So what is one to do in this case?
Staying Aligned
Arguments for using aligned memory access are many. Some of the most important ones are atomicity and portability. Atomicity refers to an integer read or write that can be performed in a single read or write operation. In the case of unaligned access, this atomicity no longer applies because it has to read across boundaries. Some code may rely on such atomic reads and writes, which when unaligned access is not taken into account may lead to interesting and sporadic bugs and crashes.
The very obvious elephant in the room, however, is that of portability. As we saw in the preceding section, it is very easy to write code that works great on one platform, but will die pitifully on another platform. There is however a way to write code that will be fully portable, which is in fact defined within the C specification as the one true way to copy data without running into alignment issues:
memcpy
.
If we were to rewrite the earlier code fragment using
memcpy
, we end up with the following code:
#include <cstring>
uint8_t* data = binary_blob;
uint32_t val;
memcpy(&val, data, 4);
This code is fully portable, with the
memcpy
implementation handling any alignment issues. If we execute code like this on e.g. a Raspberry Pi system, no SIGBUS fault will be generated, and the process will live on to see another CPU cycle.
Data structures,
struct
in C, are groupings of related data values. As these are to be placed in RAM in a consecutive manner, this would obviously create alignment issues, unless padding is applied. Compilers add such padding where necessary by default, which ensures that each data member of a struct is aligned in memory. Obviously this ‘wastes’ some memory and increases the size of the structure, but ensures that every access of a data member occurs fully aligned.
For common cases where structs are used, such as memory-mapped I/O on MCUs and peripheral hardware devices, this is generally not a concern as these use only 32-bit or 64-bit registers that are always aligned when the first data member is.
Manually tweaking structure padding
is often possible with compiler toolchains for performance and size reasons, but should only be done with the utmost care.
Performance Impact
But, one may ask, what is the performance impact of ignoring data alignment and just letting the hardware or the OS cover up the complications? As we saw in the exploration of the physical implementation of system RAM, unaligned access is possible, at the cost of additional read or write cycles. Obviously, this would at least double the number of such cycles. If this were to occur across banks, the performance impact could be major.
Single- versus double- versus quad-byte access (Credit: Jonathan Rentzsch, IBM)
In the earlier referenced
2005 IBM article
by Johnathan Rentzsch, a number of benchmark results are provided using single, double, four and eight-byte access patterns. Despite running on a rather sluggish 800 MHz PowerBook G5, the impact of unaligned access was quite noticeable, with two-byte unaligned access being 27% slower than aligned access. For four-byte unaligned access, this was slower than aligned two-byte access, rendering the switch to larger data sizes irrelevant.
When switching to eight-byte aligned access, this was 10% faster than aligned four-byte access. Yet unaligned eight-byte access took an astounding 1.8 seconds for the whole buffer, 4.6 times slower than aligned, on account of the PowerPC G4 not having hardware support for eight-byte unaligned access, with the OS instead performing the requisite merging operations.
The performance impact does not just concern standard CPU ALU operations, but also SIMD (vector) extensions, as detailed by
Mesa et al. (2007)
. Additionally, during development of the x264 codec it was found that using
cacheline alignment
(aligned 16-byte transfer) was 69% faster on one of the most commonly used functions in x264. The implication here being that data alignment goes far beyond system RAM, but also applies to caches and other elements of a computer system.
Much of this comes down to the doubling of (common) operations and the resulting hit to overall performance.
Wrap-up
In some ways the x86 architecture is rather comfortable in how it shields you from the ugly parts of reality, such as unaligned memory access, but reality has a way of sneaking up on you when you least expect it. One such occasion occurred for me a few months ago while doing some profiling and optimizations on a
remote procedure call library
.
After the Cachegrind profiling tool in Valgrind
had shown me
the excessive amount of unaligned copying going on in the internals, the challenge was to not only implement a zero-copy version of the library, but also in-place parsing of binary data. Which led to some of the aforementioned implications with unaligned memory access upon dereferencing of the (packed) binary data.
Although the issue was easily solved using the aforementioned
memcpy
-based solution, it provided me with a fascinating look at SIGBUS faults on ARM-based systems where the same code had worked without a hitch on x86_64 systems. As for the performance impact? The benchmarks before and after the modifications to the RPC library showed a remarkable increase in performance, which may in part have been due to the switch to aligned access.
Even though there are people around who insist that the performance hit from unaligned access is not significant enough today to worry about, the very real impact on portability and atomicity should give anyone pause. Beyond that, it is totally worth it to run the code through a profiler to get a feel for what the memory access patterns are like, and what could be improved or optimized. | 19 | 8 | [
{
"comment_id": "6471571",
"author": "David Given",
"timestamp": "2022-05-10T17:35:05",
"content": "I’d just like to take this opportunity to shake my fist at those architectures which disallow unaligned memory accesses but _don’t_ produce exceptions when you try. They just return bad data. Grrr.Tha... | 1,760,372,698.497974 | ||
https://hackaday.com/2022/05/10/theory-practice-and-ducted-fans/ | Theory, Practice, And Ducted Fans | Elliot Williams | [
"Science",
"Tool Hacks"
] | [
"bench grinder",
"Ducted Fan",
"physics",
"testing"
] | About a year ago, [Wyman’s Workshop] needed a fan. But not just a regular-old fan, no sir. A
ducted
fan. You know, those fancy fan designs where the stationary shroud is so close to the moving fan blades that there’s essentially no gap, and a huge gain in aerodynamic efficiency? At least in theory?
Well, in practice, you can
watch how it turned out in this video
. (Also embedded below.) If you’re more of a “how-to-build-it” type, you’ll want to
check out his build video
— there’s lots of gluing 3D prints and woodworking. But we’re just in it for the ducted fan data!
And that’s why we’re writing it up! [Wyman] made a nice thrust-testing rig that the fan can pull on to figure out how much force it put out. And the theory aimed at 652 g of thrust, which was roughly confirmed. And then you get to power: with a 500 watt motor, he ended up producing 47 watts. Spoiler: he’s overloading the motor, even though he used a fairly beefy bench grinder motor.
So he re-did the fan design, from scratch, to better match the motor. And it performed
better
than the theory said it would. A pleasant surprise, but it meant re-doing the theory, including the full volume of the fan blade, which finally brought theory and practice together. Which then lead him design a whole slew of fan blades and test them out against each other.
He ends the video with a teaser that he’ll show us the results from various inlet profiles and fan cones and such. But the video is a year old, so we’re not holding our breath. Still, if you’re at all interested in fan design, and aren’t afraid of high-school physics, it’s worth your time.
Don’t care about the advantages of ducted fans, but simply want to make your quad look totally awesome? Have we got
the hack for you
! | 9 | 4 | [
{
"comment_id": "6471530",
"author": "peter h",
"timestamp": "2022-05-10T16:40:44",
"content": "IF you are interested in fan design you should also check out major hardware on YouTube :)",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6471635",
"author": "H... | 1,760,372,698.210275 | ||
https://hackaday.com/2022/05/10/large-scale-carbon-capture-without-the-technology/ | Large Scale Carbon Capture Without The Technology | Jenny List | [
"Current Events",
"Engineering",
"Featured",
"green hacks",
"Original Art",
"Slider"
] | [
"accelerated weathering",
"carbon capture",
"co2"
] | We humans are in something of a pickle, as we’ve put too much carbon dioxide in the atmosphere and caused climate change that might even wipe us out. There may still be people to whom that’s a controversial statement, but knowing something needs to be done about it should be a position for which you don’t necessarily have to be a climate change activist glueing yourself to the gates of a refinery.
It’s obvious that we can reduce our CO2 emissions to tackle the problem, but that’s not the only way that atmospheric CO2 can be reduced. How about removing it from the air? It’s an approach that’s being taken seriously enough for a number of industrial carbon capture solutions to be proposed, and even for a pilot plant to be constructed in Iceland. The most promising idea is that CO2 from power stations
can be injected into porous basalt rock
where it can react to form calcium carbonate. All of which is very impressive, but is there not a way that this can be achieved without resorting to too much technology? Time for Hackaday to pull out the back-of-envelope calculator, and take a look.
With So Much CO2 In The Air, Is Removing It Feasible?
This graph helps illustrate the scale of the problem. Efbrazil,
CC BY-SA 4.0
.
First of all, whether to gauge the scale of the problem or to demonstrate the futility of trying to deal with it, it’s worth quantifying how much CO2 we release. There are several slightly different figures depending where you are prepared to look, but most of them agree that humans are responsible for somewhere above 40 billion tons of CO2 per year. Viewed
on a per-capita basis
, Americans are each responsible for 15.52 tons, Canadians for 18.58 tons each, and on the side of the Atlantic where this is being written, Brits each account for 5.5 tons. It’s worth repeating these figures in order to demonstrate the futility of imagining that a few carbon capture plants can scrub the air of CO2 and make a significant difference, because the sheer scale of the problem is such that even the most prolific industrial expansion would find it difficult to keep up.
The first and most obvious way to capture and store large amounts of carbon by non-industrial means is of course in the form of biomass. Growing trees which become enduring forests sounds attractive and on the face of it is pretty easy to do, but how practical is it to make a dent in those emissions?
According to National Georgaphic’s reporting
of an ETH Zurich study published in 2019 an area the size of the USA covered in new forests could reduce atmospheric CO2 by 25% over a hundred years, which makes for a great soundbite, but it’s hardly as though there’s a handy USA-sized piece of land ready to plant trees on. If the global will to plant was there this might be an achievable target, but aside from lip-service on the part of politicians it’s difficult to imagine much movement on such an ambitious project until the waters of Chesapeake Bay are lapping at the front steps of the White House. It’s clear that while forests will play a part in dealing with our CO2 problem, they can’t solve it alone.
Could basalt hold the key to reducing atmospheric CO2? Amcyrus2012,
CC BY 4.0
Another intriguing idea comes to us via a Sheffield University study, that proposes
the UK could reach 45% of its net-zero emissions target by so-called accelerated weathering
. CO2 is naturally absorbed by rocks as they are weathered by the weak acidic effect of CO2 dissolved in rainwater, and this idea proposes amplifying this effect through farmers applying powdered rock as a soil dressing.
It’s an on-the-surface take on the basalt injection idea, where the huge surface area of rock involved would cause much more CO2 to be extracted from the air as it weathers. The CO2 is thus locked away, with consequent offset of emissions. Basalt rock is common enough to make it feasible on paper, but they acknowledge the scale of the operation would require careful handling. Are we ready to lose entire mountains of rock in the service of offsetting climate change? Maybe not yet, but yet again the waters of the Thames estuary lapping around Number 10 Downing Street might sharpen attention.
It’s clear that there’s no magic solution to climate change that will allow us to continue emitting CO2 as though nothing is amiss. There’s no super-forest we can plant, no clever factory we can build, and no magic soil dressing that will scrub the air clean. However what does emerge from reading up on these technologies is that each could play their role in offsetting a portion of emissions, and alongside a meaningful effort to reduce emissions in the first place, might help us achieve the coveted net zero. The question is, do we have the public and political will to do it? | 213 | 40 | [
{
"comment_id": "6471446",
"author": "Lou",
"timestamp": "2022-05-10T14:06:07",
"content": "Don’t trees do that for us already using solar power?",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6471590",
"author": "fiddlingjunky",
"timestamp":... | 1,760,372,699.041092 | ||
https://hackaday.com/2022/05/10/3d-print-finishing-by-spraying-glazing-putty/ | 3D Print Finishing BySprayingGlazing Putty | Dave Rowntree | [
"3d Printer hacks"
] | [
"3d printing",
"FDM",
"print smoothing"
] | Finishing off 3D prints is a labour-intensive process, and getting a good looking, smooth surface suitable for painting takes a lot of time and plenty of practice. Deeper printing layer lines or minor surface defects can be smoother over with a variety of materials, from putties to resins, but the deeper the defect, the thicker the filler and that takes it toll on the surface details – smoothing those out and making fine details less distinct. [Darkwing dad] has another solution that looks pretty easy to achieve, by mixing
acetone with glazing putty
it can be airbrushed over the print surface in one go. After a little experimentation with the ratio of putty to acetone, a wide open nozzle and a low pressure, it was found that a nice even spray could be achieved. Importantly it dries in just a few minutes, enabling multiple coats to be applied in a short space of time.
Once sufficient thickness has been applied, the coating can easily sanded to get a smooth result with the worst of the gaps filled, and the layer lines nicely hidden. The final part of the filling process is more typical, with a few coats of filler primer applied straight from a rattle can, followed by a light sand and you’re good for painting.
We’ve covered smoothing 3D prints practically as long as we’ve been covering 3D printing itself, and there are multiple ways to do this, depending on the filament material, your budget and you tolerance for noxious fumes. Here’s a guide for
smoothing using UV curable resins
, using a
special smoothable filament with IPA
, and finally if this is just too fancy, smelly or expensive, just whip out the old
butane torch and smooth those prints with good old fashioned fire
.
Thanks [Zane] for the tip! | 19 | 13 | [
{
"comment_id": "6471392",
"author": "Andy Pugh",
"timestamp": "2022-05-10T11:16:58",
"content": "It’s maybe worth mentioning that this “Glazing putty” is probably not the same as the putty you use for glazing.There is a sort of very thick paint, called “knifing putty” or “glazing putty” used for fi... | 1,760,372,699.0921 | ||
https://hackaday.com/2022/05/10/becky-stern-david-cranor-and-a-ct-scanner-vs-the-oura-ring/ | Becky Stern, David Cranor, And A CT Scanner Vs The Oura Ring | Elliot Williams | [
"Wearable Hacks"
] | [
"miniaturization",
"ring",
"teardown"
] | If you wonder how it’s possible to fit a fitness tracker into a ring, well, you’re not alone. [Becky Stern] sent one off to get CT scanned,
went at it with a rotary tool
, and then she
made a video about it
with [David Cranor]. (Video embedded below.)
While it’s super cool that you can do a teardown without tearing anything down these days — thanks to the CT scan — most of the analysis is done on a cut-up version of the thing through a normal stereo microscope. Still, the ability to then flip over to a 3D CT scan of the thing is nice.
We absolutely concur with [Becky] and [David] that it’s astounding how much was fit into very little space. Somewhere along the way, [David] muses that the electrical, mechanical, and software design teams must have all worked tightly together on this project to pull it off, and it shows. All along, there’s a nice running dialog on how you know what you’re looking at when tearing at a new device, and it’s nice to look over their shoulders.
Then there’s the bit where [Becky] shows you what a lithium-ion battery pack looks like when you cut it in half. She says it was already mostly discharged, and she didn’t burst into flames. But take it easy out there! (Also, make sure you take your hot xylene out on the patio.)
X-ray machines are of course just the coolest thing when doing a teardown. We’ve seen them used from
fixing multimeters
to
simply looking at servo motors
. | 7 | 5 | [
{
"comment_id": "6471425",
"author": "DeuxVis",
"timestamp": "2022-05-10T13:07:23",
"content": "Tools used in this teardown:…Hammer…And that is how you guarantee a perfect teardown",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6471463",
"author": "Ostracu... | 1,760,372,698.24861 | ||
https://hackaday.com/2022/05/09/will-mister-fool-you-into-learning-fpgas/ | Will MiSTer Fool You Into Learning FPGAs? | Elliot Williams | [
"FPGA",
"Retrocomputing"
] | [
"arcade",
"fpga",
"learning",
"retrocomputing",
"video"
] | What’s the killer app for FPGAs? For some people, the allure is the ultra-high data throughput for parallelizable tasks, which can enable some pretty gnarly projects. But what if you’re just starting out? How about 1980s style video games?
The MiSTer FPGA project created a bit of FPGA hardware that makes it easy to build essentially
any
old school video game or computer platform. That’s a massive clean slate. Of course, you can simply download someone else’s Atari ST or Commodore 64 setup and load it up, but if you want to
learn
FPGAs while recreating old-school video game machines, you’re going to want to get your hands dirty.
[Mister Retro Wolf] started up
a video series last winter
(trailer embedded below) where he’s embarked on a project to recreate a classic video game machine from the ground up using the MiSTer FPGA platform. In particular, he’s going to recreate the Namco Tank Battalion arcade game, from the schematics, in Verilog.
This is literally building a 6502-based video game machine from scratch (in gateware), so if you’re interested in retrocomputing
or
FPGAs, you’ll have something to learn here. He’s gotten through the CPU, screen, tilemap graphics, and memory so far, but it’s not done yet. To follow along, get yourself some hardware and you can probably catch up.
We’ve covered
the MiSTer FPGA project
before, of course, because we think it’s cool. And if a video game arcade machine is going to be your gateway drug into the seedy world of programmable gates, then so be it. | 45 | 6 | [
{
"comment_id": "6471298",
"author": "Olaf",
"timestamp": "2022-05-10T05:37:38",
"content": "My Problem with FPGAs there are very few reason to use them for private project, especially in these days when it is easy to use fast MCUs like RP2040. Of course, I know that there a things you can only do w... | 1,760,372,698.639724 | ||
https://hackaday.com/2022/05/09/avx-512-when-the-bits-really-count/ | AVX-512: When The Bits Really Count | Matthew Carlson | [
"Software Development"
] | [
"assembly",
"AVX-512",
"benchmarking",
"intel",
"optimization",
"SIMD",
"x86",
"x86_64"
] | For the majority of workloads, fiddling with assembly instructions isn’t worth it. The added complexity and code obfuscation generally outweigh the relatively modest gains. Mainly because compilers have become quite fantastic at generation code and because processors are just so much faster, it is hard to get a meaningful speedup by tweaking a small section of code. That changes when you introduce SIMD instructions and need to decode lots of bitsets fast. Intel’s
fancy AVX-512 SIMD instructions can offer some meaningful performance gains with relatively low custom assembly
.
Like many software engineers, [Daniel Lemire] had many bitsets (a range of ints/enums encoded into a binary number, each bit corresponding to a different integer or enum). Rather than checking if just a specific flag is present (a bitwise and), [Daniel] wanted to know all the flags in a given bitset. The easiest way would be to iterate through all of them like so:
while (word != 0) {
result[i] = trailingzeroes(word);
word = word & (word - 1);
i++;
}
The naive version of this look is very likely to have a branch misprediction, and either you or the compiler would speed it up by unrolling the loop. However, the
AVX-512 instruction set on the latest Intel processors
has some handy instructions just for this kind of thing. The instruction is
vpcompressd
and Intel provides a handy and memorable C/C++ function called
_mm512_mask_compressstoreu_epi32
.
The function generates an array of integers and you can use the
infamous
popcnt
instruction to get the number of ones
. Some early benchmark testing shows the AVX-512 version uses 45% fewer cycles. You might be wondering, doesn’t the processor downclock when wide 512-bite registers are used? Yes. But even with the downclocking, the SIMD version is still 33% faster. The
code is up on Github
if you want to try it yourself. | 16 | 7 | [
{
"comment_id": "6471239",
"author": "Brane2",
"timestamp": "2022-05-10T02:07:46",
"content": "Which is speaks against AVX.All that extra hardware just to get 33% speed increase in some obscure case.Vector units have been marketed as massive speed boost for many cases.With opening of GPUs for compu... | 1,760,372,699.144671 | ||
https://hackaday.com/2022/05/11/modifying-old-fonts-in-the-name-of-baseball/ | Modifying Old Fonts In The Name Of Baseball | Kristina Panos | [
"Software Hacks"
] | [
"backwards K",
"baseball",
"bitmap",
"font",
"glyph"
] | Baseball is in full swing again, and having recently accepted a position with Major League Baseball, [Ty Porter] is warming up with a big contribution to the MLB LED Scoreboard project —
modifying 20-some old fonts to support baseball’s ‘ꓘ’ character
that indicates a special strikeout with a called third strike (meaning the batter didn’t take a swing).
The problem is that Major League Baseball-the-entity recently deprecated the original data source for
the scoreboard project
. This called for a huge refactor of the codebase, including previously-patched fonts which were now showing either the font’s default no-character character, or nothing at all.
Fortunately, BDF font files are fairly human-readable and make reference to
bitmap
, which is an actual bitmap in hex. [Ty] settled on Unicode A4D8 (ꓘ), a character from the Tibeto-Burman language Lisu that certainly looks good enough to this baseball fan. Then it became a matter of mirroring the bitmap for ‘K’. [Ty] tried a few things like reversing the nibbles and looking up each one in a table, but that also mirrors the padding, which is bad news.
Then he tried not reversing the nibbles and just looked them up in a table, but this approach dropped and added bits unintentionally. Finally, he tried reversing the order, looking up the reversed nibble, and shifting each byte until there was no padding. This worked for most of the 20 fonts [Ty] patched. The others fell in line with some manual work.
Not much of a baseball fan?
You’re almost guaranteed to like this one
, especially if you hate mayo. | 4 | 4 | [
{
"comment_id": "6471867",
"author": "Feinfinger (WIMP at work)",
"timestamp": "2022-05-11T12:48:14",
"content": "Baseball? I know base band and harmonics…But …https://xkcd.com/2606/… don’t we need all of those too?",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id... | 1,760,372,699.184471 | ||
https://hackaday.com/2022/05/11/summers-coming-let-mowerino-cut-your-grass/ | Summer’s Coming – Let Mowerino Cut Your Grass | Al Williams | [
"Arduino Hacks",
"Robots Hacks"
] | [
"Arduino Mega 2560",
"autonomous",
"bluetooth",
"robot lawnmower"
] | In the Northern hemisphere, summer is about to hit us full bore. While we love the season, we do dislike lawn maintenance. Apparently, so does
[salmec] who developed the Mowerino
around an Arduino Mega 2560 board.
As you might expect, the robot uses sharp blades so, you probably want to be careful. There are sensors that allow the machine to self-navigate or you can control it via Bluetooth. This is one of those things that seems easy until you try to actually do it. Nylon trimmer string is probably safer, but it breaks and it is hard to keep it cutting. Blades are more robust but also riskier to things like rocks, fingers, and pets.
Moving around in the yard is also an issue. The Mowerino has some ordinary-looking caster wheels in the front. That might be a place for improvement since most yards are not friendly to that kind of wheel. The other thing we worried about is what happens to the grass clippings. Around here, a week of rain means your mower will choke on grass clippings. On the other hand, the Mowerino has a smaller blade so maybe that helps mitigate clipping clogging.
Overall, though, it looks like it might be a good place to start if you dream of robot groundskeepers patrolling your estate. Most of the mowers we see like this
have big wheels
. But, of course,
not all of them
. | 22 | 7 | [
{
"comment_id": "6471817",
"author": "ThisGuy",
"timestamp": "2022-05-11T08:16:13",
"content": "I think generally the idea with robot mowers is that they cut the grass often enough that clogging with trimmings is far less likely. Us lazy humans cut the grass MAYBE once a week (if we feel like it) so... | 1,760,372,699.239738 | ||
https://hackaday.com/2022/05/10/a-simple-binary-coded-decimal-watch/ | A Simple Binary Coded Decimal Watch | Lewin Day | [
"clock hacks"
] | [
"clock",
"watch"
] | Analog and LCD watches are both useful designs, but ultimately are mainstream timepieces. Using
a binary watch
is an easy way to set one’s self apart as a tech enthusiast, while impressing your hacker friends to boot.
One such build comes to us from [vishalsoniindia], and it uses a single bare PCB which is designed to mate directly to a traditional watch strap. The single tactile button on board is used to activate the watch, showing the current time in hours and minutes in binary-coded decimal on the watch’s LEDs. Long-pressing the button puts the watch in setting mode to correct the time as needed.
The watch relies on an ATtiny85 microcontroller, a lightweight and compact design which is more than powerful enough to run a simple watch. It’s paired with a 74HC595 shift register to run all the LEDs from a minimum number of pins, and there’s also a TP4056 charging circuit on board to keep the lithium-polymer battery topped off.
A project like this is a great way to learn all manner of basic electronics skills, from PCB design, to SMD soldering and even working with basic logic parts like shift registers. As a bonus, you get a cool watch out of it to boot.
We’ve seen some similar designs
over the years
,
as varied
as the hackers that build them. Video after the break. | 15 | 7 | [
{
"comment_id": "6471810",
"author": "Gösta",
"timestamp": "2022-05-11T07:21:11",
"content": "Smart and good looking :-) Maybe binary watches will turn into mainstream fashion statements.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6471878",
"auth... | 1,760,372,699.327821 | ||
https://hackaday.com/2022/05/10/this-golf-club-uses-machine-learning-to-perfect-your-swing/ | This Golf Club Uses Machine Learning To Perfect Your Swing | Robin Kearey | [
"Games",
"News"
] | [
"accelerometer",
"golf",
"machine learning",
"swing"
] | Golf can be a frustrating game to learn: it takes countless hours of practice to get anywhere near the perfect swing. While some might be lucky enough to have a pro handy every time they’re on the driving range or putting green, most of us will have to get by with watching the ball’s motion and using that to figure out what we’re doing wrong.
Luckily, technology is here to help: [Nick Bild]’s
Golf Ace is a putter that uses machine learning to analyze your swing
. An accelerometer mounted on the shaft senses the exact motion of the club and uses a machine learning algorithm to see how closely it matches a professional’s swing. An LED mounted on the club’s head turns green if your stroke was good, and red if it wasn’t. All of this is driven by an Arduino Nano 33 IoT and powered by a lithium-ion battery.
The Golf Ace doesn’t tell you what part of your swing to improve, so you’d still need some external instruction to help you get closer to the ideal form; [Nick]’s suggestion is to bundle an instructor’s swing data with a book or video that explains the important points. That certainly looks like a reasonable approach to us, and we can also imagine a similar setup to be used on woods and irons, although that would require a more robust mounting system.
In any case, the Golf Ace could very well be a useful addition to the many gadgets that try to improve your game. But in case you still end up frustrated, you might want to try
this automated robotic golf club
. | 2 | 2 | [
{
"comment_id": "6471906",
"author": "Bobambo",
"timestamp": "2022-05-11T15:18:04",
"content": "This article is just dying for an illustration featuring Mr. Meeseeks!",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6472009",
"author": "Gösta",
"timestam... | 1,760,372,699.277403 | ||
https://hackaday.com/2022/05/10/number-like-its-1234-ad-with-this-cistercian-keypad/ | Number Like It’s 1234 AD With This Cistercian Keypad | Dan Maloney | [
"Misc Hacks"
] | [
"Cistercian",
"keypad",
"number pad",
"rp2040",
"usb",
"wood"
] | Don’t feel bad if you don’t know what Cistercian numbers are. Unless you’re a monk of the Order of Cistercia, there’s really no reason for you to learn the cipher that stretches back to the 13th-century. But then again, there’s no reason not to use the number system to make
this medieval-cool computer number pad
.
If you haven’t been introduced to the Cistercian number system, it’s actually pretty clever. There are several forms of it, but the vertical form used here by [Tauno Erik] is based on a vertical stave with nine glyphs that can be attached to or adjacent to it. Each glyph stands for one of the nine numerals — one through nine only; there’s no need for a zero glyph. There are four quadrants around the stave — upper right, upper left, lower right, and lower left — and where the glyph lies determines the multiplier for the glyph. So, if you wanted to write the number “1234”, you’d overlay the following glyphs into a single symbol as shown.
[Tauno]’s Cistercian keypad, admittedly more of an art and history piece than a useful peripheral, somehow manages to look like it might have been on the desk of [Theodoric of York, Medieval Accountant]. Its case is laser-cut birch plywood, containing a custom PCB for the 20 keyboard switches and the Xiao RP2040 MCU that runs the show. Keycaps are custom made from what looks like oak combined with a 3D-printed part, similar to
his previous wooden keycap macro pad
. Each of the nine Cistercian glyphs is hand-carved into the keycaps, plus an imaginary glyph for zero, which wasn’t part of the system, as well as operators and symbols that might have baffled the medieval monks.
The native Cistercian system is limited to numbers between 1 and 9,999, so we’ll guess that the keypad just outputs the Arabic numeral corresponding to the Cistercian key pressed and doesn’t actually compose full Cistercian numbers. But the code to do that would be pretty easy, and the results pretty cool, if a bit confusing for users. Even if it’s just for looks, it’s still a cool project, and we doff the hood of our monkish robe to [Tauno] for this one. | 14 | 5 | [
{
"comment_id": "6471693",
"author": "Craig",
"timestamp": "2022-05-11T00:05:43",
"content": "If there is no zero glyph, how would one write the number, say, 1204?",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6471695",
"author": "Mike Shawaluk",
... | 1,760,372,699.605135 | ||
https://hackaday.com/2022/05/10/framework-board-gets-this-round-display-pc-rolling/ | Framework Board Gets This Round Display PC Rolling | Tom Nardi | [
"classic hacks",
"computer hacks"
] | [
"Circular LCD",
"framework",
"mainboard",
"mechanical keyboard",
"motherboard",
"retro",
"round LCD"
] | The Framework laptop is already a very exciting prospect for folks like us — a high-end computer that we can actually customize, upgrade, and repair with the manufacturer’s blessing? Sounds like music to our ears. But we’re also very excited about seeing how the community can press the modular components of the Framework into service outside of the laptop itself.
A case in point, this
absolutely gorgeous retro-inspired computer built by [Penk Chen]
. The
Mainboard Terminal
combines a Framework motherboard, five inch 1080 x 1080 round LCD display, and OLKB Preonic mechanical keyboard into a slick 3D printed enclosure that’s held together with magnets for easy access. Compared to the Raspberry Pi that we usually find tucked into custom computer builds like this, the Framework board offers incredible performance, not to mention the ability to run x86 operating systems and software.
[Penk] has Ubuntu 22.04 LTS loaded up right now, and he reports that everything works as expected, though there are a few
xrandr
commands you’ll need to run in order for the system to work properly with the circular display. The standard Ubuntu UI doesn’t look particularly well suited to such an unusual viewport, but we imagine that’s an issue you’ll have to learn to live with when experimenting with such an oddball screen.
It was just a few weeks ago that we brought you word that
Framework was releasing the mechanical drawings for their Mainboard module
, and we predicted then that it would be a huge boon to those building bespoke computers. Truth be told we expected a cyberdeck build of some sort to be the first one to hit our inbox, but you certainly won’t catch us complaining about
seeing more faux-vintage personal terminals
. | 15 | 10 | [
{
"comment_id": "6471644",
"author": "RW ver 0.0.3",
"timestamp": "2022-05-10T20:02:56",
"content": "I hope it has an eye of Sauron “screensaver”",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6471678",
"author": "Grawp",
"timestamp": "2022-0... | 1,760,372,699.488083 | ||
https://hackaday.com/2022/05/10/thinnest-keyboard-uses-cherry-diy-doubleshot-method/ | Thinnest Keyboard Uses Cherry DIY Doubleshot Method | Kristina Panos | [
"how-to",
"Peripherals Hacks"
] | [
"custom keycaps",
"double shot keycaps",
"ISO Enter",
"keyboard",
"keycaps",
"low-profile"
] | As with any other community, it takes all kinds to make the keyboard world go ’round. Some like them thicc — more backing for the clacking and all — but some like them sleek and prefer the slimmest possible keyboard. For now and the foreseeable future, the go-to method for making whisper-thin keebs is to use Kailh Choc switches, because that’s about all that’s out there.
But chocs aren’t for everyone, and there are plenty of die-hard Cherry fans out there that want it both ways. Being one among them,
[Khmel] set about designing the lowest-profile possible keyboard (and caps) that uses standard Cherry-sized keyswitches
. Shut up and take your money? Well, okay, but
the case and keycap files are all available on Thingiverse
, so.
The whole video is great, and at less than 2½ minutes long, it’s definitely worth your time. There are a few little gems of wisdom sprinkled throughout, like printing keycaps standing up on their backsides (like where they would have a little flash dot if they were factory-molded). This gives them a nice texture thanks to the layer lines. But the real reason we’re here today is this DIY method for making doubleshot keycaps with little fuss that [Khmel] just tosses out there toward the end.
Trust us, there’s a piece of glass there.
Traditionally,
doubleshot keycaps
are made with two layers of plastic — one for the legend, and one for the rest. This produces a quite durable keycap and (used to be the norm), but the expensive process gave way to laser-etched and pad-printed keycap legends in the ’90s. [Khmel] was able to fake the look by printing legends at 0.25 layer height and then fusing each one to its respective keycap by laying a thin piece of glass (think microscope slide) on top and applying a soldering iron for a few seconds. Classy!
Tweezing tiny legends not really your kind of tedium?
Here’s a method for DIY waterslide decals instead
.
via
KBD #77 | 24 | 10 | [
{
"comment_id": "6471631",
"author": "Dude",
"timestamp": "2022-05-10T19:32:48",
"content": "I bought a Cherry (?) brand slim keyboard and it measures at 20.2 mm thick at the ESC key, and 12.5 mm at the leftmost CTRL key.Scissor switch keys FTW – although it’s a little bit too clacky for my liking. ... | 1,760,372,699.551531 | ||
https://hackaday.com/2022/05/09/all-the-sticky-labels-you-could-ever-need-no-drm-just-masking-tape/ | All The Sticky Labels You Could Ever Need: No DRM, Just Masking Tape | Jenny List | [
"cnc hacks"
] | [
"grbl",
"label printer",
"masking tape",
"plotter"
] | Printable sticky labels are a marvelous innovation, but sadly also one beset by a variety of competing offerings, and more recently attempts by manufacturers to impose DRM on their media. Fortunately they don’t have to rely on expensive printers or proprietary rolls of stickies, as [michimartini] demonstrates with
the masking tape plotter
. It’s a tiny pen plotter that writes your label onto the tape.
At its heart is the popular
grbl
G-code to motion parser, and its mechanism uses the lead screw axis from a DVD drive. Not for this project simply another hacked-apart drive mechanism though, for it has a custom-designed carriage for the axis. It’s 3D printed, and to ensure the least friction possible for a pen using only its weight to keep contact with the tape it was heated up once assembled to ensure all parts had a chance to bed in. Meanwhile the tape roll forming the X axis is turned directly by a standard stepper motor.
We like this project a lot, and look forward to any refinements to the idea. Meanwhile, it’s not the first
custom label printer we’ve shown you
. | 58 | 20 | [
{
"comment_id": "6471184",
"author": "James",
"timestamp": "2022-05-09T23:12:40",
"content": "To save people hunting for it…https://www.youtube.com/watch?v=js4_p1S9vIM",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6471201",
"author": "rpavlik",
... | 1,760,372,699.778767 | ||
https://hackaday.com/2022/05/09/a-raspberry-pi-as-an-offboard-display-adapter/ | A Raspberry Pi As An Offboard Display Adapter | Jenny List | [
"Raspberry Pi"
] | [
"display adapter",
"raspberry pi",
"screen capture",
"Wayland"
] | The humble USB-C port has brought us so many advantages over its USB ancestors, one of which is as a handy display output for laptops. Simply add an inexpensive adapter and you can hook up everything from a mobile phone upwards to an HDMI display or projector. There’s a snag though, merely having USB-C is not enough as the device has to support the display feature. It’s a problem [Gunnar Wolf] had to face with a Lenovo ARM laptop, and his solution is unexpected. Instead of an adapter,
he’s used a Raspberry Pi 3
and some software tricks.
The obvious route to an off-board Pi mirroring onboard video is to use VNC, which he tried but found wanting due to lagginess. As a user of the Wayland compositor he found he could instead use
wf-recorder
and send its output to a stream, and thus capture his screen in a way that the Pi could read over the network. It’s not quite as convenient a solution as a pure-hardware adapter, but at least it allowed him to share the screen.
It’s surprising how often we find projects needing to mirror the display of a computer using what hardware is to hand, at least
this one is more elegant than some others
. | 6 | 4 | [
{
"comment_id": "6471160",
"author": "Xaland versus Waland?",
"timestamp": "2022-05-09T21:53:20",
"content": "Is it just me or is Wayland still being forced as a change despite a host of software issues? Don’t get me wrong, I like the idea of it but even Nvidia has sort of pushed back recently and i... | 1,760,372,699.648126 | ||
https://hackaday.com/2022/05/09/autogyro-models-are-hard-even-for-peter-sripol/ | Autogyro Models Are Hard — Even For [Peter Sripol] | Adam Fabio | [
"hardware",
"Transportation Hacks"
] | [
"autogyro",
"Gyrocopter",
"gyroplane",
"peter sripol",
"R/C",
"radio control",
"rc"
] | Aviation consists of two major groups. Airplane enthusiasts, and helicopter enthusiasts. The two groups rarely get along, each extolling the virtues of their chosen craft. Somewhere in between are autogyro folks. People who like vehicles that blend the best (or worst) of both airplanes and helicopters. Aviation master [Peter Sripol] has
dipped his toes into the autogyro world, but not without some trouble
.
Autogyros are propelled by a propeller, like a plane. They also have a tail section that works similar to a fixed-wing aircraft. That’s where the similarities end though. Lift for autogyros comes in the form of a rotating set of blades, much like a helicopter. Autogyro rotors aren’t powered during flight. They utilize
autorotation
. The blades freewheel, spun by the air as the craft moves forward.
[Peter] recently got his hands on a full-scale autogyro. So it made sense to build a model to help learn to fly. This isn’t [Peter’s] first attempt with autogyro models. He’s built a few in the past, with limited success. This time he started from scratch and ran into even more problems!
[Peter] found that most autogyro models use gyroscopes to aid the pilot. These devices won’t be available on his full-scale ultralight, so [Peter] wanted to build a craft that flew without electronic assistance. His first designs resulted in crashes just after liftoff. [Peter] scaled the design up, because bigger models are always more stable in the air. He also found that aerodynamics don’t scale exactly to models, so some design changes were needed. Extending the tail finally gave him a stable craft, but it still had problems. Changes to the rotor head and blade design turned out to be the real keys to getting the model to work. The details are all available in
this 49 page (and counting!) R/C Groups forum thread
.
The nice thing about this model is that it’s not hard to build. Most of the frame is built from towel bars and aluminum bits you can pick up at the local hardware store. The blades are 3D printed with aluminum spars. [Peter] has promised to upload the design files by the end of May.
Curious about autogyros? We’ve covered
models
and
full-scale versions
right here at Hackaday. | 12 | 7 | [
{
"comment_id": "6471096",
"author": "CRJEEA",
"timestamp": "2022-05-09T18:39:10",
"content": "“not had to build” – not hard to build.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6471098",
"author": "The Commenter Formerly Known As Ren",
"... | 1,760,372,699.898024 | ||
https://hackaday.com/2022/05/09/how-a-smartphone-is-made-in-eight-easy-blocks/ | How A Smartphone Is Made, In Eight “Easy” Blocks | Matthew Carlson | [
"Hackaday Columns",
"Phone Hacks",
"Slider"
] | [
"breakdown",
"cellphone",
"smartphone"
] | The smartphone represents one of the most significant shifts in our world. In less than thirteen years, we went from some people owning a dumb phone to the majority of the planet having a smartphone (~83.7% as of 2022, according to Statista). There are very few things that a larger percentage of people on this planet have. Not clean water, not housing, not even food.
How does a smartphone work? Most people have no idea; they are insanely complicated devices. However, you can break them down into eight submodules, each of which is merely complex. What makes them work is that each of these components can be made small, at massive economies of scale, and are tightly integrated, allowing easy assembly.
So without further ado, the fundamental eight building blocks of the modern cellphone are: the application processor, the baseband processor, a SIM card, the RF processor, sensors, a display, cameras & lenses, and power management. Let’s have a look at them all, and how they fit together.
Application Processor
When you think computer or, by extension, smartphone, you think of a single cohesive unit powering what your smartphone does. However, even putting aside the universal multicore processors, the processing inside your phone is not a single voice but a cacophony of voices chattering away at each other. The application processor (AP) is what we think of as this traditional brain. It features a large multi-core CPU, almost always ARM-based.
These APs might come as part of an extensive system on a chip (SoC). The SoC can include memory, the GPU, digital signal processors, image processing units, the modem (which we will get to later), and other minor things like video decoders and AI engines.
But back to the CPU. It runs your phone’s operating system and is primarily the ring leader in your phone’s decisions. These days, it often has big powerful cores that consume much more power and small cores that consume much less energy. This is usually done by making the smaller cores single dispatch, in-order, while the larger cores are massive multiscalar out-of-order cores. We could spend quite a long time breaking down the various parts of a modern processor, but we think you might learn better
by making your own
or
fixing a broken simulation
.
Baseband Processor
The baseband processor (BP) is an entirely separate processor that the AP can talk to, often referred to as a modem. Even the iPhone, which has its own custom AP, uses a Qualcomm or Intel BP. Generally, Wi-Fi, Bluetooth, and other radio-type communications are handled by the AP and the BP focuses entirely on cellular communications. Even the specs for the ancient 3G protocol are long and dense, with each revision adding intricacy on top. Complex power amplifiers, multiband-multimode transceivers, and other techniques add to a complex circuit.
Baseband processors have their own firmware and RAM, and the codebases are opaque manufacturer-specific binaries. There’s a good talk on
hacking an old 3G USB modem
. In fact, some of the Intel modems in some iPhone
models had x86 processors in them
. [Comsecuris]
detailed a buffer overflow they found in many iPhone modems
that gives some helpful information on the internal workings.
SIM Card
We think of them as just being storage, but the small piece of carrier-branded plastic with the handfull of gold contacts has a small chip inside it. It’s all according to spec, but the interactions between AP, BP, and SIM cards has grown quite complex. SIM cards
come into the security limelight
, as they are updated over the air with little control from the user. They can talk to the BP without the AP knowing. Can you imagine your phone calling or texting someone, and the only way you would know would be by auditing your phone records?
Your phone already does so
. We’re slowly moving away from SIM and towards eSIM, but that’s a ways off for most of us.
Sensors
Sensors make your phone much more aware of its surroundings. Cameras, GPS, microphones, distance sensors, proximity sensors, gyroscopes, accelerometers, altimeters, magnetometers,
LIDAR
, fingerprint sensors, radar sensors, ambient light level sensors, and pressure sensors are all common additions to adorn our smartphones.
The amount of data streaming in can be truly astounding. Many of these sensors have their own microprocessor to handle the load and present a more cohesive view to the AP. In fact,
some phones have coprocessors
to handle these different sensors in more power-efficient ways. So we have the AP talking to a coprocessor, talking to microprocessors, and reading sensors. All these sensors go a long way towards making a smartphone much more useful in day-to-day life. You can call, get directions, rotate for portrait mode, or
use your phone for physics experiments
.
Display
Smartphone screens are a marvel. They have a resolution that matches or beats many household TVs while being high quality and affordable.
Used phone screens are often used in projects
here on Hackaday as they’re easy to find and then drive. We see advancements here with
OLED displays
and
microLED displays
. As the screen is often the front of your phone, having it
heal itself would be pretty handy
. There’s nothing exceptional about the displays in smartphones as they’re just miniaturized versions of larger panels.
Cameras
Modern cameras on smartphones are crazy.
As an example, modern smartphone lenses are crazy. Here's the design used on the iPhone 7; every single lens element is highly aspherical with a very large number of correction coefficients; this lens completely breaks the existing poly optics implementation from the 2016 paper.
pic.twitter.com/cYr9qsa5Bj
— Yining Karl Li (@yiningkarlli)
February 27, 2022
Lenses and sensors are unique in many ways. Unlike displays, where you can shrink the process, light and lenses get weird when they’re small. So, how do you capture more light in a smaller area? An
incredible
(though long)
resource on lens design is here
that details how we do that. The lens design is a complex art with a long history of iteration and improvement since the early 1800s. There are several notable inventions listed in the link above. We could do a whole article just about camera lenses. In particular, the long exposures of old cameras had just as much to do with lens design as it did film.
The lens and sensor are going crazy, but the Image Signal Processor (ISP) that processes the photos
is going crazy as well, in some cases blatantly lying
. Like a traditional Signal Processor, the ISP takes an image and processes it, applying some transformation. However, while some filters are done on the AP — think the Snapchat filters — the actual reading of the sensor and forming a picture are done by the ISP.
Power Management
Phones are mobile and expected to last a long time on battery. Like other battery-powered products, there’s a battery management system (BMS) that supports the battery. However, there are some pretty high demands placed on it. It has to charge wirelessly and at incredibly high rates and often. On the flip side, efficiency is considered in all the other parts that we’ve discussed. There are power modes on every module. Every component is scrutinized against the budget, both monetarily and against the power budget.
Put it All Together and Throw it Away!
In our modern society, we replace our smartphones frequently, and our world seems to have no end to our hunger for them. So with more and more discarded smartphones on hand each year, packed with features and processors,
why aren’t we hacking on them more
? They
make a perfect companion for your 3D printer
.
There have been some
attempts to make smartphones modular
, allowing you to swap out the baseband processor, the display, or the camera. However, the concept
seems to have stalled
. Particularly the application processor, baseband processor, and sensor unit are so tightly connected in many modern phones, that swapping out any of the component parts would be like redesigning the whole thing from scratch. Smartphones are valuable because of their scale and tight integration, and it’s just hard to beat that.
Still, it’s
incredible how far we’ve come
in smartphones in general. We at Hackaday can’t wait to see what the next decade holds. | 22 | 9 | [
{
"comment_id": "6471086",
"author": "d00med",
"timestamp": "2022-05-09T17:47:01",
"content": "Bring back easily replaceable batteries, make it easy to load the operating system of one’s choosing, and hardware switches to disable the modem, mics. and cameras.",
"parent_id": null,
"depth": 1,... | 1,760,372,699.848099 | ||
https://hackaday.com/2022/05/09/verbot-goes-to-the-dark-side/ | Verbot Goes To The Dark Side | Adam Fabio | [
"Robots Hacks",
"Toy Hacks"
] | [
"1980's",
"omnibot",
"randi rain",
"retro",
"robot",
"Tomy",
"verbot"
] | What happens to old, neglected 1980s toy robots? According to the [Randi Rain],
they turn to the dark side
! Way back in the ’80s, Tomy had an entire line of robots — from keychain wind-up toys to
rolling, talking machines almost 2 feet tall
. Tucked into the middle of this line was Verbot. Verbot’s claim to fame is that it is a voice-controlled robot. More than that, it was speaker-dependent. Train the robot with commands like “go forward” and then watch as it responds to your every command.
As you might guess, the speech recognition wasn’t great by today’s standards. Recognition was handled by a Microcontroller — a Mitsubishi product that was possibly a mask programmed 8051 variant. Pretty novel for an 80s toy —
in fact, there’s a patent for it
.
Verbot Mechanical Interrogator in green
The real magic in Verbot is in the mechanical design. Verbot could move forward, backward, turn, “talk”, lift, and lower its arms. It did all of that with just one electric motor. [Randi] explains this mechanical magic during her teardown. Verbot used a “Mechanical Interrogator”, which really is a column of planetary gears, cogs, and levers. The device looks like it belongs in a
Curta mechanical calculator
more than a plastic toy. The whole system works through a clever operation of switches, which inform the microcontroller when a mechanical function is selected. The micro then reverses the motor to perform the operation.
The particular Verbots [Randi] is working on in this video are definitely showing their age. Yellowing, cracked plastic, and other problems had turned them both into basket cases. Rather than go the
retrobright
route, [Randi] decided to make one evil robot from the two. A coat of black paint, some orange highlights later, she had one working robot that looked more like Darth Vader than a yellowed toy.
[Randi’s] background as a professional propmaker and magician has given her some excellent casting skills. She easily creates resin replacements Verbot’s translucent red eyes and buttons using a silicon mold of the old parts.
The end result of this project is a working, rolling dark side Verbot. This little ‘bot would make an excellent companion for any Dark Trooper! | 14 | 5 | [
{
"comment_id": "6471074",
"author": "cliff claven",
"timestamp": "2022-05-09T17:19:20",
"content": "The 1790’s to 1990’s had a fair number of single motor/multiple function toys. The Armatron comes to mind, as well.I would guess the logic to be that molded gears were cheap compared to the electroni... | 1,760,372,700.083609 | ||
https://hackaday.com/2022/05/09/will-we-ever-shake-the-polaroid-picture/ | Will We Ever Shake The Polaroid Picture? | Kristina Panos | [
"Featured",
"Interest",
"Original Art",
"Rants",
"Slider"
] | [
"instant camera",
"photography",
"polaroid",
"Polaroid SX-70"
] | Today, most of us carry supercomputers in our pockets that happen to also take instantly-viewable pictures.This is something that even the dumbest phones do, meaning that we can reasonably draw the conclusion that photographic capability has become a basic feature of everyday carry, a necessity of 21st century life.
Despite the unwashed masses of just-plain-bad photographs clouding the digital landscape, photography itself remains as important as ever so we can retain and disseminate information as history unfolds. In a sense, the more instant, the better — unless it comes at the cost of image quality. The invention of photography is on par with the printing press or with language itself in that all three allow us to communicate within our own time as well as preserve The Way Things Were in frozen silence. And no invention made vivid preservation more convenient than the instant camera.
The original Polaroid SX-70 Land camera. Image via
New Atlas
Instant Memories
Peter Gabriel’s eponymous 1980 release. Image via
Wikipedia
This year, the iconic Polaroid SX-70 turns 50 years old
. This was the first truly instant SLR camera, an engineering marvel containing over 300 transistors. Every film pack had a battery inside, so in theory, no moment would go uncaptured.
Polaroid began producing instant-film cameras in 1948, but for the first 25 years or so, the developing process was quite involved. With the advent of the SX-70 in 1972, one could freeze a moment in time and hold it in their hands a minute or so later. And miraculously, the device itself folded down into a 1″ slab that would just barely fit in the jacket pocket of your leisure suit.
Things got easier for the user from there, until all you had to do was pull the picture out of the front of the camera and lay it flat to dry (because you really shouldn’t shake them). But if you wanted to mess with the outcome, it was fairly easy to manipulate the still-wet developing chemicals to great impressionistic wavy effect. Way more fun than a filter, no? If you can get your hands on one of these originals,
check out the Open SX-70 Project
.
Impossible Resurrection
The i-zone instant camera. Image via
Wikipedia
Polaroid began to decline in the 1980s alongside the rise of cheap 35mm cameras and one-hour photo labs, but to this 80s kid, instant cameras were still half novelty, half luxury, and completely awesome. The company emitted a last gasp in the form of 1999’s i-zone camera, a small instant that produced tiny pictures on decorated film strips. I have two of them; they were great. More fun than a Fun Saver, and probably more expensive, too.
Try as they might, Polaroid just wouldn’t go away. They went bankrupt twice between 2001 and 2008, were sold three times, and one parent company got caught up in a Ponzi scheme. But the iconic brand was both saved and renewed by aficionados under the name
the Impossible Project
. They scooped up the last factory and spent years reformulating the original developing chemicals until they got it right. Eventually, they unified the brand with Polaroid and started selling new instant cameras that pay homage to the past. Here’s a look inside the factory:
Tangible But Frangible
Whether physical photographs are developed instantly, in one hour, or over the course of a few days, one thing binds them all, and that is tangibility. You can write on the back, send it off in a letter, use one as a bookmark, or carry a few around in your wallet. Physical photographs are dual time capsules — they freeze an otherwise-lost moment, and then the picture itself becomes a time capsule of its own, counting down until the medium disintegrates.
The only copy of this old picture of me and my buddy.
Instant-gratification photography is one thing, but add in tangibility and you have something special. Of course, digital files also age, but we can’t sense this passage of time the way we can use physical clues to date aged photographs. In digital form, pictures become files that just get corrupted and/or can’t be opened. It’s still in your hands, yet gone forever.
Of course with physical photographs, it’s much easier to lose the only print in existence. I can’t tell you how many times I’ve bought a used book and found a photograph inside. I always hope that it wasn’t someone’s only copy.
We monkeys marvel at our digital devices that can take a single image and proliferate it into
an unstoppable force
that can never be erased from the digital walls of the Internet. But the instant camera in particular gave us something else: privacy without the need for a darkroom. Suddenly, you could take a picture of anything without worrying about what someone else would think. Making duplicates negatives, and as long as you hold those (or they don’t exist),
you’re blackmail-proof
no one is getting any unauthorized copies. Was this development ultimately good or bad for society? Well, that’s another rant altogether. But surely there’s nothing inherently bad about privacy, right?
Thanks for the tip, [Ostracus]. | 47 | 18 | [
{
"comment_id": "6471006",
"author": "Chr E",
"timestamp": "2022-05-09T14:11:45",
"content": "The original folding SLR SX-70 is an absolute masterpiece of industrial design. And a lot of them are still working great 50 years later thanks to the amazing work Impossible Project has done keeping the fi... | 1,760,372,699.989144 | ||
https://hackaday.com/2022/05/09/looking-forward-to-emf-camp-teasing-us-with-a-schedule/ | Looking Forward To EMF Camp: Teasing Us With A Schedule | Jenny List | [
"cons"
] | [
"electromagnetic field",
"emf",
"hacker camp"
] | As we gear up for a summer in the field, or more accurately in a series of fields, it’s time to turn our attention towards Eastnor Castle in the Western English county of Herefordshire, venue for the upcoming Electromagnetic Field hacker camp. Sadly we’ve got no badge to tease you with, but they’ve released
a list of the talks that will fill their schedule
. There are so many to choose from, we can only mention a few in this article.
We’ll certainly be taking the time to watch [Russell Couper] describe
his electric motorcycle project
. He’s no stranger to unusual bike builds, having given us
a diesel machine at EMF 2016
. Then of course there’s our own [Dave Rountree], who will be
hacking the radio spectrum with GNU Radio
. Sure to be an interesting talk.
One feature of this camp we’re very interested in will be
CuTEL
, a wired copper telephone network on the field. We’ll be taking along our trusty GPO 746 to be part of it of course, but for those without one, there’s [Matthew Harrold]’s talk on
building a copper telephone network in a field
.
Our cursory scan of the list finishes up with [Alistair MacDonald] on
how not to start a hackerspace
. We’ve seen our fair share of hackerspace drama over the years, so whether this one causes pain for ex-hackerspace-directors or not, it promises to be informative for anyone in the hackerspace world.
At the time of writing
there are still some EMF tickets for sale
, so if the beginning of your June is free we can heartily recommend it. To get a flavour of the event,
read our 2018 review
. | 5 | 3 | [
{
"comment_id": "6470950",
"author": "BT",
"timestamp": "2022-05-09T11:09:41",
"content": "At first glance I could not tell if the article pic was an aerial photograph or a circuit board!",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6470980",
"auth... | 1,760,372,700.026848 | ||
https://hackaday.com/2022/05/09/growing-silver-nanoprisms-with-light/ | Growing Silver Nanoprisms With Light | Dave Rowntree | [
"chemistry hacks"
] | [
"led light",
"nanoparticles",
"optical",
"photo mediated synthesis",
"silver nitrate"
] | Nanoparticles sound a bit like science fiction to minds of your average hacker — too esoteric and out of reach to be something we might get to work with in our own lairs — but [Ben Krasnow] of [Applied Science] over on YouTube has proven that they most definitely can be made by mere mortals, and importantly they can be tuned.
With light
. That’s right, nano particle growth appears to be affected very strongly by being illuminated with specific wavelengths, which locks-in their size, and thus defines their light-bending properties. This is the concept of photo mediated synthesis, which causes nanoparticles to clump together into different configurations depending on the wavelength. The idea is to start with a stock solution of Silver Nitrate, which is then reduced to form silver nanospheres which are then converted to larger silver nanoprisms, sized according to the wavelength of the illuminating source.
The process seems simple enough, with a solution of Silver Nitrate and Sodium Citrate being vacuum degassed to remove oxygen, and then purged by bubbling argon or nitrogen. Sodium Borohydride acts as a reducing agent, producing silver metal nanoparticles from the Silver Nitrate solution. The Sodium Citrate coats the silver nanoparticles, as they are produced, preventing them clumping together into a mushy precipitate. PVP
(
Polyvinylpyrrolidone
) is added, acting as a colloiding agent preventing the coated nanoparticles from clumping together, and helping keep the solution stable long enough for the photo mediated synthesis process to complete. Finally, the pH is adjusted up to 11 using sodium hydroxide. The resulting silver nanoparticle stock solution has a pale yellow colour, and is ready for the final particle size selection using the light source.
The light source was custom made because [Ben] says he couldn’t find something suitable off the shelf. This is a simple design using a Teensy to drive an array of
PAM2804
LED drivers, with each one of those driving its own medium power LED, one for each of the different wavelengths of interest. As [Ben] stresses, the naïve approach of trying to approximate a specific colour with an RGB LED setup would not work, as although the human eye perceives the colour, the actual wavelength peak will be totally wrong, and the reaction will not proceed as intended. The hardware design is available on
MultiSpectLED GitHub
for your viewing pleasure.
Nanoparticles have all kinds of weird and wonderful properties, such as
making the unweldable, weldable
,
enabling aluminium to be 3D printed
, and even enabling the production of one of our
favourite liquid toys, ferrofluid
. | 1 | 1 | [
{
"comment_id": "6471185",
"author": "metalman",
"timestamp": "2022-05-09T23:16:52",
"content": "Very very interesting demonstration of what is clearly an underinvestigated basic property of matter,and as it happens,I just gotmost of the equipment to try it for an other project involving silvernano ... | 1,760,372,700.127541 | ||
https://hackaday.com/2022/05/08/classic-tamagotchi-is-reincarnated-in-modern-hardware/ | Classic Tamagotchi Is Reincarnated In Modern Hardware | Robin Kearey | [
"Microcontrollers",
"Software Hacks"
] | [
"emulation",
"stm32",
"tamagotchi"
] | If you thought that Tamagotchis were a late ’90s fad that has faded from most people’s memory by now, you’d be wrong: the franchise is still alive and well today, with new models being released regularly. But even the original model from 1996, known as Tamagotchi P1, is being kept alive by a small group of enthusiasts. When ROM dumps of the original hardware began floating around the internet a couple of years ago, even those without the real thing could run these virtual pets in an emulator.
But the whole idea of the Tamagotchi hardware was that it was portable enough to carry around anywhere. If you’re among those who missed that part of the Tamagotchi experience, you’ll be pleased to know that [JC] designed
OpenTama: a portable hardware platform that runs an emulated version of the original Tamagotchi P1 software
. It’s about as close as it gets to those first-generation virtual pets, but with several additions that make your life easier.
The software platform is [JC]’s TamaLib which
we featured last year
; in effect it’s an open-source emulator that allows the Tamagotchi ROM to run on a variety of modern hardware platforms. It also contains several additional options like the ability to save and restore your progress or to select customized ROMs. The OpenTama hardware, meanwhile, is a proper 21st-century reimplementation of the original: a small, egg-sized PCB sporting an STM32 microcontroller driving an LCD or OLED display, powered by a 100 mAh battery that can be recharged through a USB-C port.
OpenTama is not limited to the TamaLib software, either: as an open-source general-purpose platform, it can also be used as a learning tool for embedded programming, so if you’ve always wanted to program your own virtual pet, or are simply looking to build a fancy egg timer,
OpenTama’s GitHub page
is the way to go. We’ve seen quite a few neat Tamagotchi-like projects recently: this
3D-printed one comes with a nice retro LCD screen
, while
this one’s giant size ensures you don’t forget to feed it
. | 25 | 10 | [
{
"comment_id": "6470824",
"author": "Drone",
"timestamp": "2022-05-09T05:44:32",
"content": "The STM32L072CBT this thing uses is unobtanium:https://www.findchips.com/search/STM32L072CBThttps://octopart.com/search?q=STM32L072CBT¤cy=USD&specs=0Port it to a part that’s still available/affordable... | 1,760,372,700.303339 | ||
https://hackaday.com/2022/05/08/altaid-8800-puts-a-front-panel-in-your-pocket/ | Altaid 8800 Puts A Front Panel In Your Pocket | Tom Nardi | [
"Retrocomputing"
] | [
"altair 8800",
"altoids tin",
"Intel 8080"
] | It’s safe to say that the Altair 8800 is one of the most iconic, and important, computers ever created. The kit-built machine is widely regarded as the first commercially successful personal computer, and as such, intact specimens are bona fide historical artifacts when and if they ever come up on the second-hand market. Accordingly there’s a cottage industry out there dedicated to making affordable replicas, which more often than not, leverage modern hardware to emulate the original hardware.
But
that’s not what the Altaid 8800 is
. For one thing, it looks nothing like the original Altair. More to the point however, it’s not using modern components to emulate an Intel 8080 computer…it actually
is
an Intel 8080 computer — complete with fully functional front panel for manually entering in programs. It just happens to be small enough to fit into an Altoids tin, hence the name.
Creator [Lee Hart] didn’t just stop at building a miniature 8080 machine, either. He’s also gone through the trouble of producing a sixteen page faux-vintage magazine to describe the project and its operation. Normally we’d call such a document a “manual”, but somehow in this case that seems to downplay the incredible effort and attention to detail that went into it.
Schematics and firmware are available should you wish to build your own version of the Altaid 8800, but we think the prices for the bare PCBs and complete kits that [Lee] is offering are more than fair for what you get. In fact, if you’ve always wanted to
play around with front panel programming
and the associated blinkenlights, this might be one of the most affordable options available. Though to be clear, you can also hook the Altaid up to your computer with a USB-to-serial cable if you’re not up to punching in programs on those tiny buttons.
You might think this is one of the most creative and unique retrocomputing projects we’ve ever seen, and you’d be right…if it wasn’t for
[Lee]’s own Z80 Membership Card
. In some ways the precursor to the Altaid 8800, this diminutive triumph also fits in an Altoids tin and features its own era appropriate magazine-style documentation. We’re detecting something of a theme with these projects…but we certainly aren’t complaining. | 11 | 6 | [
{
"comment_id": "6470761",
"author": "Nuxi",
"timestamp": "2022-05-09T02:37:34",
"content": "This finally got released? Excellent! Lee’s kits are the best. And the manuals are half the fun.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6471084",
"au... | 1,760,372,700.176612 | ||
https://hackaday.com/2022/05/08/hackaday-links-may-8-2022/ | Hackaday Links: May 8, 2022 | Dan Maloney | [
"Hackaday Columns",
"Hackaday links",
"Slider"
] | [
"cat",
"crawler-transporter",
"documentary",
"Felis catus",
"grid",
"hackaday links",
"hacker",
"hacker culture",
"infrastructure",
"international space station",
"iss",
"Makers",
"nasa",
"rocket",
"roscosmos",
"russian",
"transformer"
] | Russia’s loose cannon of a space boss is
sending mixed messages about the future of the International Space Station
. Among the conflicting statements from Director-General Dmitry Rogozin, the Roscosmos version of
Eric Cartman
, is that “the decision has been made” to pull out of the ISS over international sanctions on Russia thanks to its war on Ukraine. But exactly when would this happen? Good question. Rogozin said the agency would honor its commitment to give a year’s notice before pulling out, which based on the current 2024 end-of-mission projections, means we might hear something definitive sometime next year. Then again, Rogozin also said last week that Roscosmos would be testing
a one-orbit rendezvous technique
with the ISS in 2023 or 2024; it currently takes a Soyuz about four orbits to catch up to the ISS. So which is it? Your guess is as good as anyones at this point.
At what point does falsifying test data on your products stop being a “pattern of malfeasance” and become just the company culture? Apparently, something other than
the 40 years that Mitsubishi Electric has allegedly been doctoring test results on some of their transformers
. The company has confessed to the testing issue, and also to “improper design” of the transformers, going back to the 1980s and covering about 40% of the roughly 8,400 transformers it made and shipped worldwide. The tests that were falsified were to see if the transformers could hold up thermally and withstand overvoltage conditions. The good news is, unless you’re a power systems engineer, these aren’t transformers you’d use in any of your designs — they’re multi-ton, multi-story beasts that run the grid. The bad news is, they’re the kind of transformers used to run the grid, so nobody’s stuff will work if one of these fails. There’s no indication whether any of the sketchy units have failed, but the company is “considering” contacting owners and making any repairs that are necessary.
For your viewing pleasure, you might want to catch the upcoming documentary series called “
A League of Extraordinary Makers
.” The five-part series seeks to explain the maker movement to the world, and features quite a few of the luminaries of our culture, including
Anouk Wipprecht
,
Bunnie Huang
,
Jimmy DiResta
, and the gang at
Makers Asylum
in Mumbai, which we assume would include
Anool Mahidharia
. It looks like the series will focus on the real-world impact of hacking, like
the oxygen concentrators
hacked up by Makers Asylum for COVID-19 response, and the influence the movement has had on the wider culture. Judging by the trailer below, it looks pretty interesting. Seems like it’ll be released on
YouTube
as well as other channels this weekend, so check it out.
But, if you’re looking for something to watch that doesn’t require as much commitment, you might want to check out
this look at the crawler-transporter
that NASA uses to move rockets to the launch pad. We’ve all probably seen these massive beasts before, moving at a snail’s pace along a gravel path with a couple of billion dollars worth of rocket stacked up and teetering precariously on top. What’s really cool is that these things are about as old as the Space Race itself, and still going strong. We suppose it’s easier to make a vehicle last almost 60 years when you only ever drive it at half a normal walking speed.
And finally, if you’re wondering what your outdoor cat gets up to when you’re not around — actually, strike that; it’s usually pretty obvious what they’ve been up to by the “presents” they bring home to you. But if you’re curious about the impact your murder floof is having on the local ecosystem,
this Norwegian study of the “catscape”
should be right up your alley. They GPS-tagged 92 outdoor cats — which they dryly but hilariously describe as “non-feral and food-subsidized” — and created maps of both the ranges of individual animals, plus a “population-level utilization distribution,” which we think is a euphemism for “kill zone.” Surprisingly, the population studied spent almost 80% of their time within 50 meters of home, which makes sense — after all, they know where those food subsidies are coming from. | 13 | 7 | [
{
"comment_id": "6470661",
"author": "gregg4",
"timestamp": "2022-05-08T23:10:28",
"content": "Interesting. One: I’ve seen those big crawlers before, also the big pads that roost on top of them before. And two: I saw that one about those Scandinavians and their talent for watching cats watch them. I... | 1,760,372,700.241468 | ||
https://hackaday.com/2022/05/08/prusas-official-enclosure-pulls-out-all-the-stops/ | Prusa’s Official Enclosure Pulls Out All The Stops | Tom Nardi | [
"hardware"
] | [
"3d printer enclosure",
"prusa",
"Prusa i3 Mk3"
] | It’s well known in the desktop 3D printing world that you get what you pay for. If you want to spend under $300 USD, you get a Creality Ender 3 and deal with its slightly half-baked nature. Or if you’ve got the money to burn, you buy a Prusa i3 MK3 and know that you’ll remain on the cutting edge thanks to a constantly evolving slicer and regular hardware revisions.
Now it stands to reason that an expensive product will have expensive accessories, but even still,
the recently unveiled “Original Prusa Enclosure”
is sure to induce a bit of sticker shock in even the most ardent of [Josef Průša]’s fans — the most bare-bones configuration of the 10 kg (22 lbs) box rings up at $349 USD. You read that right, just the
enclosure
for Prusa’s flagship machine costs more than the average Chinese 3D printer. In fact it
costs as much as the kit version of the Prusa Mini
, which incidentally, is set to get its own version of the enclosure sometime in the future. If you select all the bells and whistles, a fully-decked out Prusa Enclosure will cost you $700 USD, plus shipping.
So what do you get for your money? Well, for the most part it’s just a box. We’re sure it’s very well built, and the design is perfectly matched to the dimensions of the Prusa i3 MK3, but it’s literally just a box. There’s an integrated temperature and humidity display, but the printer itself is responsible for heating the chamber. We like that you can move the printer’s control panel to the outside of the box so you won’t have to open the doors as often, though at that point the printer and enclosure will have been merged into one heavy-weight unit, which obviously hinders transportability. The air filtration system is likely to be a popular add-on for $76, but our interest in the fire suppression system is hampered by the fact that (at least for now) it’s only available to customers in the European Union.
In the
blog post announcing the product’s release
, [Josef] explains that there’s already an
excellent low-cost enclosure solution for the i3 MK3 based on the IKEA Lack table
, so the company decided to go all in and design something for the higher end of the market. Will the average i3 owner fork out the cash for the matching enclosure? We doubt it. But for the tech startup that’s running a small farm that they want to be as safe and reliable as possible? That’s a different story. | 50 | 16 | [
{
"comment_id": "6470607",
"author": "Fallen",
"timestamp": "2022-05-08T20:08:47",
"content": "I fail to see how the ender 3 is half baked. I’ve had zero issues with mine.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6470634",
"author": "John",
... | 1,760,372,700.507111 | ||
https://hackaday.com/2022/05/08/reviving-a-1974-sinclair-scientific-calculator/ | Reviving A 1974 Sinclair Scientific Calculator | Jenny List | [
"Retrocomputing"
] | [
"70's calculators",
"calculator",
"sinclair",
"sinclair cambridge"
] | When a treasure of retrotechnology fails to work, the natural next step is to have a go at repairing it. [Adam Wilson] found himself in this position
when he acquired a 1974 Sinclair Cambridge Scientific calculator
, and his progress with the device makes for an interesting read.
First up is something of value to all old Sinclair enthusiasts, he’s found a solution to the original battery connectors being prone to failure. A couple of parts stocked by RS can be used as replacements, which should save quite a lot of Sinclairs with crusty connectors.
Saving the connectors should have fixed the calculator, but only served to reveal that it had an electronic fault. Some detective work traced this to the power supply, which is a small switching circuit. The 1974 chip and associated coil had both failed, which rather drew the project to a halt. A second repair-or-spares Cambridge Scientific was sourced, and by good luck it happened to have a working PCB. So [Adam] got a working calculator, and we hope he’ll succumb to the temptation to shoehorn in a PSU from 2022 to get the other one working.
Anyone curious about this slightly unusual calculator
should take a look at our teardown of one
. | 6 | 3 | [
{
"comment_id": "6470575",
"author": "RW ver 0.0.3",
"timestamp": "2022-05-08T17:57:10",
"content": "I kinda go to Hamfest/fleamarkets crossing my fingers I come across one of these, or micro radio, or black watch, heck ZX-80 even, in kit form, in a shabby tattered enough box I can get it cheap and ... | 1,760,372,700.54578 | ||
https://hackaday.com/2022/05/08/a-crazy-wave-automaton/ | A Crazy Wave Automaton | Anne Ogborn | [
"3d Printer hacks"
] | [
"3d print",
"art",
"automata"
] | [Henk Rijckhaert] recently participated in a “secret Santa” gift exchange. In a secret Santa, everyone’s name goes in a hat, and each person must pick a name without looking. Each gives a gift to the person whose name they drew.
Henk needed a gift for Amy, a friend who loves the water and water sports as well as maker-y things. So he built her a wave automaton — a sea wave and fishies, and
documented the build in this video
.
The build is mostly plywood and 3D printed parts. We have to think reprising it in a nice wood and brass would make a lovely project for a hobby wood and metalworker.
The bulk of the project is 30 plywood boards stacked up with spacers. Each board is mounted with a 3D printed stepped bushing on one end that rides in a horizontal slot. On the other end is a 3D printed eccentric riding in an oversized (about 5cm) hole. So the board moves in a circle at one end and back and forth at the other for a very nice simulation of an ocean wave.
The eccentrics all ride on a common shaft, but are offset in phase. He has a nice technique for setting the phases. Each eccentric has 3 small holes on a radius centered on the shaft. Toothpicks go in two of the holes, passing through holes 2 and 3 of the lower eccentric and holes 1 and 2 of the upper eccentric. 3D printed gears and hand crank drive the system.
The wave is fun, but a bit plain. So he 3D printed some flat fishies, glued them on brass rod, and epoxied the rods to the mechanism. Now the fishies jump in arcs out of the water as the shaft turns. The video isn’t clear, but we think they’re on the small ‘slot’ bearings.
There are a few interesting construction details. The 3D printed gears transmit torque to their shafts via nyloc nuts press fit into a hex hole. The handle transmits torque via a hex head bolt press fit in a 3D print. The epoxy surprised us – there doesn’t seem to be any mechanical support for the brass rod. This might be us, as the video is in Dutch, and our Dutch is limited.
If you liked this build, check out the
3D printed water droplet automaton
. | 9 | 6 | [
{
"comment_id": "6470519",
"author": "NoNamed",
"timestamp": "2022-05-08T14:02:11",
"content": "I think it’s Henk Rijckaert, not Henk Rijckhaert",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6470586",
"author": "Karl",
"timestamp": "2022-05-... | 1,760,372,700.594265 | ||
https://hackaday.com/2022/05/08/creating-an-image-format-for-embedded-hardware/ | Creating An Image Format For Embedded Hardware | Tom Nardi | [
"Microcontrollers",
"Software Development"
] | [
"bitmap",
"file format",
"image formats"
] | Whether its one of those ubiquitous little OLED displays or a proper LCD panel, once you’ve got something a bit more capable than the classic 16×2 character LCD wired up to your microcontroller, there’s an excellent chance you’ll want to start displaying some proper images. Generally speaking that means you’ll be working with bitmap files, but as you might expect when pushing a decades-old file format into an application it was never intended for, things can get a little messy. Which is why
[gfcwfzkm] has created the Portable Image File (PIF) format
.
This low-overhead image format is designed specifically for microcontrollers, and can be decoded on devices with at least 60 bytes of free RAM. Images stored with PIF not only require fewer computational resources to process, but equally important, take up less space on flash. The format supports both color and monochrome images, and the GitHub repo even includes a graphical Python 3.10 tool that lets you convert your images to either .pif files or a .h header file for embedding directly into your C code.
[gfcwfzkm] has provided some source code to show you how to get the PIF library up and running, but as of the time of this writing, there isn’t any example code for using PIF within the Arduino environment. That’s no big deal for the old hands in the audience, but we’re interested in seeing how the community can make use of this file format once it’s available in a bit more beginner-friendly package. It’s one of the final unchecked items on the todo list though, so it shouldn’t be long now.
Of course nothing is
wrong
with using bitmaps to display images in your microcontroller projects, and there’s a certain advantage to
fiddling around with the well-known image format
. But if a new file type is all it takes to speed up access times and cram a few more images onto the chip, we’re definitely ready to upgrade. | 60 | 17 | [
{
"comment_id": "6470468",
"author": "josuah",
"timestamp": "2022-05-08T11:18:07",
"content": "Great self-contained format here. One ‘.c’ and one ‘.h’ file to drop on your project and good to go.Introducing another format might not matter so much if it is just an internal thing with, say, ‘.png’ exp... | 1,760,372,700.839611 | ||
https://hackaday.com/2022/05/08/free-your-pi-with-this-bare-metal-programming-environment/ | Free Your Pi With This Bare Metal Programming Environment | Dave Rowntree | [
"Raspberry Pi"
] | [
"baremetal",
"c++",
"programming",
"Raspberry Pi 2",
"Raspberry Pi 3",
"Raspberry Pi 4",
"Raspberry Pi Zero"
] | [Rene Strange] has graced these fair pages a short while ago with a sweet Raspberry Pi software based poly synth, with a tantalising reference to it being a bare metal application. So now, we’ll look into
circle, the bare metal programming environment
that it is based upon. The platform consists of a large set of C++ classes to access the hardware as well as perform tasks such as task creation and scheduling in the cooperative multitasking, multicore environment. Supporting all Raspberry Pi boards from version 2 onwards (not including the Pico!) in both 32-bit and 64-bit flavours, the environment is pretty complete. Classes are provided for USB, networking, FatFS, as well as more mundane tasks such as dealing with interrupts. On top of these classes there are a pile of application-specific libraries, covering functions such as display interfacing, GUIs using a variety of frameworks, and some more esoteric applications such as interfacing to a Pico, and even sending the system log to a remote web browser!
Classes and libraries however, don’t always help by themselves, which is where the 42 (yes, we know) code examples come in very handy. They’ve provided example applications for some fun stuff like drawing Mandelbrot fractals to the display, as well as some more mundane tasks that we have to deal with such as getting that pesky DMA controller to play nice with the SPI hardware. All-in-all, this looks like a great set of tools for taking full advantage of some fairly beefy hardware for your next embedded project that needs plenty of resources, but not all that unnecessary operating system stuff.
Perhaps not quite as complete as circle, but we’ve seen a fair few Raspberry Pi Bare metal projects over the years, like the
Nerdsynth
, based on the PiZero, and this
neat little bare metal assembly language clone of starfox
.
Thanks [Ruhan] for the tip!
Header: Aryan Patidar,
CC BY 4.0
/Evan-Amos,
Public domain. | 3 | 3 | [
{
"comment_id": "6471050",
"author": "rclark",
"timestamp": "2022-05-09T15:46:14",
"content": "I downloaded this last night and installed the aarch64 toolchain to use it (using KUbuntu 22.04 as host). All sample files compiled just fine and then loaded the 01 blink project. Worked as advertised on... | 1,760,372,700.642782 | ||
https://hackaday.com/2022/05/07/web-emulator-for-the-kenbak-1-computer-if-youve-heard-of-it/ | Web Emulator For The Kenbak-1 Computer (If You’ve Heard Of It) | Donald Papp | [
"Retrocomputing"
] | [
"emulator",
"first personal computer",
"Kenbak",
"vintage computing"
] | Ever heard of the KENBAK-1? Recognized as the first personal computer, created by John Blankenbaker and sold in 1971 in comparatively small numbers, it’s now a piece of history. But don’t let that stop you if you are curious, because of course
there is an emulator on the web
.
If the machine looks a bit strange, that’s because early computers of this type did not have the kind of controls (or displays) most people would recognize today. Inputs were buttons and switches, and outputs were lights showing binary values of register contents. The machine could store and run programs, and those programs were entered in pure machine code (no compiler, in other words) by setting individual bit values via the switches. In fact, the KENBAK-1’s invention preceded that of the microprocessor.
The KENBAK was the first electronic, commercially available computer that was not a kit and available to the general population, but the story of how it came to be is interesting. Back in 2016 we covered how
that story was shared by John Blankenbaker himself
at Vintage Computer Festival East. | 16 | 6 | [
{
"comment_id": "6470387",
"author": "Arthur Mezins",
"timestamp": "2022-05-08T05:38:19",
"content": "I’m pretty sure the first “PC” article I recall seeing was in a Popular Electronics in 1969 that used a phone pulse dialer as input, but then that was a long time ago and I didn’t bother to commit t... | 1,760,372,700.699432 | ||
https://hackaday.com/2022/05/07/reflecting-on-a-queueing-prism-leads-to-unexpected-results/ | Reflecting On A Queueing Prism Leads To Unexpected Results | Matthew Carlson | [
"Software Development"
] | [
"concurrent",
"formal verification",
"model checker",
"prism",
"probability"
] | Computers are difficult enough to reason about when there’s just a single thread doing one task. There are dozens of cores in today’s modern processor world, and your program might try to take advantage of using more than just one. Things happening concurrently makes the number of states and interactions explode in to a mess we as humans are likely going to have trouble understanding. So, like [Hillel], you might
turn to the computer to try and model those interactions.
The model in question is a task queue. Things are added to the pile, and “workers” grab one from the pile and process it. There are two metrics used to measure the effectiveness of a task queue: throughput and latency. Throughput is the number of things you can do per second (like this
maximum throughput 3d printer
), while latency is the amount of time it takes to finish one thing.
Instead of writing a simulation, [Hillel] turned to a probabilistic model checker called PRISM. There are a few constraints on the model, such as each task being dependent and taking a different time to complete. This is modeled by the fact that each step a worker has a 50% chance of completing their task. For each step, there is a 50% chance a new task comes into the queue, up to a limit of N total tasks. Next, he modeled throughput by creating a reward function that gives us the total number of steps it took us to complete all tasks. Latency is another reward function, but, it is the sum of the number of items in the queue for each timestep.
With just one worker, the growth in latency looks quadratic. Just ten tasks wait for 29-time steps, while 20 tasks wait for 97-time steps. When adding in a second worker, the throughput doesn’t double but instead is about 2/3rds of what it was for one worker. But on the flipside, latency has fallen to something closer to linear.
While a simple model, the idea of a model to simulate a complex domain is there. You could easily add priority, more workers, retrying, adding items back to the queue, adding multiple items in one time step, and other things. [Hillel]
provides a little python gist
to help you generate the PRISM for an arbitrary number of workers.
Formal methods/verification isn’t something we talk about often on Hackaday, and if you’re curious for more,
we talked about how to verify your C compiler as being trustworthy
. | 6 | 4 | [
{
"comment_id": "6470385",
"author": "Arthur Mezins",
"timestamp": "2022-05-08T05:30:41",
"content": "I found the statement: “There are a few constraints on the model, such as each task being dependent and taking a different time to complete. This is modeled by the fact that (at) each step a worker ... | 1,760,372,700.741882 | ||
https://hackaday.com/2022/05/07/this-spherical-lamps-pieces-ship-flat-thanks-to-math/ | This Spherical Lamp’s Pieces Ship Flat, Thanks To Math | Donald Papp | [
"Art",
"cnc hacks"
] | [
"art",
"generative design",
"lamp shade",
"laser cut",
"Laser cutting",
"puzzle cells"
] | [Nervous System] sells a variety of unique products, and we really appreciate the effort they put into sharing elements of their design and manufacturing processes. This time, it’s
details of the work that went into designing a luxury lamp shade
that caught our eye.
Top: Finished lamp. Bottom: Partially-assembled.
The finished lamp shade is spherical, but is made entirely from flat-packed pieces of laser-cut wood that have been specifically designed to minimize distortion when assembled into a curved shape. The pieces themselves are reminiscent of
puzzle cells
; complex, interlocking cellular shapes found in many plants.
As usual, [Nervous System] applied a hefty dose of math and computational design to arrive at a solution. Each unique panel of the lamp is the result of a process that in part implements
a technique called variation surface cutting
for the shape of the pieces. They also provide a couple of nifty animations that illustrate generating both the piece boundaries as well as the hole patterns in each of the 18 unique pieces that make up each lamp.
As for making the pieces themselves, they are laser-cut from wood veneer, and assembly by the end user takes an hour or two. Watch a video overview, embedded just below under the page break.
We’re glad [Nervous System] takes the time to share details like this, just like the time they figured out the very best type of wood for laser-cutting their unique puzzles
and didn’t keep it to themselves
. | 3 | 2 | [
{
"comment_id": "6470330",
"author": "then",
"timestamp": "2022-05-08T01:18:19",
"content": "so uh Rhino/Grasshopper?",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6470472",
"author": "Jessica",
"timestamp": "2022-05-08T11:35:06",
"c... | 1,760,372,700.881419 | ||
https://hackaday.com/2022/05/07/bee-motion-combines-esp32-with-pir-sensor-and-usb-c/ | Bee Motion Combines ESP32 With PIR Sensor And USB-C | Tom Nardi | [
"Microcontrollers"
] | [
"charge controller",
"ESP32-S2",
"passive infrared",
"PIR senor",
"USB C"
] | There’s no shortage of ESP32 development boards out there, with many of them offering some “killer app” feature which may or may not align with whatever it is you’re trying to do. But if you’ve got a project that could benefit from the pairing of a powerful WiFi-enabled microcontroller and a passive infrared (PIR) motion sensor, the
Bee Motion created by [Paul Price] is certainly worth a close look
.
This breadboard compatible package combines an ESP32-S2 module with a top-mounted PIR sensor, making it a turn key solution for all sorts of motion sensing projects. In addition to the expected onboard voltage regulation, there’s also a LiPo charge controller and status LEDs for mobile or battery-backed operation.
While there’s far too many variables involved for [Paul] to give a specific runtime for the Bee Motion, he’s run some numbers and found that a 1500 mAH cell could potentially keep the board running for over a year if you’re taking advantage of the MCU’s deep sleep capabilities. When it’s time to recharge, whenever that may be, the board’s USB-C connector means you won’t be searching around for the proper cable.
Schematics and CAD files are available in the Bee Motion GitHub repo, and [Paul] is also
selling assembled boards on Tindie
. All you need now is to get inspired by some of the
slick PIR projects we’ve covered in the past
. | 3 | 3 | [
{
"comment_id": "6470494",
"author": "ConsultingJoe",
"timestamp": "2022-05-08T12:59:01",
"content": "Pretty neat. I love pcb dev.1st",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6471238",
"author": "Mr. BianchiRider",
"timestamp": "2022-05-10T02:01:... | 1,760,372,700.926978 | ||
https://hackaday.com/2022/05/07/apple2idiot-expansion-card-lets-your-apple-ii-sort-of-access-the-internet/ | APPLE2IDIOT Expansion Card Lets Your Apple II (Sort Of) Access The Internet | Donald Papp | [
"Microcontrollers",
"Retrocomputing",
"Wireless Hacks"
] | [
"apple II",
"ESP32",
"expansion card",
"wifi"
] | [Nathanial Hendler]’s
Apple2Idiot expansion card
for the Apple II family of computers is a nifty mix of modern and vintage, and provides a clever means of allowing the host computer to (indirectly) access the internet over WiFi while keeping things simple from the host computer’s perspective.
The PCB has plenty of space on which to silkscreen reference data. Click to enlarge.
It does this by embedding an ESP32 module and a dual-port RAM chip onto an expansion card. The Apple2Idiot, when installed into a host machine, presents as a memory location which the host machine can access. The ESP32 then takes care of all the WiFi communications and tasks requiring internet access, and the host computer directs these tasks (and reads their output) via
PEEK
and
POKE
commands.
This means that there are two pieces of software for any given task: one running on the ESP32 doing the actual work, and one running on the Apple II that communicates with the ESP32 on the card by reading and writing to memory. It’s a simple system, and one that [Nathanial] thinks works quite well for specific tasks.
Example programs include things like scanning and selecting a WiFi network, fetching weather data, and sending a message to Slack. Making new applications does mean having to write software on two ends, but the simplicity of the system also means flexibility, because anything the ESP32 does can have its complexity abstracted away by the time its data is presented to the host machine. Not that the Apple II is incapable of dealing with the modern internet more directly;
we’ve seen a basic Apple II web server written in BASIC
. | 26 | 11 | [
{
"comment_id": "6469927",
"author": "Michael Black",
"timestamp": "2022-05-07T17:40:43",
"content": "I can run any old computer with a serial port on the internet by connecting to my main computer. It’s no different than when I did dialup and used a shell at my ISP. I’m sure my main computer is b... | 1,760,372,701.043386 | ||
https://hackaday.com/2022/05/07/learning-obsolete-technology/ | Learning Obsolete Technology | Elliot Williams | [
"Hackaday Columns",
"Rants"
] | [
"philosophy",
"retrocomputing"
] | Tom Nardi and I were talking about his
trip to the Vintage Computer Festival
on the podcast, and he admitted to not having been a retrocomputer aficionado before his first trip. But he ended up keying some binary machine code into some collection of archaic silicon, and he got it. In the same episode, the sound of the week was a
Strowger switch
— the old electromechanical “brain” of telephone switching centers of old. The sample I used
was from Sam of Look Mum No Computer on YouTube
, who got one for his museum and thinks it’s just awesome.
Why do people like this kind of old (obsolete?) tech? It’s certainly not because it’s overwhelmingly capable — the giant old switch is replaced easily by a stack of silicon, and don’t even get me started on the old blinkenlights computer that Tom was keying on. In both of these cases, the people are significantly younger than the tech they’re playing around with, so that rules out nostalgia. What’s left?
I think it’s that sometimes the older technology is more immediate, more understandable, more tangible, and that resonates with people. In a time when we all have wonder devices that can do anything, programmed in languages that are pleasant, using libraries that are nothing short of magical in terms of making difficult things easy, understanding how things work down to the ground is a rare commodity.
But it’s a strange position to find ourselves in, technologically, where there’s almost necessarily a trade-off between the usefulness and functionality of a device with the ability to understand fundamentally how it works.
This article is part of the Hackaday.com newsletter, delivered every seven days for each of the last 200+ weeks. It also includes our favorite articles from the last seven days that you can see on
the web version of the newsletter
.
Want this type of article to hit your inbox every Friday morning?
You should sign up
! | 33 | 17 | [
{
"comment_id": "6469662",
"author": "Jerry",
"timestamp": "2022-05-07T14:22:01",
"content": "Going through my “Stash”, I re-found my old “Canon A-200TP” kitted out with 2 51/4 floppies, and a folding LCD green screen. I rescued it from a trash load at the landfill CIRCA 1988 or so.This link is her... | 1,760,372,701.11623 | ||
https://hackaday.com/2022/05/07/mods-make-a-stock-keyboard-your-own/ | Mods Make A Stock Keyboard Your Own | Kristina Panos | [
"Peripherals Hacks"
] | [
"Kailh browns",
"keyboard",
"neoprene",
"UHK",
"ultimate hacking keyboard",
"Zilent"
] | Trust me, you don’t have to build your own keyboard from the deskpad up to be happy or feel like one of the cool kids. Sure, it doesn’t hurt, but not everyone is able to or even wants to start from next to nothing. Take [Roger] for example. [Roger] started with a stock mechanical keeb — the Ultimate Hacking Keyboard (UHK) — which can be outfitted with magnetic add-on modules such as a thumb key cluster, trackball, trackpoint, and touch pad, and
made it his own
.
While the stock board that you choose may not be so option-laden, there are plenty of other things one can do to customize things, and [Roger] did basically all of them. The Kailh browns that the UHK came with were too loud, so [Roger] swapped them out for Zilent V2 Silent tactiles and dampened the case with plenty of neoprene foam.
[Roger] frequently switches between two keyboard layouts, which got confusing at times. But instead of boring blank keycaps, he scrounged around until he found a cool set. (We do like the way they look with the wood wrist rests.) Speaking of those wrist rests, the right one is carved out and hiding a 10,000 mAh power bank, because [Roger] also made the UHK wireless using
one of those often-out-of-stock BT-500 Bluetooth adapters
. This allows him to switch between two PCs with a keyboard shortcut.
Think you want to go split, but not sure about key wells and column stagger and all that jazz? Something like the UHK is a good place to start, because it takes the familiar brick wall layout and breaks it into two pieces. No idea what you want? Check out
the split keyboard finder
. | 2 | 1 | [
{
"comment_id": "6469843",
"author": "david s",
"timestamp": "2022-05-07T16:40:45",
"content": "Would like more info on the tiny trackball.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6472270",
"author": "Roger",
"timestamp": "2022-05-12T1... | 1,760,372,701.150864 | ||
https://hackaday.com/2022/05/07/re-imagining-the-resistor-color-code-cheat-sheet/ | Re-imagining The Resistor Color Code Cheat Sheet | Donald Papp | [
"hardware"
] | [
"cheat sheet",
"resistor",
"resistor color codes"
] | Some people look at a venerable resource like resistor color code charts and see something tried and true, but to [Andrew Jeddeloh], there’s room for improvement. A search for a more intuitive way is what led to
his alternate cheat sheet for resistor color codes
.
Color code references
typically have a reader think of a 560 kΩ resistor as 56 * 10 kΩ, but to [Andrew], that’s not as simple as it could be. He suggests that it makes more sense for a user to start with looking up the colors to make 5.6 (green-blue), then simply look up that a following yellow band means resistance in the 100 kΩ range (assuming a four-band resistor); therefore 560 kΩ is green-blue-yellow.
The big difference is that the user is asked to approach 560 kΩ not as 56 * 10 kΩ, but as 5.6 * 100 kΩ. [Andrew] shares a prototype of a new kind of chart in his post, so if you have a few minutes, take it for a spin and see what you think.
Is his proposed method more intuitive, or less? We think [Andrew] makes a pretty good case, but you be the judge. After all, just because something has always been so doesn’t mean there isn’t room for improvement. This happens to apply nicely to resistors themselves, in fact.
It may seem like through-hole resistors have always had color bands, but that is not the case
. | 108 | 40 | [
{
"comment_id": "6469500",
"author": "Alexander Wikström",
"timestamp": "2022-05-07T08:05:20",
"content": "Personally I think resistor manufacturers should just silk screen on the value in text.Silk screening isn’t all that expensive, and much more readable than bands of color.After all, if they can... | 1,760,372,701.38139 | ||
https://hackaday.com/2022/05/06/flexures-make-this-six-dof-positioner-accurate-to-the-micron-level/ | Flexures Make This Six-DOF Positioner Accurate To The Micron Level | Dan Maloney | [
"Misc Hacks"
] | [
"compliant mechanism",
"flexure",
"positioner",
"Stewart platform",
"voice coil"
] | It’s no secret that we think flexures are pretty cool, and we’ve featured a number of projects that leverage these compliant mechanisms to great effect. But when we saw flexures used in
a six-DOF positioner with micron accuracy
, we just had to dig a little deeper.
The device is known as the Hexblade, and it comes to us from the lab of [Jonathan Hopkins] at UCLA. We have to admit that at times, the video below feels a little like
the “Turbo Encabulator” schtick
— “three identical decoupled actuation limbs arranged in an axisymmetric configuration” may be perfectly descriptive, but it does not flow trippingly from the tongue. Hats off to [Professor Hopkins] for nailing the narration, though, and really, once you get a handle on the jargon, it all makes perfect sense. The platform is supported by a total of six flexures, which look like bent pieces of sheet metal but are actually cut from a solid block of material using wire EDM. Three of the flexures are oriented in the plane of the platform, while the other three are perpendicular to it. The far end of each flexure is connected to a voice-coil actuator that is surrounded by another flexure, this one in a parallelogram arrangement. The six actuators can move the platform smoothly through three linear translations (X, Y, and Z) and three rotations (roll, pitch, and yaw).
The platform’s range of motion is limited, but the advantages of using flexures as bearings are clear — there’s no backlash or hysteresis, and the voice coils can control the position of the stage to micron accuracy. Something like the Hexblade would be an ideal positioner for microscopy, and we can imagine an even smaller version, perhaps even a MEMS-fabricated one for nanomanufacturing applications. The original concept of the Hexblade serving as the print head for a fabrication robot for space applications is pretty cool, too, and we’d venture to say that a homebrew version of this probably isn’t out of reach either.
Thanks to [IraqiGeek] for the tip. | 26 | 15 | [
{
"comment_id": "6469478",
"author": "geocrasher",
"timestamp": "2022-05-07T05:05:15",
"content": "This reminds me of the mirror actuators on the JWST.https://hackaday.com/2022/02/08/working-model-reveals-amazing-engineering-of-webbs-mirror-actuators/",
"parent_id": null,
"depth": 1,
"re... | 1,760,372,701.217562 | ||
https://hackaday.com/2022/05/06/tree-forks-as-natural-composite-joints-in-architecture/ | Tree Forks As Natural Composite Joints In Architecture | Jenny List | [
"green hacks"
] | [
"architecture",
"structural joint",
"tree fork",
"wood"
] | A problem facing architects when designing complex three-dimensional structures lies in their joints, which must be strong enough to take the loads and vector forces applied by the structure, yet light enough not to dominate it. Many efforts have been made to use generative design techniques or clever composites to fabricate them, but as Dezeen reports,
a team at MIT are exploring an unexpected alternative in the form of naturally occurring tree forks
.
The point at which a tree branch forks from its trunk is a natural composite material formed of an interlocking mesh of wood grain fibres. Timber processors discard these parts of the tree as they interfere with the production of smooth timber, but the same properties that make them support the weight of a branch are it seems perfect for the architects’ needs.
The clever part of the MIT team’s work lies in scanning and cataloguing a library of forks, allowing them to be matched from the database to vertices in an architectural design. The forks are subject to minimal machining before being incorporated into the structure, and to prove it the MIT folks have made a test structure. It’s not uncommon to see medieval barns or half-timbered houses using curved pieces of wood in their natural shapes, so it’s not surprising to see that this 21st century innovation
isn’t an entirely new technique
. | 28 | 12 | [
{
"comment_id": "6469448",
"author": "Ninjalicious",
"timestamp": "2022-05-07T02:35:06",
"content": "The term is cruck frame house. And yeah places where curved trees are more common see a lot of cruck frame architecture.",
"parent_id": null,
"depth": 1,
"replies": [
{
"com... | 1,760,372,701.615949 | ||
https://hackaday.com/2022/05/06/pico-chording-keyboard-is-simultaneously-vintage-and-new/ | Pico Chording Keyboard Is Simultaneously Vintage And New | Kristina Panos | [
"Peripherals Hacks",
"Raspberry Pi"
] | [
"14-segment display",
"alphanumeric display",
"chord",
"chorded keyboard",
"chording keyboard",
"Kailh",
"keyboard",
"RGB LEDs"
] | On paper, chording — that’s pressing multiple keys to create either a single character or a whole word — looks like one of the best possible input methods. Maybe not the best for speed, at least for a while, but definitely good for conserving the total number of keys. Of course, fewer keys also makes for an easier time when it comes
to building keyboards (as long as you don’t have to code the chording software). In fact, we would venture to guess that the hardest part of building your own version of
[CrazyRobMiles]’s Pico Chord Keyboard
would be teaching your fingers how to work together to chord instead of typing one at a time.
[CrazyRobMiles] took inspiration from the Cykey chording design used for the Microwriter and later, the Microwriter Agenda that also featured a qwerty blister keyboard. Both featured small screens above the six keys — one for each finger, and two for the thumb.
While the original Microwriter ran on an 8-bit microprocessor
, Pico Chord Keyboard uses — you guessed it — the Raspberry Pi Pico.
We love that [CrazyRobMiles] went with four 14-segment displays, which gives it a nice old school feel, but used transparent keycaps over Kailh switches. This is actually important, because not only do the LEDs show what mode you’re in (alpha vs. numeric vs. symbols), they also teach you how to chord each letter in the special training game mode. Be sure to check it out in the video after the break.
Isn’t it cool that we live in a world of relatively big keyboards with few keys and
tiny keyboards with all the keys? | 9 | 5 | [
{
"comment_id": "6469625",
"author": "Alphatek",
"timestamp": "2022-05-07T13:52:38",
"content": "The ‘quinkey’ was a keyboard-only version of the microwriter for the BBC micro. It connected over the analogue port, so I suspect it has no onboard smarts.",
"parent_id": null,
"depth": 1,
"r... | 1,760,372,701.435026 | ||
https://hackaday.com/2022/05/06/electripop-turns-cut-mylar-into-custom-3d-structures/ | ElectriPop Turns Cut Mylar Into Custom 3D Structures | Tom Nardi | [
"Art",
"hardware",
"High Voltage"
] | [
"electrostatic",
"Future Interfaces Group",
"mylar",
"static electricity"
] | Mylar has a lot of useful properties, and as such as see it pop up pretty often, not just in DIY projects but in our day-to-day lives. But until today, we’ve never seen a piece of Mylar jump up and try to get our attention. But that’s precisely the promise offered by ElectriPop, a
fascinating project from Carnegie Mellon University’s Future Interfaces Group
.
The core principle at work here is fairly simple. When electrostatically charged, a strip of Mylar can be made to lift up vertically into the air. Cut that strip down the center, and the two sides will repel each other and produce a “Y” shape. By expanding on that concept with enough carefully placed cuts, it’s possible to create surprisingly complex three dimensional shapes that pop up once a charge is applied. A certain degree of motion can even be introduced by adjusting the input power. The video after the break offers several examples of this principle in action: such as a 3D flower that either stands up tall or wilts in relation to an external source of data, or an avatar that flails its arms wildly to get the user’s attention.
A mini Van de Graaff produces a variable static charge.
As the relationship between the nested cuts, slits, and holes placed in the Mylar sheet and the final 3D shape isn’t particularly intuitive, the team has
developed a visualization tool
that can be used in conjunction with existing vector art programs to create a 2D cut file. Once you’re satisfied the design will inflate to the intended shape, it can quickly be implemented with a vinyl cutter or laser. The low barrier to entry makes this project particularly well suited for DIY replication, and we’re eager to see how the maker community could put this concept to work.
There are plenty of ways that you can charge up your new shape-changing Mylar display, but we particularly liked the team’s miniature Arduino-controlled Van de Graaff generator. It may represent the smallest and most simplistic implementation of this
classic high-voltage generator
that we’ve ever seen, and looks like a fun little project in itself.
ElectriPop was developed by [Cathy Mengying Fang], [Jianzhe Gu], and [Lining Yao] in collaboration with the director of the Future Interfaces Group, [Chris Harrison]. Readers may recall that in
2018 we covered VibroSight
, another project from [Chris] and his students, which ultimately was scaled up to
demonstrate laser non-contact sensing on city-scale just last year
. Stay tuned for more from this innovative lab in the near future. | 14 | 5 | [
{
"comment_id": "6469343",
"author": "then",
"timestamp": "2022-05-06T20:19:48",
"content": "Huh but..that shiny, mirror finish does not look like my empty PET coke bottle, there is some metal in it no? Strange omission?",
"parent_id": null,
"depth": 1,
"replies": [
{
"comm... | 1,760,372,701.742183 | ||
https://hackaday.com/2022/05/06/screwed-up-can-technology-be-a-substitute-for-regular-maintenance/ | Screwed Up: Can Technology Be A Substitute For Regular Maintenance | Jenny List | [
"Parts"
] | [
"bolt",
"fraunhofer",
"nuts and bolts",
"preventive maintenance"
] | The bane of life for anyone who possesses a well-used pile of spanners is the humble nut and bolt. Durable and easy to fasten, over our lifetimes we must screw and unscrew them by the million. When they do their job they’re great, but too often they seize up solid, or more alarmingly, gradually undo themselves over time due to vibration or thermal stress. There are a host of products such as locking nuts or thread sealant to deal with this problem, but the Fraunhofer Institute have an idea which might just remove the worry surrounding important fastenings.
Their work has resulted in a solar-powered bolt with an embedded sensor
that phones home when the connection loosens, allowing an engineer to be dispatched with a spanner to tighten it up.
The sensor itself is a washer which reports the force placed upon it, when this reduces an alert is sent. Communication is via Fraunhofer’s own
MIoTy
low-power wide-area network (LPWAN) protocol, but we’d imagine that one of the many competitor technologies could also serve.
This is an interesting idea that could no doubt result in targeted maintenance catching faulty fastenings early and averting disaster in the infrastructure projects such as bridges and wind turbines that they mention. We worry slightly though, because these types of structures have lives not in the few years of most tech products but in centuries. Will an IoT bolt head sensor still be phoning home in a few decades time, or will the system rely on old bolts being replaced at regular intervals of a decade? It’s not unknown
for disasters to be the result of failures in fastenings a century old
, so we sincerely hope that authorities in charge of whatever bridge relies on these won’t be tempted to skimp on their replacements. Perhaps a guy with a spanner every few years might be a more dependable option. | 52 | 27 | [
{
"comment_id": "6469287",
"author": "Mike",
"timestamp": "2022-05-06T18:41:08",
"content": "What a stupid idea. A) solar? really so what all my equipment needs to be outside for this to work? B) If you have that kind of issue where Loctite or a locking nut don’t work, you have larger issues. Th... | 1,760,372,701.874496 | ||
https://hackaday.com/2022/05/06/retrotechtacular-how-television-worked-in-the-1950s/ | Retrotechtacular: How Television Worked In The 1950s | Jenny List | [
"Retrotechtacular",
"Video Hacks"
] | [
"crt",
"image orthicon",
"ntsc",
"tv"
] | Watching television today is a very different experience from that which our parents would have had at our age, where we have high-definition digital on-demand streaming services they had a small number of analogue channels serving linear scheduled broadcasting. A particular film coming on TV could be a major event that it was not uncommon for most of the population to have shared, and such simple things as a coffee advert could become part of our common cultural experience. Behind it all was a minor miracle of synchronised analogue technology taking the signal from studio to living room, and this is the subject of a 1952 Coronet film,
Television: How It Works!
Sit back and enjoy a trip into a much simpler world in the video below the break.
Production values for adverts had yet to reach their zenith in the 1950s.
After an introduction showing the cultural impact of TV in early-50s America there’s a basic intro to a cathode-ray tube, followed by something that may be less familiar to many readers, the Image Orthicon camera tube that formed the basis of most TV signals of that era.
It’s written for the general public, so the scanning raster of a TV image is introduced through the back-and-forth of reading a book, and then translated into how the raster is painted on the screen with the deflection coils and the electron gun. It’s not overly simplified though, for it talks about how the picture is interlaced and shows how a synchronisation pulse is introduced to keep all parts of the system working together.
A particularly fascinating glimpse comes in a brief mention of the solid copper co-axial cable and overland microwave links used to transmit TV signals across country, these concrete towers can still be seen today but they no longer have the colossal horn antennas we can see in the film.
A rather obvious omission in this film is the lack of any mention of colour TV, as while it would be late 1953 before the NTSC standard was formally adopted and early 1954 before the first few colour sets would go on sale. Colour TV would have been very much the Next Big Thing in 1952, but with no transmissions to watch and a bitter standards war still raging between the field-sequential CBS system and RCA’s compatible dot-sequential system that would eventually evolve into the NTSC standard it’s not surprising that colour TV was beyond the consumer audience of the time.
Thus we’re being introduced to the 525-line standard which many think of as NTSC video, but without the NTSC compatible colour system that most of us will be familiar with. The 525-line analogue standard might have disappeared from our living rooms some time ago, but
as the last few stations only came off-air last year
we’d say it had a pretty good run.
We like analogue TV a lot here at Hackaday, and
this certainly isn’t the first time we’ve gone all 525-line
. Meanwhile for a really deep dive into the inner workings of TV signal timing, get ready to
know your video waveform
. | 29 | 11 | [
{
"comment_id": "6469265",
"author": "12AU76L6GC",
"timestamp": "2022-05-06T17:35:48",
"content": "2 comments here:It’s important to remember that the acronym NTSC stood for Never Twice the Same Color.Back in the day most feeds were network or film as videotape was rare and expensive. During times o... | 1,760,372,701.688378 | ||
https://hackaday.com/2022/05/06/hackaday-podcast-167-deadly-art-projects-robot-lock-pickers-led-horticulture-and-good-samaritan-repairs/ | Hackaday Podcast 167: Deadly Art Projects, Robot Lock Pickers, LED Horticulture, And Good Samaritan Repairs | Tom Nardi | [
"Hackaday Columns",
"Podcasts"
] | [
"Hackaday Podcast"
] | Join Hackaday Editor-in-Chief Elliot Williams and Managing Editor Tom Nardi for a review of all the tech that’s fit to print. Things kick off with an update about the Hackaday Prize and a brief account of the 2022 Vintage Computer Festival East. Then we’ll talk about an exceptionally dangerous art project that’s been making the rounds on social media, a smart tea kettle that gave its life so that others can hack their device’s firmware, some suspiciously effective plant grow lights, and the slippery slope of remote manufacturer kill switches. We’ll wrap things up with some thought provoking discussion about personal liability as it pertains to community repair groups, and a close look at what makes synthetic oil worth spending extra on.
Check out the links below if you want to follow along, and as always, tell us what you think about this episode in the comments below!
Direct Download link
.
Where to Follow Hackaday Podcast
Places to follow Hackaday podcasts:
iTunes
Spotify
Stitcher
RSS
YouTube
Check
out our Libsyn landing page
Episode 167 Show Notes:
News This Week:
2022 Hackaday Prize Enters Second Round: Reuse, Recycle, Revamp
Vintage Computer Festival East Raises The Bar Again
What’s that Sound?
The sound was the click-clacking of a
Strowger old-school phone switch
. [Aage] won it!
Interesting Hacks of the Week:
The Deadliest Project On The Internet?
Dumping Encrypted-At-Rest Firmware Of Xiaomi Smart Kettle
Taking Water Cooler UX Into Your Own Hands With Ghidra
Blending Pepper’s Ghost, Synths, And Vintage TVs
Pepper’s Ghost on Smartphone – YouTube
Plant Growth Accelerated Tremendously With LEDs
This 3D Printed Robot Can Actually Pick Locks
For Once, The Long Arm Of John Deere Presses The Right Button
John Deere And Nebraska’s Right To Repair, The Aftermath Of A Failed Piece Of Legislation
Will John Deere Finally Get Their DMCA Comeuppance?
Samsung Bricks Smart TVs
Quick Hacks:
Elliot’s Picks:
Simple Hardware Switch For OS Dualbooting, Thanks To RP2040
Kaleidoscope – Feelings Turned Into LED Tree
I2C Tap Helps Assign Blame For SDA Conflicts
Tom’s Picks:
Wearable Electronics Takes The 3D Printing Route
Need A Snack From Across Town? Send Spot!
Hacking Toy RC Cars With The HackRF One
Can’t-Miss Articles:
Ask Hackaday: Repair Café Or Not?
Big Chemistry: Synthetic Oil | 2 | 1 | [
{
"comment_id": "6469240",
"author": "@arduinoenigma",
"timestamp": "2022-05-06T16:23:05",
"content": "Yay! @arduinoenigma mention at 09:15",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6469332",
"author": "Elliot Williams",
"timestamp": "20... | 1,760,372,701.781087 | ||
https://hackaday.com/2022/05/06/super-tough-resin-is-literally-as-tough-as-nails/ | Super Tough Resin Is Literally As Tough As Nails | Dave Rowntree | [
"3d Printer hacks"
] | [
"masked SLA",
"nail",
"resin printing",
"tough"
] | Resin printing still seems to polarize opinions amongst hacker types, with some considering such machines a good tool for the right tasks, and some just plain rejecting them outright. There are many arguments for and against, but like fused deposition modeling (FDM) machines, resin printers are improving in leaps and bounds — and so is the liquid resin itself. Nowadays low-odor resins are common, colors and finishes are varied, and now thanks to some dedicated development work, the brittleness that often characterizes such prints it being addressed. [Mayer Makes] has designed a super tough “engineering resin” that he demonstrates is so tough,
you can print a nail and hammer it into a block of wood
! (Video, embedded below, if you don’t believe it.)
This particular resin is destined for mixing, given its natural cured shade is a kind of greenish-grey, but it does
have a neat trick of presenting a definite yellowish hue when not fully cured, which is very helpful. This is particularly useful when removing support structures as you can use the color change during the curing process to judge the right moment to snap off the thicker sections, minimizing the risk of damaging the print. The resulting printed part is also tough enough to withstand subsequent traditional post-processing, such as milling, giving greater final finishing tolerances. Try doing that with an FDM print.
One of the neat things about resin chemistry is that you can simply mix them in their liquid form to tune the resin properties yourself and they can also be colored with specially formulated dyes without affecting the other properties too much, so this new super-tough resin gives prototypers yet another tool in their resin armory.
Thinking of taking the plunge and giving resin printing a try? Checkout our
handy guide which may give you a leg up
! If that doesn’t swing it for you, you could always
use resin to help smooth out your FDM prints
. It’ll probably still smell funny, mind. | 29 | 9 | [
{
"comment_id": "6469227",
"author": "Foldi-One",
"timestamp": "2022-05-06T16:09:15",
"content": "Still lots of questions about that resins real material properties, lots of the better resins could take being hammered into soft wood end grain with what looks like a pilot hole, just don’t wack ’em to... | 1,760,372,701.953353 | ||
https://hackaday.com/2022/05/06/this-week-in-security-uclibc-and-dns-poisoning-encryption-is-hard-and-the-goat/ | This Week In Security: UClibc And DNS Poisoning, Encryption Is Hard, And The Goat | Jonathan Bennett | [
"Hackaday Columns",
"News",
"Security Hacks"
] | [
"DNS spoofing",
"kubernetes",
"openwrt",
"This Week in Security"
] | DNS spoofing/poisoning is the attack discovered by [Dan Kaminski] back in 2008 that simply refuses to go away. This week
a vulnerability was announced in the uClibc and uClibc-ng
standard libraries, making a DNS poisoning attack practical once again.
So for a quick refresher, DNS lookups generally happen over unencrypted UDP connections, and UDP is a stateless connection, making it easier to spoof. DNS originally just used a 16-bit transaction ID (TXID) to validate DNS responses, but
[Kaminski] realized that wasn’t sufficient
when combined with a technique that generated massive amounts of DNS traffic. That attack could poison the DNS records cached by public DNS servers, greatly amplifying the effect. The solution was to randomize the UDP source port used when sending UDP requests, making it much harder to “win the lottery” with a spoofed packet, because both the TXID and source port would have to match for the spoof to work.
uClibc
and uClibc-ng are miniature implementations of the C standard library, intended for embedded systems. One of the things this standard library provides is a DNS lookup function, and this function has some odd behavior. When generating DNS requests, the TXID is incremental — it’s predictable and not randomized. Additionally, the TXID will periodically reset back to it’s initial value, so not even the entire 16-bit key space is exercised. Not great.
Your OpenWRT must be this old to be vulnerable.
The twist comes when we look at the history of uClibc. It was originally written for μClinux, a Linux port for microcontrollers. When Linksys released the source for the WRT54G, some of the projects springing up around that code drop combined the source with the uClibc library and buildroot. OpenWRT was one of the notable users, and when uClibc development stalled, OpenWRT devs forked it as uClibc-ng. OpenWRT took off in popularity, and several vendors like Qualcomm have adopted it as their SDK. This is how we get things like
OpenWRT 15.05 running on the Starlink router
.
The vulnerability disclosure (first link, way up there ^) name-checks OpenWRT as using uClibc-ng. This was the case up until 2017, when the LEDE release moved to the better-maintained musl standard library. No maintained release of OpenWRT has this vulnerability. The problem is devices like the Starlink router, which may be vulnerable, as it’s running an ancient fork of OpenWRT.
Code Review the Hard Way
Researchers from the Dolos Group were hired for a simple task, a
code review for robot code
. Robot here meaning RPA Robots from Automation Anywhere — snippets of Robotic Process Automation code. These are scripts with GUIs to automate a process, like copying data from one form to another. The problem is that these scripts were less-than-straightforward to audit. It was a zip, containing XML files, containing Base64 encoded data. Decode the base64 data and the result is… random noise. The possibilities are that it’s actually binary data, it’s compressed, or it’s encrypted. A quick test using
ent
reveals that it’s almost perfectly random — it’s encrypted. How do you go about auditing encrypted code? The better question may be, how does the application run encrypted code?
The answer is straightforward: the framework installer includes hard-coded AES keys. We could ask what the point of pre-shared key encryption is, when the key is publicly available. If we allow ourselves to be a bit jaded, then we might conclude that these scripts are encrypted solely so the company can advertise “Bank-grade encryption” on their website — there’s certainly no security advantage to it. The Dolos Group researchers are a bit more charitable, simply observing that managing keys is a much harder problem than cryptography itself.
Bank Hacking Made Easy
[Hussein Daher] and [Shubham Shah] of Assetnote took on the challenge of a bank’s bug bounty program, and discovered that dotCMS was
the most interesting avenue to peruse
. Why? It’s open source, so they were doing code auditing instead of black box investigation. And auditing did indeed find something interesting. DotCMS had a file upload function with a directory traversal flaw. This theoretically means an easy RCE — just upload a web shell, and open the url. On the real system it’s a bit more complicated. First off, they had to map the directory structure of the target system, not an easy task. Even using a neat trick,
/proc/self/cwd/
to get to the right directory, the actual webroot was locked down tight. The actual PoC that worked was to attack the JavaScript location, as those scripts could be overwritten. It’s a fun tale of finding quite a serious problem. It sounds like they did quite well for themselves on this bug bounty search.
The Kubernetes Goat
The best way to learn about the security of a platform is to dive in and get your hands dirty. This is apparently the opinion of [Madhu Akula], who
built Kubernetes Goat as an intentionally insecure playground
for Kubernetes. The cluster of Docker images comes with a series of scenarios — guided vulnerabilities for you to explore and learn from. If Docker or Kubernetes security sounds interesting, grab the Goat by the horns and dive in.
Who Is UNC3524
Mandiant has discovered a particularly sneaky APT group
, naming them UNC3524. Think of that as a placeholder, as there’s a decent chance this is one of our old friends, like Fancy Bear and Cozy Bear, both Russian-based groups. There are not enough giveaways to make a positive identification, and it could be a different group entirely, as all of the indicators are publicly known techniques — like the use of
reGeorg
for proxying connections. That’s open source software, as well as open source intelligence.
Regardless, these guys managed some impressive feats, like staying in a network undetected for 18 months in some cases. A distinct technique is to compromise IoT devices on the network, like IP cameras, and use those as local command and control servers. As they say, the S in IoT stands for security. Network segregation is your friend.
Once a foothold is established, the group targets IT and executive workers, and tries to get access to their email accounts. It speculated that IT accounts are targeted to know when the infection is discovered. The executive account access showed evidence that the attackers were looking for advance notice of corporate news, like mergers and acquisitions. Knowing these kind of plans in advance could give an investor a huge edge in trading, but the advanced techniques suggest a government sponsored actor. Maybe Russia or another state is developing a novel revenue stream. There are a few Indicators of Compromise to watch out for. One of the easiest to spot is SSH traffic on non-standard ports. There are a few known DNS names as well.
Via Ars Technica | 8 | 2 | [
{
"comment_id": "6469170",
"author": "RW ver 0.0.3",
"timestamp": "2022-05-06T14:09:38",
"content": "No, the S in IoT works harder than that, it stands for Security, Stability and Sustainability.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6469174",
... | 1,760,372,703.559841 | ||
https://hackaday.com/2022/05/06/audio-eavesdropping-exploit-might-make-that-clicky-keyboard-less-cool/ | Audio Eavesdropping Exploit Might Make That Clicky Keyboard Less Cool | Dan Maloney | [
"Peripherals Hacks",
"Security Hacks"
] | [
"ai",
"audio",
"clicky",
"eavesdropping",
"exploit",
"mechanical keyboard",
"Side channel"
] | Despite their claims of innocence, we all know that the big tech firms are listening to us. How else to explain the sudden appearance of ads related to something we’ve only ever spoken about, seemingly in private but always in range of a phone or smart speaker? And don’t give us any of that fancy “confirmation bias” talk — we all know what’s
really
going on.
And now, to make matters worse, it turns out that
just listening to your keyboard clicks
could be enough to decode what’s being typed. To be clear,
[Georgi Gerganov]’s “KeyTap3” exploit
does not use any of the usual RF-based methods we’ve seen for exfiltrating data from keyboards on air-gapped machines. Rather, it uses just a standard microphone to capture audio while typing, building a cluster map of the clicks with similar sounds. By analyzing the clusters against the statistical likelihood of certain sequences of characters appearing together — the algorithm currently assumes standard English, and works best on clicky mechanical keyboards — a reasonable approximation of the original keypresses can be reconstructed.
If you’d like to see it in action, check out the video below, which shows the algorithm doing a pretty good job decoding text typed on an unplugged keyboard. Or, try it yourself — the link above implements KeyTap3 in-browser. We gave it a shot, but as a member of the non-mechanical keyboard underclass, it couldn’t make sense of the mushy sounds it heard. Then again, our keyboard inferiority affords us some level of protection from the exploit, so there’s that.
Editors Note
: Just tried it on a mechanical keyboard with Cherry MX Blue switches and it couldn’t make heads or tails of what was typed, so your mileage may vary. Let us know if it worked for you in the comments.
What strikes us about this is that it would be super simple to deploy an exploit like this. Most
side-channel attacks
require such a contrived scenario for installing the exploit that just breaking in and stealing the computer would be easier. All KeyTap needs is a covert audio recording, and the deed is done. | 45 | 13 | [
{
"comment_id": "6469080",
"author": "Suimi",
"timestamp": "2022-05-06T11:24:24",
"content": "Nothing new: the concept is at least 17 years old:https://dl.acm.org/doi/10.1145/1102120.1102169",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6469184",
"a... | 1,760,372,703.743566 | ||
https://hackaday.com/2022/05/06/game-light-brings-video-games-to-your-keychain/ | Game & LightBrings Video Games To Your Keychain | Robin Kearey | [
"Games",
"handhelds hacks"
] | [
"ATtiny402",
"diy handheld",
"portable game system"
] | If you’re old enough to remember the 1990s, you might recall the sheer variety of portable gaming platforms that were around in those days. There was of course the ubiquitous hand-held Game Boy, and if you preferred something larger you could buy a Sega Game Gear or an Atari Lynx. But you could also go smaller with tiny LCD games like Nintendo’s
Game and Watch
series, with some versions literally the size of a wristwatch.
With all of these having gone the way of the dodo, we’re happy to see that [grossofabian] kept the tiny game world alive by designing the
Game & Light
: a tiny hand-held games platform with an OLED screen
. It’s small enough to attach to your keychain and comes with an LED to act as a mini flashlight. But of course the main feature is the included video game: currently it comes with
LEDboy Adventures
, a side-scrolling platformer similar to Google’s T-Rex Game. A USB port can be used to recharge the device as well as to upload new games.
The
Game & Light
is housed in a 3D printed case and powered by a lithium-ion capacitor that can store enough charge for around 40 minutes of play time. The CPU is an ATtiny402 eight-pin microcontroller with 4 kB of flash, which is just enough to store the entire
LEDboy
game. Although currently only one game is available, the system is fully programmable and open sourced, so anyone who feels up to the task can help develop new games for the platform.
If you like keychain-sized games, you’re in luck: we recently featured the solar-powered but otherwise similar
RunTinyRun
. A bit longer ago, creative hackers even managed to squeeze
entire Game Boys
into
tiny packages
. | 0 | 0 | [] | 1,760,372,703.661016 | ||
https://hackaday.com/2022/05/05/powering-a-backyard-railway-with-compressed-air/ | Powering A Backyard Railway With Compressed Air | Dan Maloney | [
"Transportation Hacks"
] | [
"compressed air",
"engine",
"locomotive",
"pneumatic",
"rail",
"railway"
] | When you’ve gone to the trouble of building your own backyard railway, chances are pretty good that at some point, you’re going to want to add a locomotive of some sort. After all, nobody wants to be stuck using muscle power to move carts around. But what exactly are you going to power your locomotive with? And will it be up to the tasks you envision it handling?
Answering such questions calls for rigorous calculations using established engineering principles — or, if you’re [Tim] from the Way Out West channel on YouTube, just
throwing a pneumatic engine on wheels
and seeing what happens. The railway that [Tim] built is for his farm in County Cork, where he plans to use it to haul wood that he’ll make charcoal from. We’ve seen a little about
his rails and rolling stock
before, which has been a low-budget and delightfully homebrewed undertaking. So too with his pneumatic engine, seen in the video below, which uses cam-operated valves to control a pair of repurposed hydraulic cylinders to turn a big flywheel.
Using scuba tanks, [Tim] was able to power the engine for a full fourteen minutes — very encouraging. But would the engine have the oomph needed for real farm work? To answer that, [Tim] plunked the engine on a spare bogie, connected the engine shaft to one of the axles with a length of rope, and let it go. Even with no optimization and zero mechanical advantage, the engine was easily able to move a heavy load of sleepers. The makeshift pneumatic railway even managed to carry its first passenger, [Tim]’s very trusting wife [Sandra].
There’s clearly more work to do here, and many problems to overcome. But we really appreciate the “just try it” approach [Tim] employed here, and with a lot of what he does. | 12 | 6 | [
{
"comment_id": "6469025",
"author": "Michael Smith",
"timestamp": "2022-05-06T08:05:37",
"content": "This why scuba compressor technology is horrible.they pressure to 4500 psi. How about a smaller or shorter stroke length for less volume used? With some gears?",
"parent_id": null,
"depth": ... | 1,760,372,703.790552 | ||
https://hackaday.com/2022/05/05/automate-the-freight-autonomous-buses-to-start-operation-in-uk/ | Automate The Freight: Autonomous Buses To Start Operation In UK | Dan Maloney | [
"News",
"Transportation Hacks"
] | [
"Automate the Freight",
"autonomous",
"bus",
"mass transit",
"public transportation",
"SAE Level 4",
"Scotland",
"uk"
] | The UK will get its
first full-size autonomous bus service this summer
, if final road testing that begins in the next two weeks goes according to plan.
Known as Project CAVForth for the UK government’s Center for Connected and Autonomous Vehicles (CCAV) and the Forth bridge, over which the buses will travel, it is said to be the most complex test of autonomous on-road mass transit yet undertaken in Europe. The full-size single-deck motorcoaches, five in total, will ply a 22-km (14-mile) route into Edinburgh from Fife, crossing the famous Firth of Forth on the Forth Road suspension bridge. The buses will carry about 36 passengers each and run at SAE Level 4 autonomy, meaning that a safety driver is optional under good driving conditions.
The riding experience will not, however, be entirely human-free. Based on focus group feedback, the bus company will be recruiting “Autonomous Bus Professionals” from their pool of trained drivers. Two of these employees will be on each bus — one in the driver’s seat to monitor the systems, and one to serve as a “Captain,” who will walk the aisle and chat up the passengers. It seems like a good idea to allay any fears the passengers might have about looking up and seeing nobody driving the bus. There’s historical precedence for this; elevator operators were very much a thing even well after automatic controls had been figured out, for precisely the same reason.
The central contention of “Automate the Freight” is that full autonomy will be deployed to commercial trucking long before it becomes mainstream in the consumer space, and when you consider that buses really are nothing more than
trucks for human cargo
, this project supports that argument. And when you think about it, public transportation is a great test case for full autonomy — the route is well-defined, it’s laid out in an urban setting with a lot of infrastructure, and there’s the bonus of self-loading cargo.
Granted, the stakes are a little higher when you’re carrying freight that has the tendency to sue if anything goes wrong. But somebody has to go first, and it’s encouraging to see that the project’s participants and sponsors have enough confidence in the system to field it. We’ll be watching carefully to see how it turns out.
[via
Singularity Hub
] | 40 | 8 | [
{
"comment_id": "6468980",
"author": "Andrew",
"timestamp": "2022-05-06T02:44:05",
"content": "Congratulations! Travels between two fixed points along a fixed route. Almost as good as a train!",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6469023",
... | 1,760,372,704.252553 | ||
https://hackaday.com/2022/05/05/maze-bolt-toy-by-lost-pla-casting/ | Maze Bolt Toy By Lost PLA Casting | Anne Ogborn | [
"3d Printer hacks"
] | [
"3d printing",
"aluminium casting",
"maze bolt"
] | Maze bolts, a bolt which has a maze along its shaft traversed by a pin on its nut, are great fun.
Here’s a really beautiful metal version
by [Robinson Foundry], made by a process more makers should know about – lost PLA casting.
His basic method is to 3D print in PLA, and then use more or less the same process as lost wax casting.
He 3D printed the part, along with the sprues and risers that go along with casting, in PLA, then dipped the parts in slurry ten (10) times. He heated in a kiln to 500°F (260°C), the PLA melted and ran out or burned away. With the PLA gone, after repairing a few cracks, he raised the temperature to 1500°F (815°C) and vitrified the slurry into a ceramic. He now had molds.
The nut is bronze. The bolt is aluminum. He poured the metal with the molds hot, held in heated sand, so the metal can flow into all the small details. The rest of the project is just cleanup, but we learned that you can vary the finish produced by glass bead blasting just by varying the air pressure.
A great demo of a useful technique and a fun toy at the end.
We covered a great technique for doing
lost PLA casting using a microwave
. | 8 | 5 | [
{
"comment_id": "6468996",
"author": "creator2014",
"timestamp": "2022-05-06T04:18:23",
"content": "Very cool…",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6469008",
"author": "Dan",
"timestamp": "2022-05-06T06:12:05",
"content": "People complain... | 1,760,372,703.509882 | ||
https://hackaday.com/2022/05/05/toast-keyboard-raises-a-glass-to-short-index-fingers/ | Toast Keyboard Raises A Glass To Short Index Fingers | Kristina Panos | [
"Peripherals Hacks"
] | [
"column stagger",
"Elite-C",
"ergonomic keyboard",
"split keyboard"
] | Custom keyboards? They’re totally great. And we can keep telling you this, but you really won’t feel it until you try a few and find one or two that are right for you. If you’re already on board, we wonder: is there any limit to what custom keyboards can provide in terms of a good, comfortable time for your fingers, wrists, arms, shoulders, and neck? We think not, and as time goes on, there is more and more evidence to support this.
Take [vpzed]’s Toast keyboard for example
. The beauty of customization is that as with any other human input problem, you’ll discover many more people who share your misery once you present a solution. In this case, it is the portion of the population whose index fingers are shorter than their ring fingers (which is evidently men in general).
This is known as the 2D:4D ratio
and is decided during gestation. At first, the phenomenon was thought to be due to high testosterone exposure in the womb, but subsequent studies have debunked this belief.
Toast aims to sate the need for a keyboard layout that accounts for a significantly shorter 2D than 4D by way of aggressively staggering the index finger’s key positions and staggering the columns overall. As you might imagine, there are no inner keys for length-challenged index fingers to grasp at — that would just be cruel. But there is another pinky column on each hand, which bring the key total to 34. We like the square boards, and frankly wish they were bread-shaped.
Not enough keys for you?
Take a look at this many-keyed monoblock split with a numpad in the middle
.
via
KBD | 4 | 1 | [
{
"comment_id": "6468847",
"author": "The Commenter Formerly Known As Ren",
"timestamp": "2022-05-05T20:04:53",
"content": "I hadn’t noticed before that my Index finger is shorter (by a little bit) than my Ring finger!But I do have trouble accurately hitting the “6” key on keyboards.",
"parent_i... | 1,760,372,703.832472 | ||
https://hackaday.com/2022/05/05/2022-hackaday-prize-disposable-vape-pens-turned-project-parts/ | 2022 Hackaday Prize: Disposable Vape Pens Turned Project Parts | Arya Voronova | [
"how-to",
"Parts",
"The Hackaday Prize"
] | [
"2022 Hackaday Prize",
"e-cig",
"e-cigarette",
"e-cigarette hack",
"e-waste recycling",
"ecig",
"recycling",
"reuse",
"vape",
"vape pen",
"vaping"
] | Disposable vape pens, a sub-genre of electronic cigarettes, have been a fad for a few years now – they’re small self-contained devices with a rechargeable battery and some vape liquid inside. As the battery discharges and the liquid runs out, the entire vape pen is typically thrown out. [Dimitar] wants to change that, however, and teaches us how to
reuse as much of the vape pen as possible
— as yet another underappreciated source for parts we can use in our projects.
In an extensive worklog, he breaks down and documents
a vape pen’s inner workings,
coupled with a video we’ve placed below the break showing
ways to disassemble them.
In these, he shows how we can reuse the casing and the plastic parts, should any of us be interested in a project that happens to fit the e-cig form factor. Attention is paid to the sensor that triggers the evaporation — it may look like a microphone, but is actually a purpose-built pressure-sensor with a high-side switch! He tears into one of these
in a separate video
, showing how to reuse it as a capacitive touch controller. He also aiming to assemble a small database of related resources
on GitHub,
currently, hosting the files for
the protection circuit
he developed as part of
his recommendations
for safely reusing vape pen Li-ion batteries.
[Dimitar]’s journey is ongoing, and we can’t wait to see some fun uses for these components that he will certainly stumble upon on his way! For instance, here’s a hacker
using an e-cig battery
to power a pair of RGB LED-adorned sunglasses, replacing the AAAA battery they originally came with. We’ve seen hackers make guides on reusing each and every part of
microwave ovens
,
printers
and
laptops,
and we ourselves have talked about reusing
ATX power supplies
and computer mice.
The
Hackaday
Prize2022
is Sponsored by: | 50 | 17 | [
{
"comment_id": "6468821",
"author": "paulvdh",
"timestamp": "2022-05-05T18:51:00",
"content": "Why does a disposable product have a rechargable battery?It seems awfully despicable.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6468896",
"author": "... | 1,760,372,703.923324 | ||
https://hackaday.com/2022/05/05/a-minimal-motoring-manifesto/ | A Minimal Motoring Manifesto | Jenny List | [
"Hackaday Columns",
"Rants",
"Transportation Hacks"
] | [
"automotive design",
"cars",
"motoring"
] | A couple of years ago, Hackaday published an article, “
Electric Vehicles Continue the Same Wasteful Mistakes That Limit Longevity
“, in which we took a look at the way the car industry, instead of taking the move to electric traction as an opportunity to simplify their products, was instead making their electric offerings far more complex. It touched a nerve and received a very large comment volume, such that now it is our 19th most commented story of all time.
It’s something brought back to the fore by
seeing a
T
he Drive
piece
bemoaning the evolution of the automobile as a software receptacle governed by end-user licenses rather than a machine under the control of its owner. In turn that’s posed the question: Just what do you really need for a car, and what is superfluous? Time to provide an answer to that question, so here it is: a minimal motoring manifesto.
It’s The Subsystems, Not The Design
The mechanical parts of a motor vehicle are by and large a done deal. We worked out long ago how to make motor vehicles that don’t decay in a short time, that have reliable mechanics, are safe to use, and handle well on the road. The front-wheel-drive car with transverse motor and transmission, a wheel as close to each corner as it can be, and independent suspension all round has been a staple on the road since the 1970s, and the probability is high that one will be sitting on your driveway.
It matters not whether it has an internal combustion engine or an electric motor, over time it has evolved to offer exceptional crash protection and a reasonable weight. Thus this is not about the physical and mechanical design of a motor vehicle, instead it concerns the subsystems that run the show. In a world where engines don’t break at 100,000 miles and it’s not uncommon to see two-decade-old cars with no rust, it’s these subsystems which will make the difference between a car under the control of its owner and one which makes an early exit to the scrapyard.
Separate The Subsystems
A Lucas engine management system from the 1990s. ColinMB,
CC BY-SA 3.0
In every motor vehicle, there are different systems responsible for their respective tasks. Sometime these are integral to the safety or operation of the car such as the engine management or the antilock braking, other times they are not, such as the air conditioning or the entertainment system. The former are essential, the latter are toys to entice would-be owners to buy the cars.
We get it that a new car buyer wants plenty of toys to brag about and feel good about their purchase, but at the same time the extra complexity brought about by those toys should not be the reason for a car with plenty of life left in it to come off the road a few years later. So here’s the first manifesto point: separate the toys from the essential stuff such that whatever runs the toys is not mission critical to the operation of the vehicle, and what remains is not governed by subscription or software licensing terms. By all means have the navigation system disappear when the app goes to abandonware, but this should not come at the expense of the car’s being able to operate.
Provide A Minimal Way In
The OBD interface provides a way in, but not the one that’s needed. Losch,
CC BY 3.0
The saddest thing about walking round a scrap yard here in 2022 is that where once there would have been plenty of worn-out cars, today there are as many near-perfect cars. The computing power behind those toys for the person who drives it off the forecourt is a technological tour de force, but that’s of scant comfort to whoever owns it at ten years old who is faced with a bill for its replacement.
We understand that the manufacturer wants to build planned obsolescence into their products, but at the same time it’s for them to make better cars without resorting to dirty tricks. It should not be beyond the bounds of technical possibility to have a standard interface with enough capabilities for third party electronics to provide those essential functions to keep the vehicle going.
Here’s A Novel Idea…
Would anyone like to claim that minimalism can’t be fun to drive? Neozoon,
CC BY-SA 3.0
We mentioned earlier that to some extent automotive design is a done deal, in that the transverse engined front wheel drive vehicle is king. Of course owners of RWD vehicles will chime in below in the comments, but it’s fair to say that with not many exceptions there’s surprisingly little difference between models.
A VW and a Ford and a Nissan feel so much like the same car in a way that their equivalents from several decades ago wouldn’t have, so the differentiating factors come down to the details. So desperate are they to differentiate themselves, that to distract from the blandness of the driving experience they instead concentrate on the experience of being in the car. It’s been such an insidious process as to be almost invisible, but should you try sitting in a car from decades past you’ll immediately see the difference. The older car has very little to distract the motorist, it’s a much less cluttered experience.
So here’s a novel idea, how about starting the design process from a point of view that less is more, and creating vehicles with the minimum required for them to be driven, because they are simply fun to drive? Perhaps people have forgotten even that driving can be fun.
Of Crooks And Dreamers
Of course, we know that this grandiosely-titled manifesto is simply a collection of ideas, and that no manufacturer will act on them. I once heard the adage that there were two types of small-production motor manufacturer, either crooks or dreamers, and I’m guessing that puts this article firmly in the land of dreamers.
But watching motor vehicles as an enthusiast sometimes feels like being an outsider in your own world, while everyone is gushing about the in-car entertainment system and you’re wondering why they don’t seem worried about its longevity or that the utilitarian styling cues aren’t matched by any pretence of ability away from the school run. We may be living in late-stage automobile design, but that doesn’t mean we have to like it.
Header image: Unknown author/
public domain
. | 103 | 21 | [
{
"comment_id": "6468790",
"author": "monsonite",
"timestamp": "2022-05-05T17:46:23",
"content": "Jenny,Great article.Don’t forget that the Mini trailblazed the transverse engine FWD in 1959.The Citroen Traction Avant was more than a decade earlier with FWD.I have been building and using electric ve... | 1,760,372,704.174806 | ||
https://hackaday.com/2022/05/05/2022-hackaday-prize-enters-second-round-reuse-recycle-revamp/ | 2022 Hackaday Prize Enters Second Round: Reuse, Recycle, Revamp | Elliot Williams | [
"contests",
"green hacks"
] | [
"2022 Hackaday Prize",
"contest",
"prize",
"recycling"
] | Ding! That’s the bell for the second challenge round of the
2022 Hackaday Prize
. If your project reuses or recycles what would otherwise be waste materials, or helps you to do the same for further projects, we want to see it.
Hackers are often frugal folk — we’ll
recycle parts for projects
because it’s easier on the pocketbook when prototyping. But in
these strangest of times
, when we’ve seen $1 microcontrollers in such shortage that they fetch $57 apiece (if you can get the parts at all), making use of what you’ve got on hand can be an outright necessity. If this is going to become the new normal, it’s going to make sense that we automate it. There’s gold, literally and metaphorically, in busted PCBs. How are you going to
get the most value out of our broken electronic waste
in our post-apocalyptic near future? Have you built an unpick-and-unplace machine? We’d like to see it.
But electronic parts are a small fraction of your recyclable materials, and plastics might play a larger role. If you’re a 3D printerer, you’ve doubtless thought about
recycling plastic bottles into filament
. Or maybe you’d like to take some of the existing plastics that are thrust upon you by this modern world and give them a second life? This factory
churning out paving stones by remelting plastic with sand
is doing it on an industrial scale, but could this be useful for the home gamer?
Precious Plastic
has a number of inspirational ideas. Or maybe you just need an
HDPE hammer
?
Have you built a
fancy can crusher
, or a
plastics sorter
, or
a recycling robot
? Head on over to
Hackaday.io
, write it up, and enter it into the Prize!
Basically any project that helps you recycle or reuse the material around you is fair game here. (But note that if you’ve got epic repair hacks, you’ll want to enter them in the upcoming Round Three: Hack it Back.) This round runs until June 12th and there are ten $500 awards up for grabs, so get hacking!
The
Hackaday
Prize2022
is Sponsored by: | 8 | 4 | [
{
"comment_id": "6468785",
"author": "jpa",
"timestamp": "2022-05-05T17:32:58",
"content": "Question to Hackaday staff: Is this challenge mainly about machines that recycle (like the examples would suggest), or are also projects that are made out of recycled parts included?",
"parent_id": null,
... | 1,760,372,703.621956 | ||
https://hackaday.com/2022/05/05/about-as-cold-as-it-gets-the-webb-telescopes-cryocooler/ | About As Cold As It Gets: The Webb Telescope’s Cryocooler | Dan Maloney | [
"Engineering",
"Featured",
"Original Art"
] | [
"astronomy",
"cryocooler",
"cryogenics",
"helium",
"Hg:Cd:Te",
"infrared",
"james webb space telescope",
"Joule-Thomson",
"jwst",
"Si:As"
] | If you were asked to name the coldest spot in the solar system, chances are pretty good you’d think it would be somewhere as far as possible from the ultimate source of all the system’s energy — the Sun. It stands to reason that the further away you get from something hot, the more the heat spreads out. And so Pluto, planet or not, might be a good guess for the record low temperature.
But, for as cold as Pluto gets — down to 40 Kelvin — there’s a place that much, much colder than that, and paradoxically, much closer to home. In fact, it’s only about a million miles away, and right now, sitting at a mere 6 Kelvin, the chunk of silicon at the focal plane of one of the main instruments aboard the James Webb Space telescope makes the surface of Pluto look downright balmy.
The depth of cold on Webb is all the more amazing given that mere meters away, the temperature is a sizzling 324 K (123 F, 51 C). The hows and whys of Webb’s cooling systems are chock full of interesting engineering tidbits and worth an in-depth look as the world’s newest space telescope gears up for observations.
Not Cold Enough
Probably the first most obvious question regarding cryocoolers in space is: Why in the world does Webb even need a cryocooler? Isn’t space, especially the area around Webb’s halo orbit around Lagrange point L2, already cold enough? In a word, no — the infrared astronomy Webb’s instruments are designed for, space is nowhere near cold enough. But what’s so special about infrared astronomy, and why does it require such low temperatures?
From its earliest designs, what would become the James Webb Space Telescope was always conceived as an infrared telescope. This is because the objects Webb was intended to study are among the oldest objects in the universe, and Hubble’s Law tells us that the farther away an object is, the faster it is moving away from Earth, the light from them will be dramatically red-shifted thanks to the Doppler effect. This means that the light from pretty much everything Webb will be pointed at lies somewhere in the infrared part of the spectrum. Webb’s four imaging and spectrographic instrument packages can cover from the very edge of the visible portion of the spectrum, around 0.6 μm wavelength, to the mid-infrared wavelengths around 28 μm. For reference, microwaves start at about 100 μm wavelengths, so the frequency of the light that Webb is designed to study isn’t that far above the radio part of the electromagnetic spectrum.
The problem with infrared astronomy is that the sensors used to pick up the light are easily overwhelmed by the heat of their surroundings, which radiates in the infrared region. Also, the photosensors used in infrared telescopes are susceptible to dark current, which is a current flow in the sensor even in the absence of any light falling on it. Dark current is primarily caused by the thermal stimulation of electrons within the sensor material, so keeping the sensor as cold as possible goes a long way to reducing noise.
There’s Cold, and Then There’s MIRI Cold
As stated earlier, Webb has four main instruments. Three of them — the Near-Infrared Camera (NEARCam), the Near-Infrared Spectrograph (NEARSpec), and the Fine Guidance Sensor and Near-Infrared Imager and Slitless Spectrograph (FGS-NIRISS) — all operate in the near-infrared part of the spectrum, as their names suggest. The near-infrared is just below the visible part of the spectrum, around 0.6 to 5.0 μm. The sensors for these wavelengths use an alloy of mercury, cadmium, and tellurium (Hg:Cd:Te), and require cooling down to around 70 Kelvin to be usable.
MIRI’s sensor, a 1024×1024-pixel, arsenic-doped silicon sensor mounted in its focal plane module. The cryocooler will drive this sensor down to 6 K. Source: NASA/JPL
For Earth-based near-IR telescopes, cooling Hg:Cd:Te sensors is usually done with liquid nitrogen. On Webb, though, another option is available, thanks to the massive, five-layer sunshade that protects the observatory from the blazing light of the Sun, as well as the light reflected off the Earth, which thanks to the telescope’s halo orbit is always in view. The layers of Webb’s aluminized Kapton sunshade are spaced out such that incident IR bounces between adjacent layers and eventually radiates out into space more or less perpendicular to the sunshade, rather than penetrating through the layers to the sensitive optics on its dark side. The sunshade receives on the order of 200 kW of energy on the hot side, while allowing only 23 mW to pass through to the cold side. This keeps the instruments located there are a frigid 40 K, which is plenty cold enough for the three near-IR instruments.
But as cold as 40 Kelvins above absolute zero may be, it’s still far too hot for the sensors in the fourth of Webb’s primary instruments. The Mid-Infrared Imager, or MIRI, is designed to take images and make spectrographic observations from 5 to 28 μm, which requires an entirely different sensor than its near-IR cousins. Rather than Hg:Cd:Te, MIRI’s sensor is based on arsenic-doped silicon (Si:As), which needs to be cooled to very close to absolute zero — less than 7 Kelvin.
Sounds Pretty Cold
In the original Webb designs, the ultra-cold temperature needed for MIRI was going to be provided by a Dewar flask containing a cryogenic substance: solid hydrogen. The choice for a stored cryogenic system was made based on the immaturity of space-rated active cryocooling systems capable of reaching 6 K at the time. However, Webb’s now-infamous delays allowed cryocooler technology to develop, and in light of the weight savings an active cryocooler offered, not to mention the potential to use MIRI longer — the instrument would be useless once the solid hydrogen had all boiled off — the decision was made to replace the cryogenic Dewar.
This wasn’t without engineering challenges, of course. Chief among these were the ability to hit the target temperature while staying within power and weight constraints, and not adding undue mechanical vibration to the sensitive optics. Both of these specifications were particularly challenging given the sheer size of Webb, and the physical layout of the observatory, which made it necessary to spread the cryocooler assemblies over three different areas of the spacecraft, each with different thermal regimes to deal with.
Schematic of the cryocooler layout on Webb. Region 3 has the compressors and control electronics, Region 2 covers the refrigerant lines up to the instrument package, And Regio 1 is the cold end at the focal plane. Source. GAO via NASA
The warmest region, designated Region 3, is located in the spacecraft bus. It’s on the hot side of the sunshield, which means it can expect to see temperatures up to 300 K or so. The assembly that’s mounted in this region consists mainly of the cryocooler compressor assembly (CCA) and its associated control electronics. The CCA is the “precooler” of the whole system, using a three-stage pulse tube design to achieve temperatures of about 18 K. Pulse tube cryocoolers have no moving parts aside from the pistons used to generate the pressure waves, making them excellent for low-vibration applications like this.
The pulse tube refrigeration process relies on thermoacoustics to transfer heat. In thermoacoustics, a standing wave is set up within a working gas (helium in the case of Webb’s cryocooler) within a sealed tube. A porous plug, called a regenerator or recuperator, sits within the tube, close to one of the nodes of the standing wave. As the working gas is compressed and expanded, a temperature gradient sets up across the regenerator. The hot end of the pulse tube radiates heat out into space via a heatsink, while the cold end is used to remove heat from a closed-loop heat exchanger, also charged with helium. The video below has an excellent demonstration of the principle of thermoacoustic cooling.
The cooled helium, now at around 18 K, enters Zone 2, which is within the tower that supports Webb’s primary mirror. The temperature in this region is between 100 K and almost 300 K, and the supercold helium has to pass through about two meters of tubing to reach the instruments at the telescope’s focus, so a great deal of engineering went into making sure there would be no unwanted heat transfer.
At the end of its trip through Zone 2, the refrigerant reaches the heart of Zone 1 — the focal plane of MIRI itself. This zone is already at about 40 K thanks to the passive cooling steps outlined before, but to drive the refrigerant down to its final 6 K temperature, it passes through what’s known as a Joule-Thomson valve. The JT valve makes use of the Joule-Thompson Effect to cool the helium working fluid even further.
Webb’s cryocooler after undergoing tests. The silver cylinders to the left house the dual-piston, horizontally opposed compressor, while the black tower holds the pulse tube and regenerator. Not shown is the Joule-Thompson valve assembly. Source: NASA/JPL
Joule-Thomson says that when the pressure of a gas is reduced, its temperature is also reduced. It’s something we’ve all seen before, as when frost forms on the outside of a dusting air can, or the cloud of water droplets that form when an air cannon lobs a projectile into the air. In Webb’s Cold Head Assembly (CHA) inside MIRI, a special valve allows the pressure of the supercold helium to drop suddenly, causing it to drop to around 6 K and cooling a copper block upon which the MIRI sensors are mounted. The helium is piped back through the JT valve and back down the tubing to the CCA, in a closed-loop system.
So far, Webb’s cryocooler system is hitting all its marks and keeping MIRI happy.
As of this writing
, the temperature at the MIRI focal plane has been steadily holding below the 7 K setpoint for more than 14 days, with the other near-IR instruments holding well below their 40 K target. Here’s hoping that we get to see results from these instruments soon.
And just for the record, the coldest natural spot in the solar system might actually be
the “double-shadowed craters” on the Moon’s south pole
, at only 25 K. Poor Pluto — never any respect. | 26 | 10 | [
{
"comment_id": "6468728",
"author": "fiddlingjunky",
"timestamp": "2022-05-05T14:26:52",
"content": "The Joule-Thompson effect is also the working principle of terrestrial refrigerators/ACs. Zone 1 is pretty directly analogous to what’s keeping your lunch meats cold, though typically a phase change... | 1,760,372,704.320751 | ||
https://hackaday.com/2022/05/05/exporting-data-from-old-gear-through-lcd-sniffing/ | Exporting Data From Old Gear Through LCD Sniffing | Arya Voronova | [
"hardware",
"Reverse Engineering"
] | [
"graphic lcd",
"lcd controller",
"lcd mod",
"logic analyzer",
"screen shots",
"screenshot",
"sniffing",
"Spectrophotometer",
"spectrophotometry"
] | [Jure Spiler] was at a flea market and
got himself a spectrophotometer
— a device that measures absorbance and transmittance of light at different wavelengths. This particular model seems to be about 25 years old, and it’s controlled by a built-in keyboard and uses a graphical LCD to display collected data. That might have been acceptable when it was made, but it wasn’t enough for [Jure]. Since he wanted to plot the spectrophotometry data and be able to save it into a CSV file, hacking ensued.
He decided to tap into the the display communication lines. This 128×64 graphical display, PC-1206B, uses a 8-bit interface, so with a 16-channel logic analyzer, he could see the data being sent to the display. He even wrote
decoder software
– taking CSV files from the logic analyzer and using primitive optical recognition on the decoded pixels to determine the digits being shown, and drawing a nice wavelength to absorbance graph. From there, he set out to make a standalone device sniffing the data bus and creating a stream of data he could send to a computer for storage and processing.
[Jure] stumbled into a roadblock, however, when he tried to use an Arduino for this task. Even using a sped-up GPIO library (as opposed to
notoriously inefficient
digitalRead
), he couldn’t get a readout frequency higher than 80 KHz – with the required IO readout rate deemed as 1 MHz, something else would be called for. We do wonder if something like RP2040 with
its PIO machinery
would be better for making such captures.
At that point, however, he found out that there’s undocumented serial output on one of the pins of the spectrophotometer’s expansion port, and is currently investigating that, having shelved the LCD sniffing direction. Nevertheless, this serves as yet another example for us, for those times when an LCD connection is all that we can make use of.
We’ve seen hackers sniff LCD interfaces to get data from reflow ovens,
take screenshots from Game Boys
and even
equip them with HDMI and VGA ports
afterwards. With a skill like this, you can even give
a new life to a vintage calculator
with a decayed display! Got an LCD-equipped device but unsure about which specific controller it uses?
We’ve talked about that! | 27 | 8 | [
{
"comment_id": "6468673",
"author": "Manawyrm",
"timestamp": "2022-05-05T11:11:39",
"content": "I love the use of Visual Basic 6 in 2022. It’s super old and outdated by todays standards, but it just works :D",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "64... | 1,760,372,704.564357 | ||
https://hackaday.com/2022/05/05/twang32-brings-led-strip-gaming-to-the-esp32/ | TWANG32Brings LED Strip Gaming To The ESP32 | Jenny List | [
"Games",
"LED Hacks"
] | [
"1d game",
"ESP32",
"game",
"led"
] | Under the Hackaday TV is a modern game console, it’s a well-known model that many of you also probably have, and its main feature is a 3D accelerator which allows it to create the beautifully rendered worlds we’ve all come to know and love. [Mircemk] eschews such fripperies with the Twang project, because
it’s a game that’s not 3D, nor 2D, but 1D
. The display, indeed the entire gaming surface, is a single strip of addressable LEDs which can be seen int he video below the break.
Behind it all is an ESP32, and a unique one-dimensional joystick using an accelerometer. There’s an audio channel with a little piezoelectric speaker too, and the LED strip is a particularly high-density one from DFRobot. Because this is an ESP32-driven device it has WiFi, upon which is exposed an access point for a network over which is served the game stats as a web page. It may not displace that modern console, but it’s certainly inventive.
Long-time Hackaday readers will be aware that this is only the latest of
a long line of one-dimensional games
, including
a 1D take on the famous PONG
. | 1 | 1 | [
{
"comment_id": "6468866",
"author": "The Commenter Formerly Known As Ren",
"timestamp": "2022-05-05T20:52:15",
"content": "[Title Photo]So, the LED strip indicates which bin the desired parts are in?B^)",
"parent_id": null,
"depth": 1,
"replies": []
}
] | 1,760,372,704.408835 | ||
https://hackaday.com/2022/05/04/bringing-zelda-classic-to-the-browser/ | BringingZelda ClassicTo The Browser | Matthew Carlson | [
"Games",
"Software Development"
] | [
"allegro",
"emscripten",
"Legend of Zelda",
"wasm",
"zelda"
] | Finding a device or app that isn’t a web browser doesn’t seem easy. These days, it is either connected to the web (looking at you ESP32) or is just a web browser pretending to be something else (a la electron, PWAs, or React Native). So, of course, it is on us to create more and more exciting things to browse. [Connor Clark] is one of those people, and he
brought
Zelda Classic
to the browser.
Zelda Classic
(ZC) isn’t an official
Zelda
game. Instead, it’s an old engine designed to run the world in the OG
Legend of Zelda
and be easily modified to support hundreds of different games. To date, there are over 600 games submitted by a large community. ZC is an
Allegro-based
Windows-only game, so the first step was to bust out Emscripten to start tweaking the C++ code to support a web environment. Rather than completely port the huge codebase over from Allegro, [Connor] made the jump from Allegro 4 to 5. Allegro 5 has SDL as a backend and adds support for Emscripten.
Unfortunately, the 4 to 5 wasn’t as simple as changing the dependency. The API was wholly re-written, and there is a handy adapter known as Allegro Legacy to help transition a project from one to another. After squashing a multitude of bugs, it was a relatively painless procedure. After a quick detour getting music and level data working, [Connor] faced his next challenge: multi-threading. Efforts to move the main loop off of the browser thread and into a web worker ran into issues with having to yield in loops, deadlocks, and recursive mutexes. Finally, he added music and gamepad support after fixing several bugs in SDL and Allegro.
It’s an incredible journey with many tips and tricks for debugging seemingly intractable bugs. The
code is up on GitHub
, or
jump in and start playing
if you’re interested. Why not check out this
browser-based OpenSCAD
as well? | 6 | 5 | [
{
"comment_id": "6468625",
"author": "SteveL",
"timestamp": "2022-05-05T07:42:37",
"content": "React Native apps aren’t web browsers, they’re native apps using native UI components which have layout and business logic written in JavaScript.",
"parent_id": null,
"depth": 1,
"replies": []
... | 1,760,372,704.493262 | ||
https://hackaday.com/2022/05/04/flip-book-animations-on-the-inside-of-3d-prints/ | Flip Book Animations On The Inside Of 3D Prints | Anne Ogborn | [
"3d Printer hacks",
"Video Hacks"
] | [
"3d print",
"animation",
"flip book"
] | We’ve all seen 3D printed zoetropes, and drawn flip book animations in the corner of notebooks. The shifting, fluid shape of the layers forming on a 3D printer is satisfying. And we all know the joy of hidden, nested objects.
Hackaday alumnus [Caleb Kraft] has a few art pieces that all reflect all these. He’s been making animations by recording a 3D printer. The interesting bit is that his print is made of two objects. An outer one with normal infill that gives a solid form, and a layer cake like inner one with solid infill.
It’s documented in this video on YouTube.
CAD model of the stack of frames
There are lots of things to get right. The outer object needs to print without supports. The thickness of the “layer cake” layers determines the frame rate. I had to wonder how he triggered the shutter when the head wasn’t in the way.
His first, experimental, piece is the classic ‘bouncing ball’ animation, inside a ball, and his mature piece is Eadward Muybridge’s “The Horse, In Motion” inside a movie camera.
We’ve covered [Caleb Kraft] before, of course. His
Moon On A Budget
piece is wonderful. And we’ve covered a number of
3D printer animations
. and
3D zoetropes.
We particularly were drawn to
this one
.
Thanks [jmc] for the tip! | 5 | 3 | [
{
"comment_id": "6468621",
"author": "IIVQ",
"timestamp": "2022-05-05T07:34:54",
"content": "If you need supports in your plug, you could first print the layer without the support, take one still photo, then print the supports in that same layer. This gets harder with multiple layers off course, req... | 1,760,372,704.370207 | ||
https://hackaday.com/2022/05/04/tpm-module-too-expensive-diy-your-own-easily/ | TPM Module Too Expensive? DIY Your Own Easily! | Arya Voronova | [
"computer hacks",
"Security Hacks"
] | [
"Gigabyte",
"SLB9665",
"TPM",
"Trusted Platform Module"
] | Since Windows 11 has announced its TPM module requirement, the prices for previously abundant and underappreciated TPM add-on boards for PC motherboards have skyrocketed. We’ve been getting chips and soldering them onto boards of our own design, instead – and
[viktor]’s project
is one more example of that. [Viktor] has checked online marketplace listings for a TPM module for his Gigabyte AORUS GAMING 3 motherboard, and found out they started at around 150EUR – which is almost as much as the motherboard itself costs. So, as any self-respecting hacker, he went the DIY way, and it went with hardly a hitch.
Following the schematic from the datasheet, he quickly made a simple KiCad layout, matching it to the pinout from his motherboard’s user manual, then ordered the boards from PCBWay and SLB9665 chips from eBay. After both arrived, [viktor] assembled the boards, and found one small mistake – he designed a module for 2.54mm pin headers, but his motherboard had 2.0mm headers. He wired up a small adapter to make his assembled V1.0 boards work, and Windows 11 installed without any TPM complaints. He shows that he’s designed a new, V1.1 version with an updated connector, too, and published its (untested but should work) design files for us
on GitHub
. These modules can vary, by manufacturer and motherboard series, but with each module published, a bunch of hackers can save money – and get a weekend project virtually guaranteed to work out.
Regardless of whether the goal of running Windows 11 is ultimately worthwhile, it has been achieved. With scalpers preying on people who
just want to use their hardware
with a new OS, rolling your own TPM PCB is a very attractive solution! Last time we covered
a DIY TPM module for ASrock server motherboards,
we had a vivid discussion in the comments, and if you’re looking to create your own TPM board, you could do worse than checking them out for advice and insights! | 83 | 21 | [
{
"comment_id": "6468511",
"author": "Mojoe",
"timestamp": "2022-05-04T23:17:03",
"content": "Since the article doesn’t mention it… TPM stands for Trusted Platform Module and according to wikipedia: “Trusted Platform Module (TPM, also known as ISO/IEC 11889) is an international standard for a secure... | 1,760,372,704.69034 | ||
https://hackaday.com/2022/05/04/the-mch2022-badge-has-landed/ | The MCH2022 Badge Has Landed! | Jenny List | [
"cons"
] | [
"badge.team",
"badgelife",
"MCH2017"
] | As spring slowly slides into summer here in Europe where this is being written, the warm weather is a reminder that on the horizon are the summer’s crop of hacker camps. The largest European one this year will be the Dutch MCH2022 near the end of July, and to whet our appetite
they’ve made public some details of their badge
. And true to the past form of Dutch camps, it’s rather an impressive build.
Since this is another piece of work from
badge.team
it has the expected ESP32 module, but alongside it on the elegantly-designed PCB there’s an RP2040 and a Lattice ICE40UP5K FPGA. The ESP is there to run the badge team firmware which even includes backwards compatibility with the original SHA2017 badge, the RP2040 ties everything together and provides a multitude of USB peripherals, and the FPGA is there to run user code. From the front, the badge has a Game Boy Advance-style form factor with a large colour TFT screen and the usual joystick and buttons. Other peripherals include a brace of addressable LEDs, a pair of nifty sensors from Bosch, and a 16-bit stereo audio channel that even powers a small onboard mono speaker when no headphones are connected.
The hardware may be slick, but it’s
the badge.team firmware
that makes this as special as all their previous offerings. It offers the chance to easily write apps either in MicroPython for the ESP32, or as payloads for the FPGA, and what makes it special is that it comes with an online app store from which all the apps can be downloaded. We’re told that it will be able to run a range of emulators out of the box, so we’re really looking forward to seeing the final version at the event. Meanwhile they’ve released a demo video that you can see below the break, and if you’re curious you can
take a look at its SHA2017 badge ancestor
. | 2 | 2 | [
{
"comment_id": "6468613",
"author": "not",
"timestamp": "2022-05-05T06:34:28",
"content": "They forgot the unicorn on the silk screen…",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6468707",
"author": "zoobab",
"timestamp": "2022-05-05T13:24:42",
... | 1,760,372,704.449087 | ||
https://hackaday.com/2022/05/04/2022-hackaday-prize-armalamp-provides-light-no-matter-what/ | 2022 Hackaday Prize: ArmaLamp Provides Light, No Matter What | Tom Nardi | [
"LED Hacks",
"The Hackaday Prize"
] | [
"2022 Hackaday Prize",
"emergency light",
"solar power"
] | Instant access to electric light is a luxury that most of us take for granted, but in times of crisis, the power is often the first thing to go. So whether you’re worried about a natural disaster or the outbreak of war, a reliable source of light is a must-have in your emergency kit. Creator
[bobricius] calls his is ArmaLamp the “Armageddon resistant night lamp”
, and while we’re not eager to test that particular claim, it certainly looks robust enough to get you through some tough times.
The basic idea behind the ArmaLamp is to make a light source so simple that, outside of being physically destroyed, it can’t fail. That means deleting the mechanical power switch and designing the circuit so the LED light will kick on automatically in the dark. Rather than using a traditional rechargeable battery, the solar powered ArmaLamp stores its charge in a 10 farad supercapacitor that can be
charged and depleted daily without having to worry about long-term degradation
.
Charging the ArmaLamp with a simple solar cell is clearly out of the question as it would represent not just a single point of failure, but a particularly fragile one at that. Instead, [bobricius] is using an array of six BPW34 photodiodes that come in a hard plastic package. Combined with an efficient driver circuit that can run the LED even when the supercap is down to 0.3 V, leaving the ArmaLamp outside during the day should provide you with four hours of ultra-reliable light every night.
The
Hackaday
Prize2022
is Sponsored by: | 35 | 13 | [
{
"comment_id": "6468413",
"author": "Ticktok (@darkharlequin)",
"timestamp": "2022-05-04T18:47:12",
"content": "i do kind of wish there was an off switch or something though, as this is only useful if you charge it during the day, and then use it immediately at night. If you put it in your pocket o... | 1,760,372,705.003416 | ||
https://hackaday.com/2022/05/04/healing-wounds-with-the-power-of-electricity/ | Healing Wounds With The Power Of Electricity | Lewin Day | [
"Hackaday Columns",
"Science",
"Slider"
] | [
"adhesive bandage",
"band-aid",
"medical",
"medicine",
"science",
"wound",
"wound dressing",
"wound healing",
"wound management"
] | Once upon a time, even a simple cut or scrape could be a death sentence. Before germ theory and today’s scientific understanding of medicine, infections ran rampant and took many lives.
While we’re now well-armed with disinfectants, dressings, and antibiotics, scientists are continuing to investigate new and unique methods to improve the treatment of wounds. As it turns out,
a little electricity might actually help wounds heal faster.
Zap!
The bandages come in two designs for treating circular or linear wounds. Credit:
Research paper
Past research has found that the application of electric current may actually assist in the wound healing process. In a paper published
in 2003
, researchers found that wound healing was sped up by anywhere from 13-50% by the application of an electrical field to the area. A variety of trials have found success in this area, using a variety of different methods of electrical stimulation, along with different polarities and field strengths in the vicinity of the wound.
The causative factor seems to center around the response of human keratinocytes to electrical stimulation. These skin cells may have their migration guided or directed by the electric field, in concert with the presence of certain growth factors in the area.
Thus far, most studies have required the use of expensive research equipment to apply the electric field to wound areas.
Recent research
from the University of Electronic Science and Technology of China has aimed to take the principle and use it in a more practical fashion.
The research has involved the creation of electrically-active wound dressings that could be applied with similar ease to typical adhesive bandages.
Speaking to
New Scientist
,
lead researcher Guang Yao notes that “Non-invasive, efficient, cost-effective and convenient approaches are always desired for treating skin wounds.”
The new dressings apply an electrostatic field to the wound site, with the negative electrode directly over the wound, and a positive electrode surrounding the area. The shape memory alloy layer also helps squeeze the wound closed. Credit:
Research paper
As designed by the research team, the dressing consists of four layers. The first layer consists of an electrically-charged polytetrafluoroethylene plastic, which can generate an electrostatic field when placed into contact with the skin. The second layer is a flexible silicone rubber, while the third layer features a shape memory alloy. This layer helps push the wound closed to further aid the healing process, and is triggered into action by skin temperature. A final layer of flexible gel sits on top.
Notably, the electromechanical synergistic dressings, as they are known, were made in two versions. An EMSD-L, for linear wounds, features a rectangular negative electrode and a rectangular ring positive electrode around the outside. Meanwhile, the EMSD-C, for circular wounds, features a circular negative electrode and corresponding circular ring positive electrode on the outside.
The dressings were applied to 50 rats in testing. Each was given either a linear wound of 10 mm long, or a circular wound of 8 mm diameter. For control purposes, some rats were given the new dressings, while others were given conventional dressings or no dressing whatsoever. The electric dressings performed the best, with circular wounds 96.8% closed after eight days. This compares to around 75% closed for the standard dressings, and just 45.9% for those rats with undressed wounds. Results from the straight wound group were similarly in favor of the new dressing design.
Yao notes that the team hopes to produce to suit a wide variety of wound types. “We are optimising the design of devices for more shaped wounds, including irregular shapes,” he says. Human trials are also on the cards down the line.
Early results are positive and it seems there really is something to it when it comes to giving wounds a little bit of a charge to help them heal faster. While you could use them on a simple papercut, their true value may be in more serious medical settings. Wound management is its own whole branch of medicine, and it can be complicated by any number of things, from bacteria to unique genetic condtions. Helping wounds close with a little bit of static electricity could make a serious difference for huge numbers of patients around the world. | 36 | 13 | [
{
"comment_id": "6468369",
"author": "billtheplatypus",
"timestamp": "2022-05-04T17:27:49",
"content": "This sounds interesting and promising. However, it would have been nice to see a trial group consisting of the same electrical bandage, but electrically neutral. It’s possible that the physical de... | 1,760,372,704.926056 | ||
https://hackaday.com/2022/05/04/a-nearly-all-new-commodore-64/ | A (Nearly All) New Commodore 64 | Jenny List | [
"Retrocomputing"
] | [
"c64",
"commodore",
"commodore 64"
] | The Commodore 64 remains one of the most influential of the 8-bit home computers four decades after its launch, so not surprisingly there is a huge enthusiast community surrounding it. With so many produced over the years it was available one might think that there would be no shortage of surviving specimens, but sadly time and component failure have taken their toll and the classic micro is not always the most reliable kid on the block. Thus a cottage industry has sprung up supplying C64 parts, leading [The Retro Shack] to have a go at
making a new one entirely from scratch
.
As you can see in the video below the break it’s not quite an
entirely
new ’64, as parts including some of the custom silicon come from failed boards. The PCB is a modern recreation of the original and the SID sound chip is an ARMsid though, and most of the parts come from a handy bagged-up kit that makes assembling the BoM much easier. Instead of the big silver box of the original RF modulator is a modern composite board, and there are a few issues with minor connector part differences.
Assembly is simply a very long through-hole soldering process, and once he’d completed it there was the expected refusal to work. We’ve all been there, and eventually he traced it to an incorrectly fitted chip. If you think you’ve seen a few brand new C64s here before you’d be correct,
one of them even used LEGO for those elusive keycaps
. | 10 | 4 | [
{
"comment_id": "6468322",
"author": "paulvdh",
"timestamp": "2022-05-04T15:37:53",
"content": "Brings back memories of the joystick with built in c64.It was probably cheaper then the bare PCB for this project.I think Jerri Ellsworth designed it for some Chinese company and it’s not much more then a... | 1,760,372,704.835282 | ||
https://hackaday.com/2022/05/04/the-connector-zoo-i2c-ecosystems/ | The Connector Zoo: I2C Ecosystems | Arya Voronova | [
"Featured",
"how-to",
"Interest",
"Microcontrollers",
"Slider"
] | [
"ecosystems",
"grove",
"i2c",
"i2c bus",
"JST",
"qwiic",
"stemma",
"stemma qt"
] | I2C is a wonderful interface. With four wires and only two GPIOs, you can connect a whole lot of sensors and devices – in parallel, at that! You will see I2C used basically everywhere, in every phone, laptop, desktop, and any device with more than a few ICs inside of it – and most microcontrollers have I2C support baked into their hardware. As a result, there’s a myriad of interesting and useful devices you can use I2C with. Occasionally, maker-facing companies create plug-and-play interfaces for the I2C device breakouts they produce, with standardized pinouts and connectors.
Following a standard pinout is way better than inventing your own, and your experience with inconsistent pin header pinouts on generic I2C modules from China will surely reflect that. Wouldn’t it be wonderful if you could just plug a single I2C-carrying connector into an MPU9050, MLX90614 or HMC5883L breakout you bought for a few dollars, as opposed to the usual hurdle of looking at the module’s silkscreen, soldering pin headers onto it and carefully arranging female headers onto the correct pins?
As with any standard, when it comes to I2C-on-a-connector conventions, you would correctly guess that there’s more than one, and they all have their pros and cons. There aren’t quite
fifteen
, but there’s definitely six-and-a-half! They’re mostly inter-compatible, and making use of them means that you can access some pretty powerful peripherals easily. Let’s start with the two ecosystems that only have minor differences, and that you’ll encounter the most!
The JST-SH buddies
KiCad symbol: Conn_01x04_MountingPin; footprint: JST_SH_SM04B-SRSS-TB_1x04-1MP_P1.00mm_Horizontal
There’s two ecosystems of I2C modules that are based on four-pin JST-SH (1mm pitch) connectors, and they’re very interchangeable! One of them is Sparkfun’s QWIIC, and other is Adafruit’s STEMMA QT (pronounced ‘cutie’). Both of them are straightforward to add to your PCB, as long as you have a few JST-SH four-pin connectors ready. What’s more – Adafruit and Sparkfun connectors have the same pinout!
The connectors being used are JST-SH, surface-mount, with 1 mm pitch. Their JST family is SR/SH and the part number for the original JST part is
SM04B-SRSS-TB
, but you can find cheap third-party connectors with the same dimensions on LCSC using “1x4P SH 1mm” search terms. Both
QWIIC
and
STEMMA
have pages to refer to when doing your own designs. Now, what are the differences between the two?
QWIIC limits itself to 3.3 V on both host (i.e. MCU board, providing power) and device (i.e. sensor, consuming power) side – a reasonable decision, simplifying things a lot. An overwhelming majority of devices we work with nowadays are 3.3 V, to the point where level-shifting problems are mostly unheard of. Perhaps, the eventual move to 1.8 V will shake that up, but we are not there yet, and factors like LED forward voltages will necessitate some kind of higher-than-1.8 V reference in our project when we get there, anyway. So, 3.3 V power and two 3.3 V logic level I2C signals on a single connector – plain and simple. Chances are, you can already add QWIIC to your sensor or MCU board – without any additional components required but the connector itself!
STEMMA QT sensor; photo by Adafruit
In contrast,
STEMMA QT
is built to expand on the possible educational and convenience value, in line with other Adafruit offerings. As such, it allows for 5 V hosts – with devices
designed to work in the 3.3 V-5 V power and logic level range,
making sure that your Arduino Uno is not left out of the game. This is possible because every module has a low-dropout voltage regulator like the AP2112K or the MIC5219, which helps keep things almost-3.3 V when you feed the board with 3.3 V. The reasoning is simple – apart from 5 V hosts like Arduino Uno, you might also want to chain your STEMMA devices with some power hungry-devices, like I2C-savvy servos or RGB strips. In short, plugging anything into anything, with any kind of chain, shouldn’t result in magic smoke escaping – an event rarely on the TODO list of a maker’s project. One more upside of STEMMA QT is standardization of device board sizes, letting you easily mechanically integrate new sensors into the project before they even arrive to you, and spawning nifty hacks like
this STEMMA Qt 3D-printable hotswap socket!
To sum up the voltage compatibility situation – all STEMMA QT devices will work with QWIIC hosts; and all QWIIC devices will work with 3.3 V STEMMA Qt hosts; as a result, any QWIIC host is also technically a STEMMA QT host. QWIIC devices will be fiercely incompatible with 5 V STEMMA QT hosts, but such hosts are rare, and you just have to be on the lookout when interfacing QWIIC devices with STEMMA hosts. Another minor hiccup with both of these standards is lack of interrupt signals – that, I will expand on below, in the “Breakout Garden” section. For now, let’s take a look at STEMMA QT’s bigger sister!
Chaining QWIIC And STEMMA modules
Three I2C QT Rotary Encoders chained; photo by Adafruit
Oh, right, chaining! Both QWIIC and STEMMA QT are chaining-friendly – many modules offering a second JST-SH connector on the opposite side of the board, with the same signals passed through. This lets you wire up your projects in a comfortable way, not having to locate a spot in your project where you can put your MCU while not having it too far from all of your sensors, or not resorting to breadboards for splitting your I2C bus into multiple stubs. Many host boards also offer multiple sockets wired in parallel, and there’s “splitter” boards available that turn a single JST-SH cable with I2C into, say, three extra sockets.
As long as your addresses don’t conflict, you will generally be fine wiring an I2C bus for a project in such a way. Oh, and make sure to
not overload your I2C bus
with all the pullups added in parallel – they tend to be 10 kΩ for STEMMA QT and 2.2 kΩ for QWIIC, and at least in case of QWIIC, it seems you’re typically able to cut two trace jumpers with an xacto knife to disconnect the pullups on any module. With all non-Pico-based Raspberry Pi boards having 1.8 kΩ onboard pullups on their I2C ports, you might find yourself needing to do that quite early on as you chain devices.
The Bigger, Blacker Connector
KiCad symbol: Conn_01x04_MountingPin; footprint: JST_PH_S4B-PH-SM4-TB_1x04-1MP_P2.00mm_Horizontal
STEMMA
has the same pinout as STEMMA QT and QWIIC, but a different, larger connector. It, too, is flexible when it comes to voltages you can output on the host end, and in turn, must be able to accept on the device end. Most of the advantages in STEMMA QT section apply to STEMMA, save for QWIIC compatibility and reduced physical size.
STEMMA connectors are JST PH connectors with 2 mm pitch, with JST part number being
S4B-PH-SM4-TB
, and cheap third-party connectors available with “1x4P PH 2mm” search terms. They’re a bit easier to tackle with a soldering iron than the 1 mm pitch SH connectors, and for
larger boards
, they’re a good fit.
JST-PH is one of those cases where surface-mount sockets turn out to be way more resilient than the through-hole ones. With a tougher retention mechanism, your fingernails will no longer suffice – you’ll likely want to use your trusty pair of blue flush cutters for unplugging these! I2C-carrying STEMMA also has an GPIO and analog STEMMA counterpart, using 3-pin JST PH connectors for things like WS2812 strips – where 5 V compatibility becomes exceptionally handy. However, 4-pin connectors are firmly reserved for I2C, and such consistency is hard to not appreciate in educational and prototyping environments – checking the
dozens of tutorials
Adafruit has involving STEMMA devices, the “Wiring” sections in those are extra straightforward! On some STEMMA hosts, you will also be able to
rewire the port
to either 3.3 V or 5 V through a solder jumper.
Just Can’t Get Into The Grove
The
Grove connector standard
, oldest of them all, is now somewhat of a black sheep among the I2C connector ecosystems, and is here half as a piece of history, half as a cautionary tale. Contrary to principles of open-source ecosystems, Grove uses a proprietary connector, which
has makers scramble for its proper identification
as they try to find a source that is not SeeedStudio. Unlike all the other standards listed here, when you see a 4-pin Grove connector, you don’t know if it’s for I2C, UART, two digital GPIOs or something analog, which ruins the whole “plug and play” idea.
To those of you unfortunate to have to
interface with Grove
, it also uses 3.3 V – 5 V range of possible voltages, but is less interested in explicitly advertising which one is used, or letting you change that – both things that STEMMA does without breaking a sweat. It uses the same pinout for I2C as QWIIC/STEMMA do. If you have a STEMMA-compatible (JST-PH) cable, you can sand it down a bit to make it fit into a Grove connector.
In other words, there’s a good reason you don’t see Grove connectors used more often. I couldn’t help but notice that Tom’s Hardware, when writing the conclusion section of their own
I2C connector ecosystem overview article
, failed to find an advantage of Grove that wasn’t generic to every other ecosystem they talked about. Unless you want to resign to paying SeeedStudio for every connector and cable you ever need, and are okay never being compatible with connector ecosystems worth investing effort into, I strongly recommend you avoid using Grove on your boards. Let’s spend time on the next – underappreciated – option instead.
A Stroll In The Breakout Garden
KiCad symbol: Conn_01x05; footprint: PinHeader_1x05_P2.54mm_Vertical
The Breakout Garden ecosystem
by Pimoroni uses an elegant pinout – taking a row of five pins off the
Raspberry Pi GPIO header
, pins 1 to 9, including 3.3 V, SDA, SCL, a GPIO pin and, of course, GND – in this order. They sure don’t hold a patent to this pinout – a whole lot of hackers, myself included, have been using this pinout for ages on our I2C-equipped boards. Such a pinout, for a start, means that you can plug any Breakout Garden board onto a Raspberry Pi directly.
You’re not limited to that, either – Pimoroni also offers nice slide-in connectors that let you hotswap Breakout Garden modules. And, if you don’t want to use the slide-in sockets, just solder angled male pin headers and treat them like any other module. Breakout Garden modules typically have a 3.3 V – 5 V input voltage range. They also claim reverse polarity protection on every module, so, inevitably plugging a module backwards shouldn’t delay your project.
With the Breakout Garden pinout, you also get an extra GPIO, which is most commonly either NC or used as an interrupt pin. Interrupt pins are under-appreciated when working with I2C devices – they let you offload your CPU and your I2C bus, avoiding polling and letting your I2C peripheral signal you when it wants your attention, something not possible through the I2C bus alone. For a few modules, like
this haptic actuator driver
, the GPIO is used as a “trigger” pin instead, for action synchronisation. That does hurt the concept of chaining somewhat, of course – to be fair, though, so does the bulky hotswap socket. Not that you can’t connect Breakout Garden boards in parallel – after all, INT pin is typically disable-able for I2C devices, which will absolutely come handy, given the the puzzling decision of wiring all the INT pins together on
their 6-socket Raspberry Pi HAT
.
Adding basic support for “Breakout Garden”-like connection in your project is as simple as adding a five-pin 2.54mm (0.1″) pin header – and with that, you instantly get Raspberry Pi GPIO header compatibility. When it comes to creating your own modules, I couldn’t find any dimensions or an official “how to create” modules, so you’re probably not meant to do that – which doesn’t mean that you can’t reverse-engineer the schematics and the dimensions and then try anyway, but it sure is quite discouraging. If you want to add
a Breakout Garden socket
, they have two rows of pins that are exactly 5.08mm (0.2″) apart, and provide convenient plug & play connectivity, though with the cost of £1 per socket (not including shipping), the slide-in sockets are the most expensive to use of these all.
Conveniently Crimped Cables
In the market for some JST-SH accessories? You really can’t go wrong with the SMD connectors; however, you absolutely can go wrong when it comes to pre-crimped cables. Crimping JST-SH with its 1 mm pitch is far from easy, and buying your own cables is your best bet – except for when they come miswired. A year ago, I was preparing for a project and bought a bundle of JST-SH cables, pictured to the right. Upon closer inspection, something felt off.
Turned out that they had their cable ends wired in the opposite direction, one’s pinout reverse to that of the other – with likely disastrous consequences when used as an interconnect. The cables I bought will require some careful rewiring with tweezers, and next time you are shopping for third-party JST-SH cables so that you can wire up your next project, you will know to inspect the pictures before pressing the “Buy Now” button.
Mentions Of Variable Honorableness
If you’ve ever worked with DFRobot parts, you might’ve seen JST-PH 4-pin (or 3-pin) connectors on their boards, too – they’re from their
ecosystem called Gravity
. Puzzlingly enough,
Adafruit claims
that STEMMA is compatible with Gravity, apart from their non-I2C devices – since Gravity does the same thing that Grove does, where a 4-pin connector doesn’t guarantee I2C. However,
checking the pinout
for Gravity I2C devices, it seems that every single pin is in a different spot, in particular, ground and power being reversed. Just like STEMMA, they use
3-pin connectors
for digital and analog devices. The fun part is, they also managed to
change the pinout for those
at some point,
also reversing the power pin polarity –
while still using the same connector, a no-no for connector standards. Proceed with caution!
EasyC
is basically QWIIC copied to a T, with the same pinout, connectors, chaining abilities and 3.3 V voltage limit – but not mentioning QWIIC in any way in their webpages and resources, which is a disappointment. Interoperability of different ecosystems is part of what makes them valuable, and arguably, you could be more inclined to buy from them if you knew that the standard they’re using is a widely accepted one – as opposed to “random pinout on some connector”. EasyC is driven by a Croatia-based e-radionica company, producing a medium-sized assortment of useful modules, including quite a few Chinese module clones and remixes – at European prices. Design files for their modules are not linked to from product files, but at least some of them seem to be
on their GitHub!
Interestingly enough, they also stock
a 5cm “EasyC” cable
which, upon closer inspection, has the same reversed wiring as the cables I told about in the previous section. Perhaps, putting a bit more thought into the EasyC ecosystem would be warranted.
Sometimes we see companies making an attempt at a JST-SH thing, but not quite getting there. An example of that is a somewhat recent board by Lolin, the Lolin D1 Mini Pro, with
a JST-SH 4-pin connector
on it labelled “I2C”. You could be forgiven for
thinking that this is a QWIIC-like pinout;
given that this connector is marked “I2C”, one could argue they’ve been tricked, backstabbed and quite possibly, bamboozled. Instead of GND-VCC-SDA-SCL pinout, this board is using GND-SDA-SCL-VCC, and it appears there’s even a few accessories like shields made with this pinout in mind. It’s as if someone sent Lolin a letter saying “hey, you should put I2C on a JST-SH connector” and then refused to elaborate further. Thankfully, with the GND pins matching, the likelihood of destroying things is not as extreme.
Building Your Own Things? Need Guidance?
Which one of the standards should you follow when designing your own boards? I have provided you with all the information you could ever need to make your own decisions, but if you’re looking for a recommendation or a guideline, I will happily provide one, too.
I personally don’t use full-sized STEMMA (JST-PH) connectors, as way too often, they’re bulky enough to make the PCB itself seem small, and can make small boards a bit unwieldy due to their height – plus, they can be harder to unplug. The JST-SH connectors, however, are way too enticing due to the prospect of being compatible with two ecosystems at once, as long as I avoid 5V hosts. And – a simple, standard pinout 5-pin header provides a surprising amount of benefits for how quickly you can add it!
In short, I recommend that you combine a Breakout Garden-like pin header and the QWIIC/STEMMA QT JST-SH connector on your boards. This way, you will always have compatibility with three out of the four ecosystems worth talking about, and connecting your I2C board to a Raspberry Pi will be as straightforward as getting five jumper cables. With this combination, you will never have to think about I2C header pinouts ever again, and you’ll have an interrupt signal handy for the times when you really could use one.
Do you have to add level shifting? Not if you don’t use 5 V in your projects, and especially not if you’re making a breakout for an IC that has a wide range of input voltages, like, say, I2C EEPROMs and RTCs. I personally work with mainly 3.3 V, and I don’t have reels of AP2112 regulators to sprinkle on every board I make – thankfully, I don’t have 5V I2C hosts, either. In case you do want to make your devices 5 V-compatible, you can’t go wrong with the classic, incredibly elegant, and inexpensive
MOSFET solution for I2C level shifting!
Conclusion
Out of these, QWIIC, STEMMA and Breakout Garden have so far stood the test of time, with hobbyist electronics companies backing them all the way there. It is only fair that we benefit from the standards they created. Hopefully, the insights and the instructions provided get us closer to universal interoperability days, when one hacker’s MCU board can seamlessly interface with other hacker’s sensors. From there, one day, our favourite SSD1306 OLED breakouts might start arriving into our mailboxes equipped with a JST-SH connector and an extra cable. Today is not that day, but with every JST-SH footprint we add to our PCB, I believe we will see to it soon. | 56 | 24 | [
{
"comment_id": "6468285",
"author": "paulvdh",
"timestamp": "2022-05-04T14:24:51",
"content": "Olimex has their UEXT connector standard.10 pin IDC with 3V3 power, I2C, UART and SPI.https://en.wikipedia.org/wiki/UEXT",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment... | 1,760,372,705.23143 | ||
https://hackaday.com/2022/05/04/dumping-encrypted-at-rest-firmware-of-xiaomi-smart-kettle/ | Dumping Encrypted-At-Rest Firmware Of Xiaomi Smart Kettle | Arya Voronova | [
"Microcontrollers",
"Reverse Engineering",
"Security Hacks"
] | [
"attack",
"Firmware modding",
"lock bits",
"memory read-out protection",
"microcontroller",
"patching",
"read protection",
"reverse engineering",
"ReverseEngineering",
"security",
"SWD"
] | [aleaksah] got himself a Mi Smart Kettle Pro, a kettle with Bluetooth connectivity, and a smartphone app to go with it. Despite all the smarts, it couldn’t be turned on remotely. Energized with his vision of an ideal smart home where he can turn the kettle on in the morning right as he wakes up, he
set out to right this injustice.
(Russian,
translated
) First, he tore the kettle down, intending to dump the firmware, modify it, and flash it back. Sounds simple enough — where’s the catch?
This kettle is built around the QN9022 controller, from the fairly open
QN902X family of chips.
QN9022 requires an external SPI flash chip for code, as opposed to its siblings QN9020 and QN9021 which have internal flash akin to ESP8285. You’d think dumping the firmware would just be a matter of reading that flash, but the firmware is encrypted at rest, with a key unique to each MCU and stored internally. As microcontroller reads the flash chip contents, they’re decrypted transparently before being executed. So, some other way had to be found, involving the MCU itself as the only entity with access to the decryption key.
[aleaksah] considered the SWD interface, a powerful debug interface and a fairly common go-to for internal data access of many MCUs. Sadly, this microcontroller has lock bits for blocking SWD, intended to be set as your product leaves the factory floor. Of course, not every manufacturer sets those bits, but after checking the SWD interface anyway, it wouldn’t respond, and he decided to go the other way. He rejoiced, finding documentation on the MCU’s internal bootloader, and decided to load his own code into RAM that would dump the flash contents from the inside. However, the read command seems to have triggered the bootloader to either scramble or erase the flash, leaving him with a dead unit.
He persevered, and decided to study the bootloader code itself, loading yet another RAM stub that would dump the bootloader code. After decompiling the bootloader, apart from a few undocumented but uninteresting commands, he found out that loading any kind of program, indeed, sends the flash chip a command to perform a flash erase. From here, he could theoretically do a tweezer hack, write-protecting the flash by short-circuiting its data pins – yet, he decided to find a proper dumping method that would extend to the chips with built-in flash, should one of those appear on our desks.
His key discovery came soon thereafter. Different SPI flash chip families have different commands for read/write/erase and other operations, and the bootloader exposes a structure you can modify to use different commands for the kind of flash chip you have connected. Simply substituting the flash erase command in that structure with something harmless resulted in the flash contents staying intact even after new code was loaded externally into RAM. As a result, [aleaksah] has discovered a method for dumping encrypted-at-rest firmware from any QN902X series MCU, using nothing but a USB-UART, the chip’s built-in bootloader and a small code dumping stub
(GitHub).
Another day, another firmware readout protection mechanism circumvented! Finding such exploits is beneficial for a lot of fun journeys, like
the recent hack
that helps us tap into myriads of STM32-powered devices out there. You can even use the abundant ST-Link programmers
as your training ground!
If the SWD interface isn’t unlocked on your device, check out this educational journey about
modding a third-party Xbox controller using SWD.
Wonder how to modify the firmware you dumped? We’ve just covered a hacker
modding their Kurzweil synthesizer’s firmware
with Ghidra! | 52 | 16 | [
{
"comment_id": "6468195",
"author": "Andrew",
"timestamp": "2022-05-04T11:24:12",
"content": "I was going to comment on the absurdity of a kettle with a microprocessor in it until I remembered that my lightbulbs all have a micro in them.At least it’s not a toaster.",
"parent_id": null,
"dep... | 1,760,372,705.328851 | ||
https://hackaday.com/2022/05/04/anxieties-of-hardware-bringup-during-parts-shortage/ | Anxieties Of Hardware Bringup During Parts Shortage | Arya Voronova | [
"hardware",
"Parts"
] | [
"BEC",
"chip shortage",
"parts shortage"
] | [Dirksavage88] tells us a story about
developing a simple BEC in times of chip shortage.
He needed a small 5V/3A regulator board for a servo rail on his drone, and decided to use one of the new integrated-inductor modules from Texas Instruments. Hardly requiring any external parts, such modules are exceptionally nice to use for all your power rail needs, albeit at a slightly increased cost – the downside is that, as the parts shortage hit, most of them have been out of stock. Originally priced at about $7 USD, the asking price for these specific modules, LMZM33603, has climbed as high as $800. Somehow, he obtained a few of these modules nevertheless, and went on designing a board.
It can be daunting to test your very first PCBs when the silicon you’re putting on it is effectively irreplaceable for your purposes. TI is known for their wacky footprints, and this module is no exception – the solder paste application took a bit of time, and seeing small solder balls around the module after reflow didn’t exactly reassure him. Thankfully, when he powered it all up, the module worked wonders, and took its rightfully earned spot in his drone’s servo turret. He says we can expect the next revision of his design in 2024, or whenever it is that the reported 100 week lead time is due. In case some of us could use them, Eagle files are
available on GitHub!
Quite a few of us are lucky enough to have enough crucial parts for what we need, but most of us got a good few projects shelved until better times – take
this WiFi-enabled wall charger project
, for instance. Even bigger projects are suffering, from
SmoothieBoard
to
Raspberry Pi.
Just a year ago, we
had our readers share their chip shortage stories. | 22 | 6 | [
{
"comment_id": "6468148",
"author": "ThisGuy",
"timestamp": "2022-05-04T08:08:02",
"content": "“or whenever it is that the reported 100 week lead time is due.”I suspect the majority of chips/modules like this will go straight from 100 weeks lead time to EOL with nothing in between.Nobody’s actually... | 1,760,372,705.389083 | ||
https://hackaday.com/2022/05/03/designing-for-the-small-grey-screen/ | Designing For The Small Grey Screen | Jenny List | [
"Video Hacks"
] | [
"crt",
"CRT display",
"tv"
] | With the huge popularity of retrocomputing and of cyberdecks, we have seen a variety of projects that use a modern computer such as a Raspberry Pi bathed in the glorious glow of a CRT being used as a monitor. The right aesthetic is easily achieved this way, but there’s more to using a CRT display than simply thinking about its resolution. Particularly a black-and-white CRT or a vintage TV has some limitations due to its operation, that call for attention to the design of what is displayed upon it. [Jordan “Ploogle” Carroll]
has taken a look at this subject, using a 1975 Zenith portable TV as an example
.
The first difference between a flat panel and a CRT is that except in a few cases it has a curved surface and corners, and the edges of the scanned area protrude outside the edges of the screen. Thus the usable display area is less than the total display area, meaning that the action has to be concentrated away from the edges. Then there is the effect of a monochrome display on colour choice, in other words the luminance contrast between adjacent colours must be considered alongside the colour contrast. And finally there’s the restricted bandwidth of a CRT display, particularly when it fed via an RF antenna socket, which affects how much detail it can reasonably convey. The examples used are games, and it’s noticeable how Nintendo’s design language works well with this display. We can’t imagine Nintendo games being tested on black-and-white TV sets in 2022, so perhaps this is indicative of attention paid to design for accessibility.
While they require a bit of respect due to the presence of dangerous voltages, there’s a lot of fun to be had bringing a CRT into 2022. Get one while you still can,
and maybe you could have a go at a retro cyberdeck
. | 23 | 4 | [
{
"comment_id": "6468105",
"author": "Joshua",
"timestamp": "2022-05-04T05:52:56",
"content": "CRT monitors are awesome, I think.Especially the monochrome versions which have no mask.Their picture is so natural and soft! 😍Their resolutions can be much higher than that of color models, too.Monochrom... | 1,760,372,705.615802 | ||
https://hackaday.com/2022/05/03/kaleidoscope-feelings-turned-into-led-tree/ | Kaleidoscope – Feelings Turned Into LED Tree | Arya Voronova | [
"Art",
"LED Hacks"
] | [
"2022 Sci-Fi Contest",
"Circuit Sculpture",
"led",
"led tree",
"rgb",
"tree"
] | In 2020, [Eddie] found himself with a few hundred RGB LEDs left after a pandemic-interrupted project, and a slew of emotions he wanted to express – so he turned to the language of hardware, and started sculpting his feelings
into an art project.
He set out to build an LED tree around a piece of wood he picked for its cool shape, and trying out a long-shelved idea of his, while at it – using different resistors to mix colors of the RGB LEDs. The end result, pictured above,
has earned “The Most Important Device” spot
in our recent Sci-Fi contest, fair and square.
Initially,
he wanted to use ATTiny microcontrollers
and PWM all the lights in parallel. Having built an intermediate prototype,
a small LED flower,
he scrapped the idea due to technical problems, and then simplified it by hard-wiring RGB LEDs with randomly selected colors instead. As for the glowing orbs themselves, he made these just by pouring hot glue into silicon orb molds, a simple technique any of us could repeat. After 90 hours of work between him and an assistant he hired,
the LEDs were wired up
, each with random resistors connected to green and blue LED colors, and some warm white LEDs added into the mix.
He wanted to mostly use blue and green colors, as symbols of a world revived and revitalized – something we can’t help but keep our fingers crossed for. Before putting it all together, they wouldn’t know which colors each of the LEDs would power up in – part of the charm for this art piece, and no doubt a pleasant surprise. In the end, it turned out to be a futuristic decoration that we’re glad a camera could capture properly! If you like what you see, the build logs linked above have a bit more insights into how it all came together.
LED-adorned plants are fun projects that bring joy for a long time after you’ve finished them. You can easily
make a LED tree
out of what you have on hand, and if you get real fancy, you can create
an intricate bonsai
, too. And, if you’re ever interested to experiment with castellations, you can design yourself
some PCB cube flowers!
This project was an entry into the 2022 Sci-Fi Contest.
Check out all of the winning entries here
. | 4 | 4 | [
{
"comment_id": "6468076",
"author": "Voja Antonic",
"timestamp": "2022-05-04T03:18:13",
"content": "Sometimes just an idea is enough to judge the quality of a project. This is one such project. For me it’s great, I don’t mind how it looks.",
"parent_id": null,
"depth": 1,
"replies": []
... | 1,760,372,705.431356 | ||
https://hackaday.com/2022/05/03/stop-motion-angels-in-the-light-field/ | Stop-Motion Angels In The Light Field | Matthew Carlson | [
"Arduino Hacks",
"digital cameras hacks"
] | [
"2022 Sci-Fi Contest",
"light field",
"stop motion"
] | Baseball jokes aside, holograms have been a dream for decades, and with devices finally around that support something like them, we have finally started to wonder how to make content for them. [Mike Rigsby] recently entered his
stop-motion holographic setup
into
our sci-fi contest
, and we love the idea.
Rather than a three-dimensional model or a 2d picture with pixels, the Looking Glass light field display supports a series of images as quantized points (hence light field). As you move around an object, images are interpolated between the frames you do know,
giving a pretty convincing effect
. In a traditional stop motion animation, you need to take anywhere between 12-24 frames to equal about one second of animation. Now that you need to take 48 pictures for one frame, over 1152 pictures for just one second of animation. Two problems quickly appear, how to take photographs accurately from the same position every time and how do you manage the deluge of photos sensibly. [Mike] started with a wooden stage for his actors. A magnet was mounted to the photo rail carriage, and a sensor allowed it to detect that it was in the same spot. An Arduino controls the rail, reads the magnet via a sensor, and controls the camera shutter. The DSLR he’s using can’t do that many frames per second, but that’s a problem for another sci-fi contest.
Holographic-ish displays are finally here, and they’re getting better. But if a display isn’t your speed, perhaps some
laser-powered glasses
can be the holographic experience you’re looking for?
This project was an entry into the 2022 Sci-Fi Contest.
Check out all of the winning entries here
. | 0 | 0 | [] | 1,760,372,705.470633 | ||
https://hackaday.com/2022/05/03/identify-radioactive-samples-with-this-diy-gamma-ray-spectrometer/ | Identify Radioactive Samples With This DIY Gamma-Ray Spectrometer | Robin Kearey | [
"News",
"Science",
"Tool Hacks"
] | [
"gamma ray spectroscopy",
"Raspberry Pi Pico",
"scintillation"
] | If you’re a radiation enthusiast, chances are you’ve got a Geiger counter lying around somewhere. While Geiger counters are useful to detect the amount of radiation present, and with a few tricks can also distinguish between the three types of radiation (alpha, beta and gamma), they are of limited use in identifying radioactive materials. For that you need a different instrument called a gamma-ray spectrometer.
Spectrometers are usually expensive and complex instruments aimed at radiation professionals. But it doesn’t have to be that way: physics enthusiast [NuclearPhoenix] has designed
a hand-held gamma spectrometer that’s easy to assemble and should fit in a hobbyist budget
. It outputs spectral plots that you can compare with reference data to identify specific elements.
The scintillator and sensor are wrapped in black tape to block out ambient light.
The heart of the device is a scintillation crystal such as thallium-doped sodium iodide which converts incoming gamma rays into visible light. The resulting flashes are detected by a silicon photomultiplier whose output is amplified and processed before being digitized by a Raspberry Pi Pico’s ADC. The Pico calculates the pulses’ spectrum and generates a plot that can be stored on its on-board flash or downloaded to a computer.
[NuclearPhoenix] wrote a convenient program to help analyze the output data and made all design files open-source. The hardest part to find will be the scintillation crystal, but they do pop up on auction sites like eBay now and then. We’ve featured
an Arduino-based gamma spectrometer before
; if you’ve always wanted to
roll your own scintillators, you can do that too
. | 37 | 9 | [
{
"comment_id": "6467980",
"author": "Saint Aardvark the Carpeted.com",
"timestamp": "2022-05-03T20:07:01",
"content": "Very cool! A quick search on eBay shows the scintillators going for anywhere from $200 to $1400 USD (https://www.ebay.com/sch/i.html?_from=R40&_trksid=m570.l1313&_nkw=NaI%28Tl%29+... | 1,760,372,705.554844 | ||
https://hackaday.com/2022/05/03/fireball-flinging-figurine-feeds-fiction/ | Fireball-Flinging Figurine Feeds Fiction | Kristina Panos | [
"Arduino Hacks",
"contests"
] | [
"2022 Sci-Fi Contest",
"9V battery",
"arduino nano",
"maquette",
"neopixel ring",
"RGB LED",
"RGB LED ring"
] | If you’re writing a screenplay or novel, there will likely be points along the way at which you can’t get enough encouragement from friends and family. While kind words are kind, acts such as [scubabear]’s can provide a push like no other. By commissioning another 3D designer friend to
model a character from the first friend’s screenplay so he could print and animate it
, [scubabear] fed two birds with one scone, you might say.
Designer friend [Sean] modeled the mighty Braomar in Maya and Z-brush, and [scubabear] did test prints on a Formlabs Form2 as they went along to keep an eye on things. Eventually, they had a discussion about making space for wires and such, so [Sean] took to Blender to make Braomar hollow enough for wires, but not so empty that he would collapse under the stress of being (we presume) the main character.
Braomar stands upon a sigil that changes color thanks to an RGB LED ring in the base that’s driven by an Arduino Nano. A single pixel in the fireball is wired through Braomar’s body and flickers with the help of an addressable LED sequencer board.
Our favorite part of this build has to be the power scheme. Not content to have a wire running out from the base or even a remote control for power-draining concerns, [scubabear] used disc magnets in the base to switch on the 9 V battery when Screenplay Friend rotates it.
Of course, if you need inspiration to even thing about beginning to write a screenplay or novel, maybe you should
lead with the maquette-building
and then construct a story around your creation.
This project was an entry into the 2022 Sci-Fi Contest.
Check out all of the winning entries here
. | 7 | 7 | [
{
"comment_id": "6467958",
"author": "Jon Mayo",
"timestamp": "2022-05-03T18:44:38",
"content": "Don’t hate the player, hate the game.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6467969",
"author": "come2",
"timestamp": "2022-05-03T19:31:01",
"... | 1,760,372,705.666574 | ||
https://hackaday.com/2022/05/03/linux-fu-the-infinite-serial-port/ | Linux Fu: The Infinite Serial Port | Al Williams | [
"ARM",
"Linux Hacks",
"Slider"
] | [
"linux",
"mbed",
"serial",
"stm32"
] | Ok, the title is a bit misleading. Like most things in life, it really isn’t infinite. But I’m going to show you how you can use a very interesting Linux feature to turn one serial port from a microcontroller into a bunch of virtual ports. In theory, you could create over 200 ports, but the reality is you will probably want to stick with fewer.
The feature in question is what’s known as pseudoterminal or sometimes a
pty
or
pts
. These special files were made to feed data to programs that expect to accept data from a terminal. The files provide two faces. To the client, it looks like any other terminal device. To the creator, though, it is just another file. What you write to that file goes to the fake terminal and you can read anything that is sent from the program connected to the terminal. You use these all the time, probably, without realizing it since running a shell under X Windows, for example, doesn’t attach to a real terminal, after all.
You could, of course, do the same trick with a composite USB device, assuming you have one. Also assuming you can find a working driver and get it working. However, many microcontrollers have a serial port — even one with a USB converter built-in — but fewer have full-blown USB hardware. Even the ones that do are often at odds with strange drivers on the PC side. Serial ports work and work well even on the simplest microcontrollers.
The Plan
The plan is simple enough. A Linux program listens to a real serial port and watches for special character sequences in the data stream. Those sequences will allow you to switch data so that the data stream will go to a particular terminal. Data coming back from the terminals will go to the real serial port after sending a sequence that identifies its source.
I built a contrived example because there were certain key features I wanted to test. On the microcontroller, one thread reads an analog quantity and another a digital quantity. The system prints both of these out to separate virtual serial ports. If you press a key in either terminal, the associated data will pause. There’s also a debugging terminal and a command terminal that takes user input to alter things like how often to sample data.
The code, by the way, is on
GitHub
. If you aren’t using an STM32F411 Blackpill with Mbed, you’ll probably have some work to do. However, keep in mind that the complexity in the code is to fit in with the Mbed libraries. The actual protocol is simple and you can implement it anywhere.
The Protocol
Speaking of the protocol, it is both lightweight and robust. Each device is both a transmitter and a receiver and there is very little connection between them. So while one device is sending to a virtual channel, it might be receiving data from a completely different virtual channel. Each virtual channel has an identification number that can range from 0 to 253.
The transmitter sends most data bytes directly over the port. When there is a desire to change virtual ports, the transmitter sends an FF byte followed by the channel number. There are a few issues to consider.
First, the transmitter has to be aware that if it really wants to send an FF, it can’t. So it sends FF FE instead. If you were sending nothing but FF characters, that would double the amount of data sent, but that’s a relatively rare situation.
Second, there is a robustness problem if the transmitter sends an FF and then dies. The next byte could be considered a channel number. However, since a freshly restarted transmitter should send an initial channel selector, the next byte should be an FF (the initial transmit selector). To combat this, the protocol accepts any number of FF bytes as a legitimate prefix. So all of the following will select channel 4:
FF 04
FF FF 04
FF FF FF FF FF FF 04
The only issue is if the serial connection is intermittent. It is possible to get an FF byte, have the cable go out temporarily and then get a later byte that will trigger an unwanted channel change. There isn’t much you can do about that, although this assumes the next byte is a legitimate channel number since most systems won’t use all possible channels. You could add some robustness by timing out the escape prefix or adding, say, a checksum to the switching sequence but that would only reduce problems not eliminate them. If you are dealing in pure ASCII data, limiting to channels above 0x80 would reduce the issue but, again, not totally eliminate it. In practice, if you have a reliable serial connection, there’s no problem.
Third, there is the case where the receiver dies and starts again midstream. This can cause an issue where some data goes to the wrong virtual terminal. There are two features to help with this. First, if the transmitter sends FF FD to the receiver, the receiver should retransmit its current channel selector. You could also set a transmitter to periodically send the channel selector since it is harmless to send the same selector more than one time.
Another way to combat this partially is to use the
-s
switch on the Linux server to prevent any data from flowing to the virtual terminals until one is explicitly selected. Note that this only matters during the start-up phase of the server. Once a channel is selected it stays selected until another one is selected.
KISS
You can probably see that all the complexity here is to make the server fit in with Linux and the microcontroller side fit in with the C library calls. If you wanted to send data from, say, an Arduino, it would be easy to just prefix everything with “\xFF\xCC” where CC is the channel number. Receiving data could be almost that easy. You just have to remember when you’ve seen an FF and handle the three escape codes (that is, FE is a real FF, FD is a request to resend the channel selector, and everything else is a channel change).
However, I wanted to be able to just have virtual serial ports on both sides of the cable, so it was a lot more work. Part of it is that working with
Mbed I/O streams is quirky at best
. First, let’s look at the Linux server.
The Linux Server
The Linux software opens a terminal port (e.g.,
/dev/ttyUSB0
or
/dev/ttyACM0
etc.) and then produces multiple pseudo terminals that most terminal software can use. For USB devices, the baud rate is probably unimportant. However, for a real serial device, you probably need to match up baudrates (untested). The code currently does not change the baudrate so you’d need to set it externally or modify the code if you need to.
The ttymux program takes a few options. The only one that is critical is the -c option which defines a virtual port. Each port has an ID number from 0-253. You can also ask for a symlink. So, for example, look at this command:
ttymux -c 10 -c 33:virtualportA -c 50:/tmp/portB /dev/ttyACM0
Here we are creating three ports. Port #10 has no name. Port 33 and 50 will be in ./virtualportA and /tmp/portB, respectively.
Other options:
-d – Autodelete symlinks on exit
-n – Do not set attributes on serial port
-s – Do not send data to a virtual port until expressly selected
When the program runs you’ll see a list of channels and their associated psuedoterminals (probably
/dev/pts/X
where X is some number). If you don’t provide a symlink, that’s how you connect to the virtual port. If you provide a symlink, you can use either. Note that the ID number is not the same as the pts number. So channel 10 in the above example probably won’t be
/dev/pts/10
. If it is, that’s just a coincidence.
To compile, you need pthreads:
g++ -o ttymux ttymux.cpp -lpthread
Looking at the
code
, the server isn’t really that complex. There are two threads. One reads the serial port and the other writes to it. Nothing else touches the real serial port. Then each virtual channel has its own pty. There’s no need to buffer characters or anything.
The part that creates the pty is very simple:
pty=posix_openpt(O_RDWR|O_NOCTTY|O_NONBLOCK);
if (pty==-1) return -1;
grantpt(pty);
unlockpt(pty);
To create the symbolic links, you need to know the name of the pty which is what the getptyname call is for. Using that file name to open will give you the terminal side of the pty. I usually use picocom which has no problems. But some programs, like cutecom, for example, know too much about what a serial port is supposed to look like so you can’t open a pty with them.
The Microcontroller
The microcontroller code is a bit more convoluted. The
SerialMux
class does all the work. Like the Linux side, it has two threads that control access to the real port. Unlike the Linux side, each virtual serial port object has its own set of input and output buffers. The threads fill those buffers and — eventually —
_read
and
_write
do the work of getting the data in and out of the Mbed stream base class. It is not terribly efficient because the streams eventually call
_putch
and
_getch
to do I/O character by character, but there are reasons for that and if you really wanted to tweak it, you could override the underlying methods.
One thing that surprised me was that returning true for the
isatty
function totally breaks the I/O system. I didn’t figure out why, but I did note that the factory-standard USBSerial class also returns false for this and has a comment about it in the Mbed source code.
Another thing that was odd is that the stream’s built in mutex acted strangely and I never figured out exactly why. It may be that it protects all streams or something but I eventually reverted to having my own mutex to protect each set of buffers and another mutex to protect the physical serial port.
Once you follow the logic, the SerialMux class is not that hard. A lot of the code in the main.cpp is to work around issues when the USB port is disconnected.
I also copied and modified a class I’ve used before to build
command processing systems
. Probably overkill for this, but I had it hanging around and it was easy to use. It is interesting that the code doesn’t know anything about the multiplex system. It just takes a normal stream and works fine.
In Use
Once you have the microcontroller program loaded you can run the Linux server with this command line:
ttymux -s -c 1:analogport.virtual -c 2:digitalport.virtual -c 100:debugport.virtual -c 10:cmdport.virtual
I then use picocom on each virtual port, although you could probably use any other terminal program. You will want to set some options for the command terminal for your own benefit:
picocom -c --omap crlf cmdport.virtual
In the analog and digital terminals, press any key but a space to pause the loop. A space will resume. In the command window, you can use the help command to get a list of what you can do. Don’t expect backspace to work, although there are ways around that if you wanted to fix that.
Future Directions
The protocol is simple even if the example is not and there are many ports possible. Even simple microcontrollers could emulate many ports.
On the server side, someone will surely ask for Windows. It seems like you could do something similar with
com0com
or one of its related projects. Other ideas would be to feed network sockets instead of pseudo terminals or to work out a system to duplicate fake ports. The protocol and code are simple enough to make any of that possible.
It is true that USB composite devices are a better answer to this problem if you have the hardware and drivers to support it. However, that’s a lot more work, a lot more resources, and limits the ability of cheap hardware to participate.
If you are interested in the USB route, there are
some examples of using a Pi Zero
and some user-space code if you can provide your own Windows drivers. If the network angle piques your interest, you might have a go with
ser2net
. | 23 | 10 | [
{
"comment_id": "6467924",
"author": "Cyna",
"timestamp": "2022-05-03T17:15:20",
"content": "Threading on an STM32F4 must really mean tasking.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6467930",
"author": "Pat",
"timestamp": "2022-05-03T17:32:10",... | 1,760,372,705.738902 | ||
https://hackaday.com/2022/05/03/patching-the-kurzweil-k2500-synthesizer/ | Patching The Kurzweil K2500 Synthesizer | Matthew Carlson | [
"Musical Hacks",
"Reverse Engineering"
] | [
"Ghidra",
"patching",
"piano"
] | Despite being a computer with some extra chips, synthesizers today are still quite expensive. They used to cost far more, but we tend to think of them as instruments instead of computers. And just because it is an instrument doesn’t mean someone like [Peter Sobot] can’t
crack it open and patch the OS inside
.
The synth in question is a Kurzweil K2500, released in 1996 with a Motorola 68000. Rather than directly start pulling out parts on the kitchen table, [Peter] began by doing some online research. The K2500 operating system is still available online, and a quick pass through Ghidra showed some proper instructions, meaning the file
likely wasn’t encrypted
.
He found the part of the code that reads in a new firmware file and checks the header and checksum. Certain functions were very high in memory, and a quick consultation of the service manual yielded an answer: it was the volatile RAM. With that tidbit, [Peter] was able to find the function that copied chunks of the new ROM file to RAM and start decoding the file correctly. [Peter] changed a few strings, made sure the checksums were correct, and he was ready to flash. The actual tweaks that [Peter] are made are left up to the reader, but the techniques to get a working decompiled build and a viable ROM image to flash apply to many projects. One benefit is now the K2000 simulates correctly in MAME due to his spelunking. He has
his flashing script
up on GitHub for the curious.
Ghidra is perfect for this kind of thing. We’ve seen people
tweaking their water coolers with it.
It opens to door towards tweaking anything to your liking. | 2 | 1 | [
{
"comment_id": "6467911",
"author": "Iván Stepaniuk",
"timestamp": "2022-05-03T16:08:21",
"content": "Cool! Hopefully, that horrible 7×5 LCD font is part of the firmware and not burned into the LCD controller. Those “p”!",
"parent_id": null,
"depth": 1,
"replies": [
{
"com... | 1,760,372,706.038252 | ||
https://hackaday.com/2022/05/03/ask-hackaday-repair-cafe-or-not/ | Ask Hackaday: Repair Café Or Not? | Jenny List | [
"Featured",
"Interest",
"Original Art",
"Repair Hacks",
"Slider"
] | [
"electrical safety",
"repair",
"Repair Cafe"
] | A huge part of the work our community does, aside from making things and doing a lot of talking about the things we’d like to make, involves repair. We have the skills to fix our own stuff when it breaks, we can fix broken stuff that other people throw out when it breaks, and we can fix broken stuff belonging to other people. As our consumer society has evolved around products designed to frustrate repairs and facilitate instead the sale of new replacements for broken items this is an essential skill to keep alive; both to escape having to incessantly replace our possessions at the whim of corporate overlords, and to fight the never-ending tide of waste.
Repair Cafés: A Good Thing
A German repair café.
, Redaktion NdW, CC BY 2.0
So we repair things that are broken, for example on my bench in front of me is a formerly-broken camera I’ve given a new life, on the wall in one of my hackerspaces is a large screen TV saved from a dumpster where it lay with a broken PSU, and in another hackerspace a capsule coffee machine serves drinks through a plastic manifold held together with cable ties.
We do it for ourselves, we do it within our communities, and increasingly, we do it for the wider community at large. The
Repair Café
movement is one of local groups who host sessions at which they repair broken items brought in by members of the public, for free. Their work encompasses almost anything you’d find in a home, from textiles and furniture to electronics, and they are an extremely good cause that should be encouraged at all costs.
For all my admiration for the Repair Café movement though, I have chosen not to involve myself in my local one. Not because they aren’t a fine bunch of people or because they don’t do an exceptionally good job, but for a different reason. And it symbolically comes back to an afternoon over thirty years ago, when sitting in a university lab in Hull, I was taught how to wire a British mains plug.
It Starts With A Mains Plug
This is probably the worst-wired mains plug I could muster when
I wrote about appliance testing
.
Of course I already knew how to wire a mains plug as I’d been doing it when repairing broken electrical appliances for years at that point, but the point was that as an electronic engineering student I was being taught to do it properly. In fact during those three years training I learned a lot more about electrical safety than just how to wire a plug, I came away with plenty of high-voltage experience as well as a lot of
electrical safety testing
under my belt outside the realm of my course as I and my friends tried to ensure that the early-90s ravers we were setting up equipment for wouldn’t be electrocuted. If you can remember the rave era, you weren’t really
there
, man!
So I can do high-voltage electrical work, and I’ve been trained to do it safely. As I write this I’m surrounded by equipment on which I’ve done just that. But here’s the crux of my problem, as someone who’s been trained to do it I have a responsibility on my shoulders to get it right.
In other words, should someone later electrocute themselves on something that I repaired, I bear a greater liability than someone with no training, because I’m supposed to know how to do things safely. And since I may not know what else lurks in a piece of older mains electrical gear, I’ve reluctantly decided that it probably presents a risk and thus I’d better not participate in a Repair Café. It goes against a lot of what I personally stand for, but it’s my butt on the line if something goes wrong.
Ilvy Njiokiktjien
, CC BY-SA 3.0.
Among Hackaday’s readership will be people who participate in Repair Cafés, run them, or are involved in the wider Repair Café movement. I’d like to ask them whether my concerns above are valid or whether I’m worried about nothing, and indeed about the wider question of repair and liability. Repair Café or not, that’s the question! | 82 | 25 | [
{
"comment_id": "6467870",
"author": "jenningsthecat",
"timestamp": "2022-05-03T14:19:16",
"content": "From my experience with the Toronto repair cafe, there are LOTS of fixes that you can do or help with that are firmly in the SELV category, not to mention those that aren’t in the electrical/electr... | 1,760,372,706.177198 | ||
https://hackaday.com/2022/05/03/blending-peppers-ghost-synths-and-vintage-tvs/ | Blending Pepper’s Ghost, Synths, And Vintage TVs | Arya Voronova | [
"Art"
] | [
"art",
"blender",
"optical illusion",
"pepper's ghost",
"vintage television"
] | We were recently
tipped off to the work of [Joshua Ellingson]
, and digging in, we found an extensive collection of art and ongoing experiments, with synthesizers deforming and driving old black-and-white clips played on vintage television sets, objects jumping from screens into the real world and back, and cathode ray tube oscilloscopes drawing graphics in the air
(loud sound!)
(nitter)
. It’s recommended that you check out the short showcase videos we embedded below before you continue reading, because transcribing these visuals into words won’t do them justice.
In case you’re not up for a video, however, we shall try transcribing them anyway. Animals, shapes and figures appear in the real world, bound by glass spheres and containers, using the technique known as Pepper’s Ghost. A variety of screens used for creating that illusion – sometimes it’s a tablet, and sometimes it’s an old television set rested upside down on top of a glass aquarium. Vintage television sets are involved quite often in [Ellingson]’s experiments, typically found playing movie scenes and clips from their appropriate eras, or even
used as one of the locations
that a Pepper’s Ghost-enchanted object could move into — firmly a part of the same imaginary world turned real.
It’s not always that things move from a TV screen into their glass boundary, gaining an extra dimension in the process, but when it happens,
the synchronization is impeccable
. All of that is backed by — and usually controlled by — Moog synthesizer sounds, knob turns driving video distortions or aspects of an object movement. Not all of his clips have synthesizers, old TVs, or Pepper’s Ghost illusion in them, but every experiment of his contains at least two out of these three, working in unison to create impressions. And as much as the art value is undeniable, [Ellingson] also adds a whole lot of hacker value for us to take away!
[Ellingson] understands what goes into building optical illusions like Pepper’s Ghost — using a variety of different glassware, from Erlenmeyer flasks to teapots, producing a consistent and ongoing stream of new ideas with unique spins on them. His aim is to share and create beyond what his art can achieve, which is why he encourages us to try it out ourselves — with this
one minute video
of a quick Pepper’s Ghost build, using nothing but a generic tablet, an emptied-out plastic snow globe and a piece of cheap transparency film used for school projectors. If you want to go beyond, he’s made
an extensive tutorial
on illusions of the kind he does, their simplicities and complexities, and all the different ways you can build one.
We all benefit when an artist finds a technology and starts playing with it, closing the divide between technology and art – and by extension, the divide between technology and nature. Sometimes, it’s
flowing light art installations
where you are a boulder in route of plankton’s movement, other times, it’s through-hole component-packed
printed circuit birds
that sing not unlike the non-printed-circuit ones, or
manipulation of CRT displays
with function generator-driven coils to offset the beam and turn the image into a pattern of lines.
We thank [Adrian] for sharing this with us! | 10 | 7 | [
{
"comment_id": "6467844",
"author": "CRJEEA",
"timestamp": "2022-05-03T12:44:17",
"content": "That’s a pretty awesome visual effect.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6467846",
"author": "metalman",
"timestamp": "2022-05-03T12:51:33",
... | 1,760,372,705.997848 | ||
https://hackaday.com/2022/05/03/wearable-electronics-takes-the-3d-printing-route/ | Wearable Electronics Takes The 3D Printing Route | Jenny List | [
"3d Printer hacks",
"Wearable Hacks"
] | [
"easythreed k7",
"wearable",
"wearable 3d printer"
] | There was a time when a cheap 3D printer was almost certain to mean an awful kit of parts, usually a so-called “Prusa i3”, which was of course as far away in quality from the machines supplied by [Josef Průša] himself as it’s possible to get. But as Chinese manufacturers such as Creality have brought machines with some quality and relaibility into the budget space these abominations have largely been crowded out. There are still cheap 3D printers to be found though, and it’s one of these that [3D Printing Professor]
has mounted on his wrist
(
Nitter
) for the ultimate in portable manufacturing.
The
Easythreed K7
is a novel take on a 3D printer that positions the device more as a child’s toy than a desktop manufacturing solution. It’s somewhat limited in its capabilities by its tiny size but by all accounts it’s a usable machine, and at around $100 USD it’s about the cheapest 3D printer for sale on the likes of AliExpress.
The wearable mount
is probably best described as a forearm mount rather than a wrist mount, but has provision for a battery pack and a small roll of filament. And this contraption is claimed to work, but we maybe would think before committing to a day-long print with it.
This may be the smallest wearable 3D printer we’ve shown you so far, but it’s not the first. That achievement goes to Shenzhen maker [Naomi Wu],
who strapped one on her back way back in 2017
.
Thanks [J. Peterson] for the tip! | 6 | 5 | [
{
"comment_id": "6467837",
"author": "fdufnews",
"timestamp": "2022-05-03T12:17:12",
"content": "go go gadget 3D printer",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6467894",
"author": "MrUnderhill89",
"timestamp": "2022-05-03T15:14:37",
"conten... | 1,760,372,705.938339 | ||
https://hackaday.com/2022/05/02/this-colossal-vacuum-tube-computer-plays-a-mean-game-of-pong/ | This Colossal Vacuum Tube Computer Plays A Mean Game Of Pong | Robin Kearey | [
"Retrocomputing"
] | [
"pong",
"reed relay",
"vacuum tube computer"
] | It doesn’t happen often that we report on new vacuum tube based computer designs. Today however, we’re pleased to introduce to you the
Fast Reliable Electronic Digital Dot Computer
, or Fred.Computer for short. It’s the brainchild of [Mike] who also brought us ENA,
which we featured earlier
.
Fred is a new design that reuses the parts that made up ENA. It has an 8-bit CPU, 16 bytes of RAM, 256 bytes of NVRAM, and runs at a clock speed of 11.3 kHz. With its 560 tubes drawing a total supply current of about 200 A it also provides a fair bit of heating to [Mike]’s study. The main logic is implemented through NOR gates, built from 6N3P dual-triode tubes sourced from Eastern Europe. These NOR gates are combined into more complex structures like latches, registers and even a complete ALU. A total of sixteen machine code instructions can be used to write programs; clever design allows Fred to perform 16, 32 or even 64-bit calculations with its 8-bit ALU.
Need some RAM? There’s sixteen bytes right here.
An interesting addition is a new RAM design based on reed relays. [Mike] realised that relays are actually very similar to digital transmission gates and can therefore be used to make a simple static RAM cell. If you thought relays were too slow for RAM cells, think again: these reed relays can toggle at a mind-boggling 700 Hz, making them more than fast enough for Fred.
The main I/O device is a console that contains several pushbuttons as well as a 12 x 8 LED display. All of this makes Fred a fully-functional general-purpose computer that’s even capable of playing Pong (video, embedded below). [Mike]’s website is full of interesting detail on all aspects of vacuum tube computer design, and makes delightful reading for anyone tempted by the idea of building their own.
Can’t get enough of vacuum tube computers? Have a look at
this 1-bit MC14500 implementation
, marvel at
this modern interpretation of an adding machine
, or find out
how IBM designed its logic in the 1950s
. | 12 | 5 | [
{
"comment_id": "6467818",
"author": "Vernon vogt",
"timestamp": "2022-05-03T10:41:15",
"content": "My 1954 tube computerhttps://photos.app.goo.gl/hxyKEUC2fNUB2jDK9",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6481094",
"author": "okb164",
... | 1,760,372,706.28818 | ||
https://hackaday.com/2022/05/02/the-most-deadly-project-on-the-internet/ | The Deadliest Project On The Internet? | Ryan Flowers | [
"Art",
"Science"
] | [
"electrical safety",
"fire safety",
"high voltage",
"high voltage MOT",
"microwave oven transformer",
"MOT",
"public safety",
"safety"
] | Before deciding whether the headline of this article is clickbait, please take a moment to watch
the excellent video by [BigClive] below the break
. And then, go to your local search engine and search the phrase “fractal burning death”. We’ll wait.
With that out of the way, we have to admit that when we saw the subject “The most deadly project on the Internet” on [bigclivedotcom]’s YouTube channel, we were a bit skeptical. It’s a big claim. But then we watched the video and did some googling. Sadly, there are
over 30 documented cases
of this project killing people, and more cases of permanent grievous injury.
The results of Fractal Wood Burning with High Voltage
Fractal Burning is a hobby where wood is burned by slathering wood in a conductive slurry and then applying high voltage to either side of the wood, usually using something not rated for high voltage, such as jumper cables. The High Voltage is supplied by an
unmodified
Microwave Oven Transformer. Other projects using MOT’s typically rip out the high voltage secondary windings and re-wind them as low voltage, high amperage transformers, and are using in Spot Welders and even arc welders.
As laid out by [BigClive], the voltages coming from an unmodified MOT, ranging from 2-3 KV (That’s between two and three
thousand Volts
) at a very low impedance are right up there in the “Don’t go near it!” territory.
While many in the Hacker community would have our hackles raised, many of the people who will do such projects aren’t familiar with electrical safety of any kind, but are rather more interested in the artistic effects for inclusion in woodworking projects. Surely such ones are not cavalier with their own lives on a regular basis, but the seemingly innocuous “cool” factor seems to have made this highly dangerous project seem more attractive than dangerous, especially as it gets more popular on social media platforms such as TikTok.
What’s the takeaway from all of this? As hackers who share our projects with the world, it’s on us to convey any danger that somebody else may put themselves in by following our footsteps. Surely a 60 second TikTok video isn’t enough to do that, no more than a pair of jumper cables are suitable for safely handling 2-3 kV. Perhaps such considerations will help us decide what mediums we want to use to share our projects with the world. What are your thoughts?
Of course high voltage isn’t the only way to spark a debate (or a fire). Lithium Ion batteries are known for doing the same, and these
Lessons in Lithium Ion Safety
are a good refresher course. | 96 | 25 | [
{
"comment_id": "6467727",
"author": "MmmDee",
"timestamp": "2022-05-03T02:06:16",
"content": "TikTok had a series of these 3 or 4 months ago. Makes for some good looking art, though obviously dangerous.",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6468030... | 1,760,372,706.671924 | ||
https://hackaday.com/2022/05/02/simple-hardware-switch-for-os-dualbooting-thanks-to-rp2040/ | Simple Hardware Switch For OS Dualbooting, Thanks To RP2040 | Arya Voronova | [
"computer hacks"
] | [
"bootloader",
"dualboot",
"dualbooting",
"grub",
"rp2040"
] | Dualbooting your computer can be a chore, the more switching between OSes you have to do – which is why virtualization or having separate computers are the go-to for many. Failing that, we have no choice but to smooth over our dualbooting experience with various workarounds and helpers. [William Somsky] shares
one such helper tool
with us – an elegant device made with a RP2040-sporting TinyPICO board and a three-way rocker switch, directing GRUB to boot into either Windows or Linux automatically, or leave us with the usual boot menu. This way, you can just flip the switch, hit “reboot” and walk away, coming back to your PC booted into OS of your choice, instead of timing your presence just so that you can catch the boot menu on time.
All you need to do is to solder a rocker switch to your RP2040 board of choice, then flash the RP2040 with code that detects the state of the switch, and creates a mass storage device hosting a file setting a Grub variable to either one of the 0, 1 or 2. [William] describes his journey, fighting mysterious caching problems, but tells us he got it working in the end. Sadly, [William] hasn’t shared the RP2040-side code with us, but he has at least put the Grub’s
custom.cfg
file in the ‘Files’ section of the Hackaday.io project.
Readily accessible microcontrollers with mass storage functions sure help make such hacks simple – earlier, we’ve seen
dualboot switching like this
done by modifying assembly code of the MBR. Dualbooting is a hacker’s rite of passage, and certain OSes of late
can make it harder than other ones
. Even if you don’t want to dualboot your PC, however, you sure can
dualboot an Arduino! | 43 | 18 | [
{
"comment_id": "6467668",
"author": "Ken",
"timestamp": "2022-05-02T23:05:52",
"content": "Seriously? 25 years ago we would have just put a switch on the hard drive power plugs, but of course, that would have required multiple drives… this solution requires its own microcontroller?Kids these days! ... | 1,760,372,706.757476 | ||
https://hackaday.com/2022/05/02/hackaday-prize-2022-a-3d-printed-portable-wind-turbine-for-hikers/ | Hackaday Prize 2022: A 3D Printed Portable Wind Turbine For Hikers | Robin Kearey | [
"green hacks"
] | [
"3d printed",
"hiking",
"Wind turbine"
] | If you’re out in the wilderness and off the grid, but still need to charge your phone, the most obvious way to do that is by using a solar panel. Light, flat and without moving parts, they’re easy to store and carry on a hike. But they obviously don’t work in the dark, so what’s a hiker to do if they want to charge their devices at night? If you happen to be in a windy place, then [adriancubas] has the solution for you:
a portable wind turbine that folds up to the size of a 2 L soda bottle
.
[adrian] designed the turbine to be light and compact enough to take with him on multi-day camping trips. Nearly all parts are 3D printed in PLA, and although ABS or PETG would have been stronger, the current design seems to hold up well in a moderate breeze. The generator core is made from a stepper motor with a bridge rectifier and a capacitor to create a DC output. [adrian] estimates the maximum power output to be around 12 W, which should be more than enough to charge a few beefy power banks overnight.
All parts are available as STL files on [adrian]’s project page, so if you’re looking for some wind power to charge your gadgets on your next camping trip you can go ahead and build one yourself. While we’ve seen
large 3D printed wind turbines
before, and
portable ones for hikers
, [adrian]’s clever folding design is a neat step up towards making wind power almost as easy to use as solar power.
The
Hackaday
Prize2022
is Sponsored by: | 44 | 10 | [
{
"comment_id": "6467604",
"author": "Beaker",
"timestamp": "2022-05-02T21:06:37",
"content": "That’s going to have to get smaller to get in with the ultralight and long-haul crowds. Ditch the pole and mount to a trekking pole (guy wire with tent stakes), with a lower caddy that rotates in tandem w... | 1,760,372,706.517251 | ||
https://hackaday.com/2022/05/02/i2c-tap-helps-assign-blame-for-sda-conflicts/ | I2C Tap Helps Assign Blame For SDA Conflicts | Arya Voronova | [
"Microcontrollers",
"Tool Hacks"
] | [
"debugging",
"debugging tools",
"hackaday.io",
"i2c"
] | If you’ve ever debugged a misbehaving I2C circuit, you probably know how frustrating it can be. Thankfully [Jim] over at Hackaday.io,
has a proto-boardable circuit
that can help!
Inter-integrated circuit
bus (aka I2C) uses open collector outputs on a two wire interface. Open collector means a device connected to the I2C bus can only pull the bus down to ground. Chips never drive a logic “HIGH” on the wires. When nothing is driving the lines low, a weak resistor pulls the lines up to VCC. This is a good thing, because I2C is also a multidrop bus — meaning many devices can be connected to the bus at the time. Without open collector outputs, one chip could drive a high, while another drives a low – which would create a short circuit, possibly damaging both devices.
Even with all this protection, there can be problems. The SCL and SDA lines in the I2C communication protocol are bidirectional, which means either a controller or a peripheral can pull it low. Sometimes, when tracing I2C communications you’ll need to figure out which part is holding the line low. With many devices sharing the same bus, that can become nigh-impossible. Some folks have tricks with resistors and analog sampling, but the tried and true method of de-soldering and physically lifting chip pins off the bus often comes into play.
[Jim’s] circuit splits SDA signal into controller-side and peripheral-side, helping you make it clear who is to blame for hiccups and stray noise. To do that, he’s using 6N137 optoisolators and LMV393 comparators. [Jim] shared a NapkinCAD schematic with us, meant to be replicate-able in times of dire need. With this design, you can split your I2C bus into four separate channels – controller-side SDA, peripheral-side SDA, combined SDA and SCL. 4 Channels might be a lot for a scope, but this is no problem for today’s cheap logic analyzers.
The circuit is rated for 100KHz debugging, but if it doesn’t work for your 400KHz (or higher) bus, you can always lower the speed. This kind of monitor is useful for taming devices going rogue, and it isn’t technically limited to SDA splitting! I2C also has a feature called clock stretching, where peripherals are are allowed to manipulate the SCL line, too. In case of clock stretching-related problems, you can swap the SCL and SDA lines, which will allow you to use [Jim’s] circuit on SCL.
It absolutely wouldn’t be hard to assemble a device like this when you’re really stuck with a tricky I2C situation. What kind? We’ve talked about all the possible I2C problems in
a long-form article of ours! | 8 | 4 | [
{
"comment_id": "6467554",
"author": "Jan Praegert",
"timestamp": "2022-05-02T18:49:46",
"content": "Pffff [Jim]. I don’t like suggesting to use a cheap clone with saleae software.PulseView is open source and more than enough to get the task done. It works out of the box with those CY7C68013A boxes.... | 1,760,372,706.234341 | ||
https://hackaday.com/2022/05/02/big-chemistry-synthetic-oil/ | Big Chemistry: Synthetic Oil | Dan Maloney | [
"chemistry hacks",
"Hackaday Columns",
"Slider"
] | [
"lubricant",
"lubrication",
"mineral",
"motor oil",
"oil",
"polymer",
"Synthetic"
] | For as long as I’ve been driving, I’ve been changing oil. Longer than that, actually — before I even got my license, I did a lot of the maintenance and repair work on the family car. It seemed natural to do it back then, and it continues today, despite the fact that it would probably be cheaper overall to farm the job out. I keep doing it mainly because I like keeping in touch with what’s going on with my cars.
Oil changes require supplies, but the last few times I made the trip to BigBoxMart I came back empty-handed. I don’t know whether it’s one of the seemingly endless supply chain problems or something else, but the aisle that usually has an abundance of oil was severely understocked. And what was there was mostly synthetic oil, which I’ve never tried before.
I’ve resisted the move to synthetic motor oil because it just seemed like a gimmick to relieve me of more of my hard-earned money than necessary. But now that it seems like I might have little choice but to use synthetic oil, I thought I’d do what normally do: look into the details of synthetic oils, and share what I’ve found with all of you.
Old Mechanic’s Tales
Right up front, I’ll say that there appears to be a lot of “folklore” about motor oils in general and synthetics in particular, and a lot of strong feelings among people for whom cars are more than mere transportation. So it’s easy to find videos and blog posts that insist that synthetics are a gift from the lubrication gods, and ones that declaim against synthetics in the strongest possible terms. And of course, each camp looks at the other as heretics, whose lubrication predilections are sure to lead them into a pit of automotive despair and suffering. Such is our polarized world, I suppose.
While I don’t really want to choose sides in the motor oil wars, I definitely do not want to do anything that could potentially damage the carefully tended engines of my cars. Having never run synthetics, I did feel a little due diligence was in order: is it possible for synthetics to cause damage to older engines that have only run traditional oils?
The short answer is: probably not. When synthetic oils first came out, their chemistry was not entirely compatible with current engine technology. Specifically, the early ester-based synthetics caused problems with engine seals containing polyester resins. Those days are long gone, as both engine seal technology and synthetic oil formulations have improved. Modern synthetics have been tested to be compatible with all sorts of materials commonly used in engine seals, like nitrile, silicone, polyacrylates, and fluoroelastomers like Viton. Oils that bear the proper testing certifications have been shown not to cause excessive swelling or shrinking, hardening, or reduction in strength in seal material when exposed to synthetic oil.
So basically, if you’ve got an engine made any time in the last 30 years or so, and you use a synthetic oil that matches the manufacturer’s recommendations, you should be fine.
All About the Base
But what exactly is it about synthetic motor oil that makes it synthetic? And how does it differ from traditional motor oil? As it turns out, there’s less difference than you’d think between the two oils, but the way that they differ is pretty interesting, and the differences revealed the world of lubrication engineering in a way that I never really appreciated before.
All motor oils, traditional or synthetic, are highly engineered products that contain a bewildering array of additives, each with a specific job. However, motor oils all start with a base oil, which falls into one of five broad groups, based on properties such as sulfur content, viscosity, and the amount of saturated hydrocarbons it contains — more on that later:
API base oil groups. Note that mineral oils all have some degree of sulfur and unsaturated hydrocarbons based on the crude oil they are sourced from and the refining method. PAO base oils lack these compounds. Source:
American Petroleum Institute
API BASE OIL CATEGORIES
Base Oil Category
Sulfur (%)
Saturates (%)
Viscosity Index
Mineral
Group I (solvent refined)
> 0.03
and/or
< 90
80 to 120
Group II (hydrotreated)
< 0.03
and
> 90
80 to 120
Group III (hydrocracked)
< 0.03
and
> 90
> 120
Synthetic
Group IV
Poly-α-olefin (PAO) lubricants
Group V
All other base oils
Group I, II, and III base oils are all derived from crude oil, and the methods used to refine the crude feedstock into lighter fractions suitable for engine oil largely determine the amount of sulfur in the base oil, as well as the concentration of unsaturated hydrocarbon compounds in it. Saturated hydrocarbons are ones where each carbon in the backbone of the polymer is fully populated with hydrogens; in other words, saturated compounds have no carbon-carbon double bonds. This is important because unsaturated bonds are potential sites for oxidation, which can damage the properties of the base oil.
Synthetic, Yes, But…
So since the base oils for traditional mineral oils come straight from the ground in the form of crude oil, surely that must mean that synthetic oil avoids the stain of association with fossil fuels. As it turns out, that’s not the case. If there’s one thing we’ve learned from this
“Big Chemistry” series
, it’s that almost everything we use in daily life comes, in whole or in part, from petrochemicals. And it’s the same with synthetic oil.
Group IV base oils are almost exclusively poly-α-olefins, or PAOs. Like plastics, PAOs are synthetic polymers, but rather than having massively long and intricately cross-liked sidechains, PAOs are mostly a small number of short sidechains linked together. But, plastics and PAOs have a lot in common, in terms of starting materials and the processes needed to create them.
The starting point for most polymers is natural gas. The primary compound in natural gas is methane (CH
4
), the simplest hydrocarbon possible and a member of the alkane family, which has a backbone of fully saturated carbons. But most natural gas deposits also have a significant concentration of more complicated alkanes, such as the four-carbon butane, three-carbon propane, and two-carbon ethane. Ethane is the starting point for much polymer chemistry, and can be isolated from raw natural gas by selective condensation.
Ethane is distilled from natural gas and converted to ethylene by steam cracking.
Ethane gas can be converted into ethylene gas by steam cracking, which uses high temperatures and pressures to break down saturated hydrocarbons and introduce carbon-carbon double bonds. Hydrocarbons with at least one double bond are referred to as alkenes, and the alkene version of ethane is called ethylene. And ethylene, with its chemically reactive and centrally located double bond, is an extremely useful building block.
The next step along the way to synthetic oil is making longer chain alkenes from ethylene. The chemical process used for this,
the Ziegler process
, is complex and beyond the scope of this article – and honestly, beyond my understanding. But suffice it to say that it uses
an aluminum-containing organic catalyst
to stick multiple ethylene compounds together. The Ziegler process allows fine control over the oligomerization reaction, and can produce alkenes of specific lengths. When the carbon backbone has ten carbons with a single double bond, it’s called 1-decene.
1-decene is a ten-carbon alpha-olefin, produced from oligomerizing ethylene using the Ziegler process.
Alkenes, which are also known as olefins, are characterized by where along the carbon backbone their double bond is located. When the double bond is located next to the first, or alpha, carbon, the resulting molecule is called an alpha-olefin, or α-olefin. 1-decene is the most common α-olefin used in the production of poly-α-olefin, which is accomplished by reacting 1-decene with a catalyst of boron trifluoride (BF
3
) and either water or an alcohol. This reaction targets the vulnerable double bond on the α-carbon of 1-decene, linking it to the α-carbon on another 1-decene molecule.
1-decene chains are added to a growing PAO by boron trifluoride and water. The oligomerization reaction is allowed to continue for about five cycles before being stopped. The leftover double-bond on the last decene to be added is later removed by hydrogenation, to remove a potential oxidation site.
Unlike in plastics, the polymerization reaction is only allowed to go for a few rounds, yielding small oligomers of 1-decene. Five or six rounds are typical, resulting in a PAO that is completely devoid of sulfur compounds and unsaturated bonds — the remaining double bond from the last reaction is saturated by reacting the PAO with hydrogen gas under pressure. That removes the last possible site for oxidation, making for a stable PAO base oil.
Almost Done
PAOs are manufactured in huge volumes and shipped to blending facilities where the base oils are mixed together to achieve the proper viscosity. Additives such as detergents, dispersants, anti-foaming agents, and anti-wear agents are added to meet the specifications of the final product.
While the name may be misleading, in many cases synthetic motor oils hold the edge over their mineral oil counterparts. When making a motor oil from a mineral base oil, it’s nearly impossible to avoid potentially performance-limiting problems, especially oxidation sites. On the other hand, synthetic oils can almost entirely avoid introducing those oxidation sites, leading to a final product that lasts longer and performs better throughout its life. Rafe from
Lubrication Expert
has a great video on the topic:
I don’t know if I’ll ever be able to bring myself to go 25,000 miles without changing the oil, which synthetic manufacturers often advertise as being possible, but now I know what’s behind that claim, and that the cost of synthetics is at least justified by the amount of engineering that goes into them. | 49 | 21 | [
{
"comment_id": "6467533",
"author": "Charlie L",
"timestamp": "2022-05-02T17:50:56",
"content": "Final note: I’ve been using synethetics (only synthentics) for years starting with my last three new cars (Toyota Priuses). I was told by my dealer (whom I actually trust) and several mechanics that onc... | 1,760,372,706.857794 | ||
https://hackaday.com/2022/05/02/for-once-the-long-arm-of-john-deere-presses-the-right-button/ | For Once, The Long Arm Of John Deere Presses The Right Button | Jenny List | [
"News",
"Security Hacks",
"Transportation Hacks"
] | [
"john deere",
"right to repair",
"tractor"
] | Over many years now we’ve covered right-to-repair stories, and among them has been a constant bête noire. The American farm machinery manufacturer John Deere whose instantly recognisable green and yellow tractors have reliably tilled the soil for over a century, have become the poster child for inappropriate use of DRM. It’s enough to make any farmer see red, but there’s a story from CNN which shows another side to manufacturer control.
A Deere dealership in Melitopol, Ukraine, was looted by invading Russian forces, who took away an estimated $5m worth of farm machinery
. The perfect crime perhaps, save for the Deere computer system being used to remotely disable them leaving the crooks with combine harvesters they can’t even start.
It makes for a good news story showing the Ukranians getting one over on the looters, and since on-farm thefts are a hot topic anywhere in the world it’s not entirely unexpected that Deere would have incorporated a kill-switch in their products. Recently we covered a look at
how the relationship between motor vehicle owner and manufacturer is changing from one of product ownership to software licence
, and this is evidently an example of the same thing in the world of machinery. It’s reported that the looters are seeking the help of tractor hackers, which may be unfortunate for them since
the world’s go-to source for hacked Deere software is Ukraine
. Perhaps they would be better remembering that
Russia has legendary tractors of its own
.
Thanks [Robert Piston] for the tip. | 84 | 35 | [
{
"comment_id": "6467512",
"author": "Tom Hargrave",
"timestamp": "2022-05-02T16:58:27",
"content": "Until the thieves figure out what’s been disabled and they hardwire around it.Just look at HackADay as an example, people can be incredibly resourceful!",
"parent_id": null,
"depth": 1,
"... | 1,760,372,707.168795 | ||
https://hackaday.com/2022/05/02/from-car-to-device-how-software-is-changing-vehicle-ownership/ | From Car To Device: How Software Is Changing Vehicle Ownership | Jenny List | [
"Transportation Hacks"
] | [
"cars",
"complexity",
"motor vehicles",
"right to repair",
"software"
] | For much of the last century, the ownership, loving care, and maintenance of an aged and decrepit automobile has been a rite of passage among the mechanically inclined. Sure, the battle against rust and worn-out parts may eventually be lost, but through that bond between hacker and machine are the formative experiences of motoring forged. In middle-age we wouldn’t think of setting off across the continent on a wing and a prayer in a decades-old vehicle, but somehow in our twenties we managed it. The Drive have a piece that explores how technological shifts in motor vehicle design are changing our relationship with cars such that what we’ve just described may become a thing of the past. Titled “
The Era of ‘the Car You Own Forever’ Is Coming to an End
“, it’s well worth a read.
At the crux of their argument is that carmakers are moving from a model in which they produce motor vehicles that are simply machines, into one where the vehicles are more like receptacles for their software. In much the same way as a smartphone is obsolete not necessarily through its hardware becoming useless but through its software becoming unmaintained, so will the cars of the future. Behind this is a commercial shift as the manufacturers chase profits and shareholder valuations, and a legal change in the relationship between customer and manufacturer that moves from ownership of a machine into being subject to the terms of a software license.
This last should be particularly concerning to all of us, after all if we’re expected to pay tens of thousands of dollars for a car it’s not unreasonable to expect that it will continue to serve us at our convenience rather than at that of its manufacturer.
If you’re a long-time Hackaday reader, you may remember that
we’ve touched on this topic before
.
Header image: Carolyn Williams,
CC BY 2.0
. | 48 | 10 | [
{
"comment_id": "6467484",
"author": "signao",
"timestamp": "2022-05-02T15:56:02",
"content": "Move towards software-defined cars, bicycles, scooters etc. will have a net positive impact I believe. For example, in case of theft, a car that requires Internet connectivity to start and operate can be r... | 1,760,372,707.0424 | ||
https://hackaday.com/2022/05/02/vintage-computer-festival-east-raises-the-bar-again/ | Vintage Computer Festival East Raises The Bar Again | Tom Nardi | [
"cons",
"Current Events",
"Featured",
"Interest",
"Retrocomputing",
"Slider"
] | [
"handheld",
"pbx",
"trs-80",
"VCF East",
"VCF East 2022",
"Vintage Computer Festival East"
] | When I arrived at the InfoAge Science and History Museum for this year’s
Vintage Computer Festival East
, I fully expected it to be a reduced event compared to last year. After all, how could it not? Due to the schedule getting shifted around by COVID, show runner Jeffrey Brace and his team had just six months to put together an event that usually gets planned over the course of an entire year. With such a truncated preparation time, they more than deserved a little slack.
But as anyone who attended VCF East 2022 can attest, they didn’t need it. Not only did the event
meet the high expectations set by last year’s Festival
, it managed to exceed them. There were more workshops, more talks, more vendors, more consignment rooms, more live streams, more…well, everything. This year’s program even got a splash of glossy color compared to the grayscale handout attendees received in October. It was, by any metric you care to use, better than ever.
It does however leave me in somewhat on an unenviable position. As we’ve learned during the pandemic, a virtual representation of an event as extensive as VCF can give you a taste of what’s offered, but all the nuance is lost. Looking at pictures of somebody’s passion project can’t compare to actually meeting the person and seeing that glint of pride in their eye as they walk you through all the details.
So bear that in mind through this rundown of some of the projects that caught my eye. This isn’t a “best of” list, and the Festival is certainly not a competition. But each attendee will invariably come away with their own handful of favorite memories, so I’ll document mine here. If you’d like to make your own memories, I’d strongly suggest making the trek out to the Jersey Shore come April 2023 for the next Vintage Computer Festival East.
History of Handhelds
A disturbing number of people believe that portable computing started in 2007 when Apple unveiled the first iPhone, but those who’ve been following the world of tech a
bit
closer know there’s a long line of organizers, PDAs, palmtops, tablets, and other oddball gadgets that stretch back to the very earliest days of personal computing. Dave Shevett brought along some choice selections from his incredible personal collection of handheld computing devices that ranged from a Curta mechanical calculator to iconic stalwarts like the Palm Pilot and BlackBerry.
At an event packed with as much rare and expensive hardware as VCF, you should generally keep your hands to yourself. But in this case, Dave invited attendees to pick up and play with the devices on display to get a feel for what using them might have been like. Well, not all of them. I didn’t see him hand the Curta off to the random passerby, but there’s only so much damage you can do to a Sony CLIE or a TRS-80 Model 100.
Checking Out Core64
I’ve learned over the years that “vintage computing” means something different depending on who you ask. For some, it’s the era of early desktops like the Commodore 64. Others are looking for big iron mainframes and front panel blinkenlights. Being of modern design,
Andy Geppert’s Core64
technically doesn’t fit into either camp, but it does allow you to interactively play with what’s unquestionably one of the most fascinating components of the very first digital computers: core memory.
We’ve covered Core64 here on Hackaday
in the past, and Andy even hosted a
Retro Memory Hack Chat
in 2021
. But this is the first time I got the chance to see the hardware in person, and let me tell you, it’s
awesome
. The kits he brought along were long sold out by the time I got there, but he still had a couple demo units on hand for attendees to play with, and was happy to talk about the project with anyone who was interested. The device has several modes of operation, but the one that allows you to draw directly on the matrix by lighting up the LEDs behind each ferrite was especially popular with the younger crowd.
Its application as an educational tool was abundantly clear, but the Core64 isn’t just for the miniature hardware hackers in your life. There’s not a lot of opportunity to work with core memory these days, and even fewer to actually weave the stuff by hand, making this a particularly compelling gadget for anyone who wants to get some hands-on experience with
one of the technologies that helped put man on the Moon
.
Can You Hear Me Now?
At first glance, the
Dial 1 for IT
exhibit put together by Jason Perkins might seem somewhat out of place at a computer festival. While there was technically computer hardware involved, it was pushed off to the back, behind two tables that were stacked high with a wide array of telephones. The specimens on display ran the gamut from old rotary phones to relatively modern cordless models. There was even a payphone hung up on the wall next to the display, a particularly rare sight these days.
All of the phones were connected up to a PBX, and each had a little sticker indicating its extension. Attendees were free to pick up whatever phone tickled their fancy and dial up one of its peers. There was even a public phone number listed so you could call into the system from your cell. This exhibit gave younger audiences a chance to get hands-on with technology that they likely have never seen in person before, and it was a huge hit. There was a certain novelty to seeing teenagers use a payphone in 2022, and it wasn’t lost on them — several times I saw younger visitors taking pictures of their friends using the payphone with, ironically, the pocket supercomputers that pass for phones in the 21st century.
The TRS-80 Rides Again
For those who’ve never attended a VCF event, you might have the impression that the show floor looks like a computer museum — with rows of ancient machines arranged in tableau, far too old and fragile to power on, let alone actually use. In some special cases, you’d be right. But for the most part, VCF is as much about breathing new life into these classic machines as it is admiring them as historical artifacts.
RoundUp!
, a
new game developed for the TRS-80 by Peter Cetinski
is a perfect example.
Of course, simply developing a game for the TRS-80 isn’t necessarily that notable of an accomplishment. After all there was no shortage of games cranked out by single developers back in the day, and you could argue that the majority of TRS-80 owners were probably adept enough at BASIC that they would have fiddled with their own simple games (or copied them out of a book) at some point.
The trick here is that Peter isn’t using a 1980s development workflow. Instead, his games are created on a Macbook Pro using modern development tools. The aptly named
TRS-80 Screen Designer
from Plaid Vest Software
lets him create art assets using an interface that’s not entirely unlike the old grid paper worksheets. The
zmac cross compiler
lets you build binaries for the Tandy on your Windows, Linux, or Mac OS machine, and the
trs80gp emulator
lets you test them out. Slap the result on a stack of floppy disks (or cassette tapes, as the case may be), and you’ll be ready to get your own table at next year’s VCF.
Random Samplings
The many faces of the Compaq Portable
Spacewar running on a PDP-8
An authentic German Enigma machine
Wii Development Kit
Somebody’s got a new project on their hands.
You may not like it, but this is what peak PC gaming looks like.
Pushing old Weather Channel gear into service.
Making an Impression
No matter their age or background, everyone I spoke to at the 2022 Vintage Computer Festival had nothing but positive things to say about the event. At the end of the day even my own 11-year-old daughter, who usually spends her free time digging holes in
Minecraft
, was impressed. I’d say she came away from the event a bit wiser as well — there’s something about spending an afternoon toggling programs into the front panel of a minicomputer that makes the previously incomprehensible magic inside a modern smartphone seem quaint in comparison. She says she’s excited to go next year, and not just in the “
Dad’s says I have to go”
way, either.
Part of the appeal is no doubt the
InfoAge campus itself
, which offers an incredible array of exhibits for VCF visitors to explore. Seriously, were else is there a shipwreck museum in walking distance of an operational radio telescope? But even still, that the passionate members of the Vintage Computer Federation are able to craft an event that manages to enthrall guests that aren’t even half as old as the computers or equipment on display is frankly a minor miracle. Considering this year’s theme was “Computers for the masses”, I’d say they nailed it. | 34 | 12 | [
{
"comment_id": "6467460",
"author": "Thomas Cherryhomes (@tschak)",
"timestamp": "2022-05-02T14:06:59",
"content": "We were able to do a bring-up of the #Commodore version of #FujiNet as well. This happened in the lounge, and had a weather and ISS tracking display on the main monitor.",
"parent... | 1,760,372,706.950427 | ||
https://hackaday.com/2022/05/02/diy-metal-detector-gives-you-the-mettle-to-find-some-medals/ | DIY Metal Detector Gives You The Mettle To Find Some Medals | Bryan Cockfield | [
"classic hacks",
"News"
] | [
"circuit",
"coil",
"metal detector",
"op-amp",
"Operational amplifier",
"oscillator",
"simple"
] | Hurricane season is rapidly approaching those of us who live in the northern hemisphere. While that does come with a good deal of stress for any homeowners who live in the potential paths of storms it also comes with some opportunities for treasure hunting. Storms tend to wash up all kinds of things from the sea, and
if you are equipped with this DIY metal detector
you could be unearthing all kinds of interesting tchotchkes from the depths this year.
The metal detector comes to us from [mircemk] who is known for building simple yet effective metal detectors. Unlike his previous builds, this one uses only a single integrated circuit, the TL804 operational amplifier. It also works on the principle of beat-balance which is an amalgamation of two unique methods of detecting metal. When the wire coils detect a piece of metal in the ground, the information is fed to an earpiece through an audio jack which rounds out this straightforward build.
[mircemk] reports that this metal detector can detect small objects like coins up to 15 cm deep, and larger metal objects up to 50 cm. Of course, to build this you will also need the support components, wire, and time to tune the circuit. All things considered, though it’s a great entryway into the hobby.
Want to learn more about metal detecting? Check out this
similar-looking build which works on the induction balance principle
. | 23 | 7 | [
{
"comment_id": "6467412",
"author": "Artenz",
"timestamp": "2022-05-02T11:33:07",
"content": "There’s also a video by diodegonewild with similar overlapping coils:https://www.youtube.com/watch?v=eCRgNr6jj2g",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "64674... | 1,760,372,707.227394 | ||
https://hackaday.com/2022/05/02/need-a-snack-from-across-town-send-spot/ | Need A Snack From Across Town? Send Spot! | Dave Rowntree | [
"Artificial Intelligence",
"Robots Hacks"
] | [
"autonomous navigation",
"boston dynamics",
"computer vision",
"gnss",
"legged robot",
"neural network",
"Nvidia Jetson",
"RTK",
"speech recognition",
"spot"
] | [Dave Niewinski] clearly knows a thing or two about robots, judging from his YouTube channel. Usually the projects involve robot arms mounted on some sort of wheeled platform, but this time it’s the tune of some pretty famous yellow robot legs, in the shape of spot from Boston Dynamics. The premise is simple —
tell the robot what snacks you want, entirely by voice command, and off he goes to fetch.
But, we’re not talking about navigating to the fridge in the same room. We’re talking about trotting out the front door, down the street and crossing roads to visit favorite restaurant. Spot will order the snacks and bring them back, fully autonomously.
Spot’s depth cameras provide localized navigation and object avoidance information
Local AI vision system handles avoiding those pesky moving objects
There are multiple things going here, all of which are pretty big computational tasks. Firstly, there is no cloud-based voice control, ala Google voice or Alexa. The robot works on the premise of full autonomy, which means no internet connectivity for any aspect. All voice recognition, voice-to-text, and speech synthesis are performed locally using the
NVIDIA Riva
GPU-based AI speech SDK, running on the local
NVIDIA Jetson AGX Orin
carried on Spot’s back. A front-facing webcam supplies the audio feed for this. The voice recognition application listens for the wake phrase, then turns the snack order into text, for later replay when it gets to the destination. Navigation is taken care of with a
Microstrain RTK GNSS module
, which has all the needed robustness, such as dual antennas, and inertial fallback for those regions with a spotty signal. Navigation is no use out in the real world on its own, which is where Spot’s depth sensor cameras come in. These enable local obstacle avoidance, as per the usual spot behavior we’ve all seen before. But what about crossing the road without getting tens of thousands of dollars of someone else’s hardware crushed by a passing truck? Spot’s onboard streaming cameras are fed into the
NVIDIA dash cam net AI platform
which enables real-time recognition of moving obstacles such as cars, humans and anything else that might be wandering around and get in the way. All in all a cool project showing the future potential of AI in robotics for important tasks, like fetching me a beer when I most need it, even if it comes from the local corner shop.
We love robots around here. Robots can
mow your lawn
, navigate
inside your house with a little help from invisible QR Codes
, even
help out with growing your food
. The robot-assisted future long promised, may now be looking more like the present. | 22 | 11 | [
{
"comment_id": "6467351",
"author": "Dan",
"timestamp": "2022-05-02T08:53:32",
"content": "And deliveroo riders are out of jobs in 3… 2…",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6467390",
"author": "Fosselius",
"timestamp": "2022-05-02... | 1,760,372,707.297888 | ||
https://hackaday.com/2022/05/01/track-those-leftovers-with-this-little-timer/ | Track Those Leftovers With This Little Timer | Jenny List | [
"home hacks",
"Microcontrollers"
] | [
"food",
"Holtek",
"refridgerator",
"timer"
] | We’ve all at some point in our lives opened the fridge door and immediately wished we hadn’t. A miasma of stench envelops us as we discover that last Saturday’s leftovers have been forgotten, and have gone off. If only we had some way to keep track of such things, to avoid such a stench-laden moment. Step forward [ThinkLearnDo],
with a little timer designed for exactly that purpose
.
The operation is simple enough, press the button and place the unit on top of the container with the leftovers in it. If you haven’t eaten the leftovers within a week, the LED will start blinking. The blink is a subtle reminder to deal with the old food before it becomes a problem.
Onboard is a Holtek HT68F001 microcontroller with a coin cell for power, not much else is needed. The Holtek is an unusual choice, one of several brands of super-inexpensive Chinese microcontrollers we see less commonly than ATmegas and STM32s. This is exactly the place where such a minimal computer fits perfectly: a way to add a little bit of smarts to a very cheap item with minimal strain on the BoM.
If these chips interest you, a while back
we covered a run-down of the different families
including the Holtek and the famous 3-cent Padauk chips. | 28 | 11 | [
{
"comment_id": "6467253",
"author": "Severe Tire Damage",
"timestamp": "2022-05-02T05:06:55",
"content": "Use an esp8266 and send reminder messages to your cell phone.The little Holtek is cool though, but I have over 100 18650 laying around, so I could take a different route.",
"parent_id": nul... | 1,760,372,707.359298 | ||
https://hackaday.com/2022/05/01/all-in-one-automated-plant-care/ | All-In-One Automated Plant Care | Bryan Cockfield | [
"Microcontrollers"
] | [
"all-in-one",
"controller",
"ESP32",
"growing",
"light",
"moisture",
"plant",
"soil",
"water"
] | Caring for a few plants, or even an entire farm, can be quite a rewarding experience. Watching something grow under and then (optionally) produce food is a great hobby or career, but it can end up being complicated. Thanks to modern technology
we can get a considerable amount of help growing plants
, even if it’s just one plant in a single pot.
Plant Bot from [YJ] takes what would normally be a wide array of sensors and controllers and combines them all into a single device. To start, there is a moisture sensor integrated into the housing so that when the entire device is placed in soil it’s instantly ready to gather moisture data. Plant Bot also has the capability to control LED lighting if the plant is indoors. It can control the water supply to the plant, and it can also communicate information over WiFi or Bluetooth.
The entire build is based around an ESP32 which is integrated into the PCB along with all of the other sensors and components needed to monitor a single plant. Plant Bot is an excellent all-in-one solution for caring for a plant automatically. If you need to take care of more than one at a
time take a look at this fully automated hydroponic mini-farm
. | 18 | 8 | [
{
"comment_id": "6467219",
"author": "RW ver 0.0.1",
"timestamp": "2022-05-02T03:21:00",
"content": "Does it have robust debugging? … How does it deal with greenfly? :-D",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6467345",
"author": "FrankS",
... | 1,760,372,707.523239 | ||
https://hackaday.com/2022/05/01/hackaday-links-may-1-2022/ | Hackaday Links: May 1, 2022 | Dan Maloney | [
"Hackaday Columns",
"Hackaday links",
"Slider"
] | [
"aeroshell",
"Emmy",
"font",
"Hack Chat",
"hackaday links",
"Ingenuity",
"IPC-2152",
"lathe",
"Lichtenberg",
"mars",
"MPEG",
"parachute",
"Perseverance",
"thermal vias",
"Web Fonts",
"woodturning"
] | We start this week with news from Mars, because, let’s face it, the news from this planet isn’t all that much fun lately. But a couple of milestones were reached on the Red Planet, the first being
the arrival of
Perseverance
at the ancient river delta it was sent there to explore
. The rover certainly took the scenic route to get there, having covered 10.6 km over the last 424 sols to move to a position only about 3.5 km straight-line distance from where it landed. Granted, a lot of that extra driving was in support of the unexpectedly successful Ingenuity demonstration, plus taking time for a lot of pit stops along the way at interesting features. But the rover is now in place to examine sedimentary rocks most likely to harbor the fossil remains of ancient aquatic life — as opposed to the mainly igneous rocks it has studied along the crater floor so far. We’re looking forward to seeing what happens.
Speaking of
Ingenuity
, the plucky helicopter just keeps on performing. It recently completed its 27th flight — of five planned flights, mind you — and
spotted the crashed remains
of the aeroshell and parachute from
its spectacular arrival
last February. They look quite the worse for the wear, but that’s to be expected. The stunningly high-resolution pictures Ingenuity sent back will no doubt be pored over by engineers for whatever clues it holds about how the structure stood up to descent and landing conditions. We’re not sure, but this may be the first time a landing or crash site has been revisited since Allan Bean absolutely nailed the Apollo 12 landing to within walking distance of
Surveyor 3
in 1969.
“And the Emmy goes to… Comic Sans?” No, not really, and apologies to anyone triggered by the mention of The Font That Shall Not Be Used. But this week
the 2021 Technology & Engineering Emmy award
went to the World Wide Web Consortium (W3C) Web fonts Working Group and MPEG together for “standardizing font technology for custom downloadable fonts and typography for web and TV devices.” To be clear, the award is not for any particular font, but rather the technical achievement of downloadable fonts. Still, it’s easy to poke fun at typography, especially when font snobs go on about the merits of this serif or that descender. But those subtle differences that most of us think are meaningless actually play a huge role in the “feel” of websites. Web fonts have a lot to do with how polished and professional most sites look these days, compared to some of the atrocities of the Web 1.0 days.
A couple of weeks back, we had a
PCB Thermal Design Hack Chat
over on Hackaday.io with Mike Jouppi. It was a great discussion and spawned an interesting sidebar with attendee Sven about thermal vias. It looks like Sven’s application had plenty for Mike to sink his teeth into, because he made
an in-depth video
on the thermal design of this PCB, along with a discussion of what went into developing
IPC-2152
, the standard for PCB trace current-carrying capacity design. Thanks to Mark Hughes of Advanced Assembly for the heads up on this, and for suggesting Mike come on the Hack Chat in the first place.
And finally, it looks like Lichtenberg patterns are getting popular enough that it’s necessary to warn people that playing with electricity can be dangerous. Lichtenberg patterns, which are fractal channels burned into wood or other materials by the (hopefully) judicious application of high voltage, are certainly something
we’ve seen and featured before
. However, the American Association of Woodturners — because of course there’s such a group —
now condemns the practice
, which apparently has caught on in the woodturning community. The AAW
really
doesn’t want anyone doing Lichtenbergs — they banned the practice at all their events and in their publications, enlisted the aid of a doctor to tell everyone that electricity can stop your heart, and urged anyone who has fractal woodburning gear to throw it out now before it attacks. We understand and wholeheartedly agree that working with high voltage can be dangerous, and we’re not saying that woodturners should not take the potentially deadly consequences of Lichtenbergs seriously. But this warning seems a bit rich coming from an organization that encourages its members to stand in front of a machine that can
throw razor-sharp tools at you
,
fling heavy chunks of wood at your head
, or
instantly relieve you of your clothes
— or worse. Be safe out there, everyone. | 18 | 7 | [
{
"comment_id": "6467094",
"author": "Jeff Faust",
"timestamp": "2022-05-01T23:09:18",
"content": "Well, woodturners have had a few centuries to establish best practices for safety. Can’t blame them for being leery of this newfangled Lichtenberg stuff.",
"parent_id": null,
"depth": 1,
"r... | 1,760,372,707.624976 | ||
https://hackaday.com/2022/05/01/this-3d-printed-robot-can-actually-pick-locks/ | This 3D Printed Robot Can Actually Pick Locks | Robin Kearey | [
"lockpicking hacks",
"Robots Hacks"
] | [
"3d printed",
"lockpicking",
"robot"
] | Lockpicking is more of an art than a science: it’s probably 10% knowledge and 90% feeling. Only practice will teach you how much torque to apply to the cylinder, how to sense when you’ve pushed a pin far enough, or what it feels like when a pin springs back. Surely a robot would never be able to replicate such a delicate process, wouldn’t it?
Well, not according to [Lance] over at [Sparks and Code], who thought that
building a lock picking robot would be an interesting challenge
. He started out with a frame to hold a padlock and a servo motor to apply torque. A load cell measures the amount of force applied. This helps to keep the lock under a constant amount of tension as each pin is picked in succession. Although slow, this method seemed to work when moving the pick manually.
The difficult part was automating the pick movement. [Lance] built a clever system driven by two motors that would keep the pick perfectly straight while moving it horizontally and vertically. This was hard enough to get working correctly, but after adding a few additional clamps to remove wobble in the leadscrew, the robot was able to start picking. A second load cell inside the pick arm would detect the amount of force on each pin and work its way across the lock, pin by pin.
At least, that was the idea: as it turned out, simply dragging the pick across all pins in one go was enough to open the lock. A much simpler design could have achieved that, but no matter: designing a robot for all these intricate motions was a great learning experience anyway. It also gave [Lance] a good platform to start working on a more advanced robot that can pick higher-quality locks in which the dragging technique doesn’t work.
We haven’t come across lockpicking robots before; perhaps the closest equivalent would be this
3D-printed Snap Gun
. If you’re interested in all aspects of locks and how to apply them, check out our
Physical Security Hack Chat with Deviant Ollam
. | 8 | 7 | [
{
"comment_id": "6467055",
"author": "Raniz",
"timestamp": "2022-05-01T20:32:16",
"content": "Looks like a Master lock. If it’s one thing Ive learnt watching Bosnian Bill it’s that Master locks are crap.",
"parent_id": null,
"depth": 1,
"replies": []
},
{
"comment_id": "6467069",... | 1,760,372,707.570525 | ||
https://hackaday.com/2022/05/01/how-to-hide-a-photo-in-a-photo/ | How To Hide A Photo In A Photo | Jenny List | [
"Software Hacks"
] | [
"images",
"maths",
"steganography"
] | If you’ve ever read up on the basics of cryptography, you’ll be aware of steganography, the practice of hiding something inside something else. It’s a process that works with digital photographs and is the subject of
an article by [Aryan Ebrahimpour]
. It describes the process at a high level that’s easy to understand for non-maths-wizards. We’re sure Hackaday readers have plenty of their own ideas after reading it.
The process relies on the eye’s inability to see small changes at the LSB level to each pixel. In short, small changes in colour or brightness across an image are imperceptible to the naked eye but readable from the raw file with no problems. Thus the bits of a smaller bitmap can be placed in the LSB of each byte in a larger one, and the viewer is none the wiser.
We’re guessing that the increased noise in the image data would be detectable through mathematical analysis, but this should be enough to provide some fun. If you’d like a closer look,
there’s even some code to play with
. Meanwhile as we’re on the topic,
this isn’t the first time Hackaday have touched on steganography
. | 32 | 11 | [
{
"comment_id": "6467001",
"author": "JRD",
"timestamp": "2022-05-01T18:00:42",
"content": "Unfortunately, this particular steganography won’t survive exposure of the method. This method messes with the final bits of each byte. Once you know that, it’s trivial to run statistics on the final bits of ... | 1,760,372,707.774602 | ||
https://hackaday.com/2022/05/01/bend-your-prints-to-eliminate-supports/ | Bend Your Prints To Eliminate Supports | Arya Voronova | [
"3d Printer hacks"
] | [
"3d printed",
"enclosure",
"eurorack",
"flat pack",
"flex",
"flex hinge",
"foldable",
"freecad",
"living hinge"
] | When designing even a reasonably simple 3D-printable part, you need to account for all the supports it will require to print well. Strategic offsetting, chamfering, and filleting are firmly in our toolkits. Over time we’ve learned to dial our settings in so that, hopefully, we don’t have to fumble around with a xacto knife after the bed has cooled down. On Twitter, Chris
shows off his foldable 3D print experiments
(
nitter
) that work around the support problem by printing the part as a single piece able to fold into a block as soon as you pop it off the bed.
The main components of this trick seem to be the shape of the place where the print will fold, and the alignment of bottom layer lines perpendicular to the direction of the fold lines. [Chris] shows
a cross-section of his FreeCad design
, sharing the dimensions he has found to work best.
Of course, this is Twitter, so other hackers are making suggestions to improve the design — like
this sketch of a captive wedge
likely to improve alignment. As for layer line direction alignment, [Chris]
admits to winging it
by rotating the part in the slicer until the layer lines are oriented just right. People
have been experimenting with this
for some time now, and tricks like these are always a welcome addition to our toolkits. You might be wondering – what kinds of projects are such hinges useful for?
The example Chris provides is a Eurorack rail segment — due to the kind of overhangs required, you’d be inclined to print it vertically, taking a hit to the print time and introducing structural weaknesses. With this trick, you absolutely don’t have to! You can also go way further and 3D print a single-piece foldable
Raspberry Pi Zero case
, available
on Printables,
with only two extra endcaps somewhat required to hold it together.
Foldable 3D prints aren’t new, though we typically see them done with
print-in-place hinges
that are technically separate pieces. This trick is a radical solution to avoiding supports and any piece separation altogether. In laser cutting, we’ve known about similar techniques for a while, called a
“living hinge”
, but we generally haven’t extended this technique into 3D printing, save for a few
manufacturing-grade techniques
. Hinges like these aren’t generally meant to bend many times before they break. It’s possible to work around that, too — last time we talked about this, it was an
extensive journey that combined plastic and fabric
to produce incredibly small 3D printed robots!
We thank [Chaos] for sharing this with us! | 38 | 11 | [
{
"comment_id": "6466969",
"author": "ConsultingJoe",
"timestamp": "2022-05-01T15:16:03",
"content": "That’s neat!",
"parent_id": null,
"depth": 1,
"replies": [
{
"comment_id": "6467005",
"author": "Olivier",
"timestamp": "2022-05-01T18:12:15",
"cont... | 1,760,372,707.706597 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.