Sometimes when browsing the websites of our global hackspace community you notice a project that’s attractive not necessarily because of what it does or its technology but because of its presentation. So it is with the subject of this article, [Kris] needed a house temperature monitor and found a 1960s slide viewer made an excellent choice for its housing.
The monitor itself is a fairly straightforward Arduino build using a couple of DS18B20 1-wire temperature sensors and a real-time-clock module and displaying their readings on a small OLED screen. Its code can be found on this mailing list thread if you are interested. The display presented a problem as it needed to be reasonably large, yet fairly dim so it could be read at night without being bright enough to interrupt sleep.
A variety of projection techniques were tried, involving lenses from a projection clock, a magnifying glass, and a Google Cardboard clone. Sadly none of these lenses had the required focal length. Eventually the slide viewer was chosen because it was pointed out that the OLED screen was about the same size as a photographic slide.
Slide viewers are part of the familiar ephemera of the analog era that most people over 60 may still have taking up drawer space somewhere but may well be completely alien to anyone under about 30. They were a magnification system packaged up into a console usually styled to look something like a small portable TV of the day, and different models had built-in battery lights, or collected ambient light with a mirror. The screen was usually a large rectangular lens about 100mm(4″) diagonal.
[Kris]’s Vistarama slide viewer came via eBay. It’s not the smallest of viewers, other models folded their light paths with mirrors, however the extra space meant that the Arduino fit easily. The OLED was placed where the slide would go, and its display appeared at just the right magnification and brightness. Job done, and looking rather stylish!
[Great Scott] should win an award for quickest explanation of a buck converter. Clocking in at five and a half minutes, the video clearly shows the operating principles behind the device.
It starts off with the question, what should you do if you want to drop a voltage? Many of us know that we can dim and brighten an LED using the PWM on an Arduino, but a closer inspection with an oscilloscope still shows 5V peaks that would be dangerous to a 3.3V circuit. He then adds an inductor and diode, this keeps the current from dropping too fast, but the PWM just isn’t switching fast enough to keep the coil energized.
A small modification to the Arduino’s code, and the PWM frequency is now in the kHz range. The voltage looks pretty good on the oscilloscope, but a filter cap gets it to look nice and smooth. Lastly, he shows how when the load changes the voltage out looks different. To fix this a voltage divider feeds back the information to the Arduino, letting it change the PWM duty to match the load.
In the last minute of the video he shows how to hook up off-the-shelf switching regulators, whose support components are now completely demystified as the basic principles are understood. Video after the break.
[Daniel Perdomo] and two of his friends have been working on a mechanical version of Pong for the past two years. We can safely say that the final result is beautiful. It’s quite ethereal to watch the pixe–cube move back and forth on the surface.
[Daniel] has worked in computer graphics for advertising for more than 20 years. However, he notes that neither he nor his friends had any experience in mechanics or electronics when they began. Thankfully, the internet (and, presumably, sites like Hackaday) provided them with the information needed.
The pong paddles and and pixel (ball?) sit onto of a glass surface. The moving parts are constrained to the mechanics with magnets. Underneath is a construction not unlike an Etch A Sketch for moving the ball while the paddles are just on a rail with a belt. The whole assembly is made from V-groove extrusion.
Our favorite part of the build is the scroll wheel for moving the paddle back and forth. For a nice smooth movement with some mass behind it, what’s better than a hard-drive platter? They printed out an encoder wheel pattern and glued it to the surface. The electronics are all hand-made. The brains appear to be some of the larger Arduinos. The 8-bit segments, rainbow LEDs, etc were build using strips glued in place with what looks like copper foil tape connecting buses. This is definitely a labor of love.
It really must be seen to be understood. The movement is smooth, and our brains almost want to remove a dimension when watching it. As for the next steps? They are hoping to spin it up into an arcade machine business, and are looking for people with money and experience to help them take it from a one-off prototype to a product. Video after the break.
Hacking has always brought more good to the world than not hacking. The successful efforts of the Allies during World War II in deciphering the Enigma machine output still reminds us of that. Today, the machine is a classic example of cryptography and bare-metal computing.
With its wooden enclosure, keyboard, interchangeable rotors, and plugboard, his build resembles an original Worldwar II enigma machine down to the letter. However, when looking closer, you’ll find that the rotors are implemented as electronic modules that plug into D-Sub sockets on the machine. Also, there is a 16 segment display that displays the rotor position as well as an LCD screen that lets you comfortably read the plain- and ciphertext. On the inside, you’ll find an Arduino Mega along with 1,800 other parts and 500 wires, and of course, this modern version has a backspace key.
It took [Andy] over 9 months to put all this together, and he now finds himself among the winners of the State Science & Engineering Fair (SSEF), who will be sent to Intel as representatives of their states. Given his experience in field-capable computing, we’re sure [Andy] can help Intel reconquering mobile. Enjoy the video!
A major limitation they wanted to overcome was screen size. A projector mounted to the ceiling should turn the entire wall behind the machine into a massive 15-foot playfield for anyone in the room to enjoy.
With so much space to fill, the team assembled a visual concept tailored to blend seamlessly with the original storyline of the arcade classic, studying the machine’s artwork and digging deep into the sci-fi archives. They then translated their ideas into 3D graphics utilizing Cinema4D and WebGL along with the usual designer’s toolbox. Lasers and explosions were added, ready to be triggered by game interactions on the machine.
To hook the augmentation into the pinball machine’s own game progress, they elaborated an elegant solution, incorporating OpenCV and OCR, to read all five of the machine’s 7 segment displays from a single webcam. An Arduino inside the machine taps into the numerous mechanical switches and indicator lamps, keeping a Node.js server updated about pressed buttons, hits, the “Lange Change” and plunged balls.
The result is the impressive demonstration of both passion and skill you can see in the video below. We really like the custom shader effects. How could we ever play pinball without them?
[JAC_101], the Director of Legal Evil Emeritus for LVL1 Hackerspace (don’t ask me, it’s their title system), was challenged to a hacking duel. It all started years ago. The person who is now president of LVL1, visited the space for the first time and brought with her a discarded Apple II controller for Lego bricks which had previously belonged to her father. Excited to test it, the space found that, unfortunately, LVL1’s Apple II wouldn’t boot. An argument ensued, probably some trash talking, and [JAC_101] left with the challenge: Could he build an Arduino interface for the Apple II Lego controller quicker than the hackerspace could fix its Apple II?”
In the end, a concentrated force by one hacker over two years overcame the collective ADHD of many. He began by opening the interface to look inside, a completely unnecessary step since he found it was already thoroughly documented. Next he forgot about the project for a year. Then he remembered it, and built an interface for an Arduino Uno to hook to the controller and wrote a library for the interface. Realizing that sending serial commands was not in line with the original friendly intention of the device, he added a graphical display to the project; which allowed the user to control the panel with touch. In the end he won the challenge and LVL1 still doesn’t have a working Apple II. We assume some gloating occurred. Some videos of it in action after the break.
Over on hackaday.io, [Arduino Enigma] posted the code for his clock that runs on a KIM Uno (the KIM-1 clone we mentioned late last year). Although the KIM Uno has a few demos preloaded (including Microchess and a scientific calculator), all of them take some interaction. The clock makes the KIM Uno a more dynamic desk display since it does something useful without any user interaction (once you set the clock, of course).
The project shows the code stored in ROM, but you can’t directly enter the program into ROM (which is really EEPROM on the host Arduino). The trick is to enter the address (that is press AD and then 0, 4, 0, 0) and then mash down the reset button for about a second. Then you can press DA and enter the hex codes provided (pressing + after each byte). Since the code is in nonvolatile storage, you can start it at any time by setting the time in RAM and executing the code at address 400.
The program is short and sweet, making it is easy to enter and a great opportunity to brush up on understanding your 6502. However, the simplicity means it doesn’t range check your initial time settings, so don’t tell it that it is 32:99 or something like that. The code isn’t commented, but it is pretty simple, once you realize one thing: the first instruction, SED, sets the 6502’s decimal mode so no conversion between hex and decimal is needed.
Each part of the time (hours, minutes, and seconds) is stored in RAM at locations 0024, 0025, and 0026. The NEXTD routine uses the X register to scan through each part of the time, adding 1 or 0 as appropriate (stored in RAM location 0029). If the time part matches the corresponding table entry at CARRYT (that is, 60, 60, or 24 also indexed by the X register), then the code does not take the branch to CONTIN and reloads the increment (location 0029) with zero, so the next digits will not advance. If it does match, the increment stays as 1 and the current part returns to a zero value.
You may notice the time is stored back to locations starting at 0024 and 00F9. That’s because 00F9 is where the KIM-1 ROM looks for data to write to the display when calling the ROM-resident subroutine at 1F1F. The X register ranges from 0 to 2, corresponding to the seconds, minutes, and hours. Once all the time is updated, the loop at L1 displays the time and delays for about one second.
A neat piece of coding and a great example of the power of the 6502’s decimal mode. This would look even better with [Scott’s] enhanced version of the KIM-1 UNO.
Microcontrollers existed before the Arduino, and a device that anyone could program and blink an LED existed before the first Maker Faire. This might come as a surprise to some, but for others PICs and 68HC11s will remain as the first popular microcontrollers, found in everything from toys to microwave ovens.
Arduino can’t even claim its prominence as the first user-friendly microcontroller development board. This title goes to the humble Basic Stamp, a four-component board that was introduced in the early 1990s. I recently managed to get my hands on an original Basic Stamp kit. This is the teardown and introduction to the first user friendly microcontroller development boards. Consider it a walk down memory lane, showing us how far the hobbyist electronics market has come in the past twenty year, and also an insight in how far we have left to go.
The Basic Stamp kit on my workbench was made in 1993, and sold for a suggested retail price of $139 USD. Adjusted for inflation, this is nearly $230 in 2015 dollars. What do you get in the Basic Stamp starter kit? A single stamp, a programmer cable, and a surprising amount of documentation.
The Basic Stamp is an extremely minimalist board that does just enough to blink an LED, read a button, or drive an LCD. In the official documentation, there are only a handful of parts: a microcontroller, an EEPROM with a few bytes of memory, a crystal, and a voltage regulator.
The PIC16C56XL is the brains of the outfit, featuring 1.5kilobits of Flash memory and 25 bytes of RAM. By modern standards, it’s tiny; the closest modern analog would be the ATtiny10, itself not a very recent chip. Microchip’s smallest and newest chip is the PIC12LF1522, featuring twice as much Flash and ten times the amount of RAM. We’re dealing with an old microcontroller when using the Basic Stamp
Other components include a 93LC56 serial EEPROM. beside that is a 4MHz regulator, a 5V linear regulator, and a transistor and a few resistors for the ‘brown out’ circuit. Power is provided by a 9V battery connector soldered onto the board.
The electronic design of the Basic Stamp is simple, yes, but there’s a method to the madness. The code you write for the Basic Stamp is stored in 256 bytes of the EEPROM. This code is read by a PBASIC interpreter on the PIC, dutifully following commands to blink a LED or display a character on an LCD. No user code is actually stored on the microcontroller.
How about the programming environment? That’s a single executable running in a DOS shell. The system requirements are only, an IBM PC or compatible, DOS 2.0+, 128k of RAM, and a disk drive. Meager requirements, but this is not something that will run on your modern Windows workstation; it requires a proper parallel port.
For an IDE, the Basic Stamp editor is comparable to earlier Arduino IDEs; Alt+R runs the program on the Stamp connected to the computer, Alt+L loads a program, Alt+S saves a program, and Alt+Q quits the editor.
The BASIC language implemented on the PIC is minimal, but it does everything you would expect; individual pins can be set as input and output, buttons are debounced, and PWM functions are baked into the language.
The Basic Stamp is now regarded as a slow, inconvenient artifact from the past. No one uses it, and the only place you’ll find one is in the back cabinet in a physics or EE classroom. This is an incredible disservice to a still-impressive piece of technology, and looking back at the Basic Stamp with our modern expectations is an incredible bias.
There were microcontroller development platforms before the Basic Stamp, but these were engineering tools, and expensive compared to the Stamp. Development platforms for the electrical hobbyist were around after the stamp, too: the Micromint Domino packed an entire development platform into a rectangular brick of plastic. None of these designs could match the popularity of the Basic Stamp despite the platform’s shortcomings.
The Arduino receives a lot of hate. Detractors say it’s too high-level for proper embedded programming, not high-level enough for a modern workflow, is based on old, obsolete chips, doesn’t have the features of modern ARM microcontrollers, and the IDE is a mess. Despite an even less capable IDE, meager memory, and a slow processor, the Basic Stamp proved incredibly popular. The fact that you could pick up a Basic Stamp development kit at any Radio Shack probably didn’t hurt it’s popularity, either.
Now, with our fancy IDEs, mbed microcontrollers, powerful ARMs, and huge libraries, the ease of use of the Basic Stamp has still not been equaled. It may be slow, outdated, but all of us owe a great debt to the Basic Stamp for introducing an entire generation to the world of embedded programming, microcontrollers, and electronics tinkering.
We’ve seen a growing number of posts and recommendations around the net regarding components, specifically transistors. “Don’t use old parts” they cry, “Go with newer components.” You can often find these recommendations on Arduino forums. This all came to a head with a page called “Do Not TIP,” which was linked in the Arduino subreddit. This page belongs to [Tom Jennings], creator of Fidonet, and one of the early authors of what would become Phoenix BIOS. [Tom] and a few others have been calling for everyone to send their old parts to the landfill – not use them, nor gift them to new experimenters. Get them out of the food chain. No offense to [Tom], but we have to disagree. These parts are still perfectly usable for experienced designers, and have a lot to offer new hardware hackers.
TIP is the part number prefix for a series of power transistors created by Texas Instruments. In fact, “TIP” stands for Texas Instruments Power. The series was originally released in 1969. Yes, that’s right, 1969. Why are we still using parts designed when man first walked on the moon? The same reason people are still using the 555 timer: they’re simple, they’re easily available, they’re robust, and most of all, they get the job done. The TIP series has been used in thousands of classes, tutorials both online and off, and millions of projects over the years. Much of that documentation is already out there on the internet. The TIP series is also out in the distribution channel – they’ve been used for 40 years. Any retail shop that stocks a few electronics parts will have at least one of the TIP series.
The TIP series aren’t always the best transistors for the job. However, for most hobbyist-designed circuits, we don’t need the best performance, nor the best price – we’re going to use the parts we have on hand. There is always room to improve once you get the basic circuit working.
In [Tom’s] specific example, he’s using a TIP120 to control a motor at 5 volts drawing 1 amp of current. [Tom’s] big problem with the TIP120 is that it’s inefficient when running the motor. That’s because the TIP120 isn’t a transistor. It’s two transistors configured as a Darlington pair. Like everything else in life, Darlington pairs have trade offs. To achieve high gain, you end up with higher voltage drop. In high current designs, that translates into heat. In this case, 2 watts of heat, which [Tom] claims will result in melted parts and fire. It turns out that the datasheet shows 2 watts is the upper limit for thermal dissipation on the TIP120’s TO-220 case. It will get very hot, but it will not catch fire. Want to be on the safe side? Add a heatsink, which is as easy as attaching a piece of metal using the convenient screw hole in the TO-220 case.
Just for fun, we created our own version of [Tom’s] example. We connected a TIP120 to a 12V lab supply. Rather than connect a motor, we grabbed our Re:Load Pro and set it for 1 amp. We use a 680 ohm base resistor to ensure the TIP120 was in saturation. The Re:Load Pro indicated that it was indeed seeing 1 amp of current flow, at 10.9 volts. This means that the TIP120 was only dropping 1.1V, rather than the 2V quoted on the datasheet. Were we just lucky? We tried a few TIP120s we had around the lab from a couple of manufacturers, and all of them were pretty close – well below the worst case 2V. Obviously you can’t design beyond the specs called on in the datasheet, but sometimes things work out in your favor. With the current set to 1 amp, the math is easy. The Re:Load Pro was converting 10.9 watts of power to heat. The TIP120 was dissipating 1.1 watts. The TIP120 did get hot – we measured up to 60°C. But it never went beyond that. A heatsink would have cooled things down, but we were shooting for worst case scenario. We ran this setup for 2 hours and there was no smoke, fire, or failure.
Can you do better with a different part? Absolutely. [Tom] suggests a MOSFET such as the NTD4906N. FETs are great, we use them all the time. However, they come with a completely different set of rules and pitfalls compared to BJTs. Learning the rules, the design trade offs and pitfalls of both families of devices are key factors when learning electronics design. Every component a designer learns is a new color on their design palette. On the code side we worry about people becoming “cut and paste” coders. The same thing happens on the hardware side when a designer doesn’t learn how to use different types of parts.
So don’t throw away your old parts. Use them, learn from them, and become a better designer for it!
[Chris Gregg] had a dream. He wanted to convert use a typewriter as a printer. Sure this has been done before, but [Chris] wanted to create his own version. He picked up a 60’s era Smith Corona electric typewriter, with the hopes of driving its key switches with a computer. You can imagine his surprise when he discovered the keys were not electric switches at all, but a complex mechanical system which triggered a clutch to strike the actual paper. Realizing this was not going to be a simple wiring job, [Chris] set the project aside, where it remained for several years.
A conversation with [Bruce Molay], a coworker at Tufts University reignited [Chris’] interest in project. [Bruce] suggested using solenoids to press the keys. [Chris] dove in, and quickly had 48 solenoids on hand. The first problem was mounting the solenoids on the keys. [Chris’] roommate happens to be [Derek Seabury], president of Artisan’s Asylum Hackerspace. [Derek] created an acrylic frame which holds the solenoids and fits directly over the typewriter’s keyboard. This meant that no modifications needed to be made to the typewriter itself. Simply lift off the solenoid array and you’re ready to rock like it’s 1965.
The next step was driving all those solenoids. For that, Chris worked with [Kate Wasynczuk], one of his students at Tufts. [Chris] designed a board using Texas Instruments TPIC6A595 shift registers. The TIPC “power logic” series work like regular 74 series logic, but have seriously beefy outputs. These chips can handle up to 50 volts and 1.5 amps pulsed output current – plenty for [Chris’] 24 volt solenoids. [Chris] taught himself schematic entry and PCB layout in Eagle. After only two tries, he had a working board from OSHPark.
An Arduino Uno converts serial over USB output to a bit stream ready to clock into the shift registers. On the computer side, [Chris] wrote up a basic CUPS driver which allows him to print from his Macbook. The perfect demo for this project turned out to be musical. Click past the break to see The Smith Corona perform “The Typewriter Symphony”, by Leroy Anderson. This may be the first time this particular piece of music has been performed with actual words being typed, rather than random keys.
Here’s a classic version of “The Typewriter Symphony”