Here’s some interesting hardware for you: Sharp came out with a very cool series of LCD displays, gong by the name Sharp Memory LCD. Not only are these displays very low power – on the order of about 5 microAmps to keep the display alive – but some of the smaller displays are reflective, making them eminently readable even in daylight. [Mike] decided he’d take a look at these displays and liked what he found.
While these displays are still pretty new, there are a few breakout boards available to make them accessible to desktop tinkerers. The folks at MakerDyne have a breakout board available and there’s one by kuzyatech over on Tindie.
While these displays are readable in daylight and are extremely low power, don’t expect to display LCD video on them anytime soon. The refresh rate is still fairly slow, but you might be able to get away with simple animations with interlacing and so forth. Still, outside of eink, you’re not going to find a better display in terms of power consumption and daylight readability.
Continue reading “Working with very cool LCD modules from Sharp”
In industrial applications, controlling relays, servos, solenoids, and the like isn’t just a matter of wiring in an Arduino and plugging in some code. No, for reliable operation you’ll need a PLC – a programmable logic controller – to automate all your hardware. PLCs are usually pretty expensive pieces of hardware, which led [Warwick] to come up with his own. He built two versions, one large and one small that can handle just about any task thrown at them.
Both devices are powered by an ATMEL SAM7S ARM chip running at 48 MHz. The smaller of the two devices has 10 digital inputs, 4 analog inputs, and 8 digital outputs able to sink 200 mA each. The larger PLC has 22 digital ins, 6 analog ins, and 16 digital outputs. Both of these devices have a ton of connectivity with USB, RS-232 and RS-485 ports
Below you can see the large PLC being used as a barcode scanner and as a strange device using compressed air to levitate a ping-pong ball. There’s also a demo of the smaller PLC lighting up some LEDs.
Continue reading “Open source PLC”
Regular Hackaday readers will be familiar with all the cool things you can do with FPGAs; emulating old video game consoles, cracking encryption protocols, and DIY logic analyzers become relatively simple projects with even a modest FPGA dev board on your workbench. Many FPGA boards aren’t geared towards prototyping, though, and breadboard friendly devices are hard to come by. Here’s a pair of breadboardable FPGAs we’ve found while searching for some related hardware over the past few days
First up is the Mercury FPGA Module. Packaged in a DIP-64 format, the Mercury features a Spartan-3A FPGA with the equivalent of 200k logic gates. Elsewhere on the board is 512kB of RAM and 128kB of Flash storage. There are enough GPIO pins for nearly any project, but sadly only a 10-bit ADC – the same resolution you’d find in an AVR or PIC ‘micro.
Of course the Mercury isn’t the only breadboard-friendly FPGA dev board out there. There’s also the slightly more capable XuLA2 board powered by a Spartan-6 with 32 MB of RAM, 1MB of Flash. Unlike the Mercury, the XuLA2 can also fit in one of those ‘half-sized’ solderless breadboards.
Yes, it’s a different form factor than the commonly recommended Papilio One or the DE0. If you can suggest any other ‘beginners’ (i.e. doesn’t cost an arm and a leg) FPGA boards, leave a note in the comments and we’ll summarize them in another post.
Although it’s not the best way of understanding computers, most people tend to imagine electronic devices as black boxes filled with magic and blue smoke. Even microcontrollers, the most fundamental means of computation, are treated like little black plastic centipedes with metal legs. In a series of blog posts, [Andrew Gibiansky] is tearing down the walls of obfuscation and illuminating the world of transistors, gates, and FPGAs.
The first blog post goes over the idea of electronic circuits as a waterfall; a positive voltage is a reservoir on a mountain top and ground is sea level. This idea is extended to the lowly transistor acting as an electronic switch, able to turn a circuit on and off.
Continuing on to logic gates, [Andrew] covers the NOT, AND, and OR gates before moving on the flip-flops and SRAM. These can, of course, be modeled in Verilog and VHDL – programming languages that abstract the world of transistors and gates into a much more human-readable form.
[Andrew] is far from done with his series of blog posts, but judging from his work so far it seems to be a great resource for untangling the obtuse concepts of gates and memory into the coherent design of a computer.
[Henrik] has been working on a program to design electronic circuits using evolutionary algorithms. It’s still very much a work in progress, but he’s gotten to the point of generating a decent BJT inverter after 78 generations (9 minutes of compute time), as shown in the .gif above.
To evolve these circuits, [Henrik] told a SPICE simulation to generate an inverter with a 5V power supply, 2N3904 and 2N3906 transistors, and whatever resistors were needed. The first dozen or so generations didn’t actually do anything, but after 2000 generations the algorithm produced a circuit nearly identical to the description of a CMOS inverter you’d find in a circuit textbook.
Using evolution to guide electronic design is nothing new; an evolutionary algorithm and a a few bits of Verilog can turn an FPGA into a chip that can tell the difference between a 1kHz and 10kHz tone with extremely minimal hardware requirements. There’s also some very, very strange stuff that happened in this experiment; the evolutionary algorithm utilized things that are impossible for a human to program and relies on magnetic flux and quantum weirdness inside the FPGA.
[Henrik] says his algorithm didn’t test for how much current goes through the transistors, so implementing this circuit outside of a simulation will destroy the transistors and emit a puff of blue smoke. If you’d like design your own circuits using evolution, [Henrik] put all the code in a git for your perusal. It’s damn cool as it stands now, and once [Henrik] includes checking current and voltage in each component his project may actually be useful.
Hey, it’s a hardware twofer! Here’s two platforms coming down the pipe:
First up is the Mimo Dreamplug, the latest in a continued expansion of choices for very tiny, single-board Linux computers. The Dreamplug should be extremely capable of just about any task you can throw at it. With a 1.2GHz Marvell Sheeva CPU, eSATA, fiber optic/TOSLINK, WiFi, Bluetooth, two Gigabit Ethernet connections, and 512 MB of RAM, we’re thinking this could be used for just about anything. It’s a little pricy at $250, but that’s what you pay for all those features.
No idea when it will be available, though. Never mind, you can get the same thing for $150 here. Thanks, [Scott].
Next up is the Kinetis KL25Z Freedom Board, an Arduino-compatable, Cortex-M0+ based dev board being made available for pre-order. The specs on this machine seem pretty good – with a 48MHz ARM chip, on-board accelerometer, a capacitive touch ‘slider’ built into the PCB, and OpenSDA for a USB debug interface, you should be able to make a few cool projects with this board. As a neat bonus, it costs $13, and Freescale is giving away a version of their Codewarrior development environment (limited to 128kB, but that’s all the Flash the Kinetis has). Hopefully, it’ll be a much more open development platform than what our own [Mike Szczys] has been able to wrangle from the STM32 board that has been floating around. The Kinetis should be available this fall.
Thanks [Impulse405] and [Hussam] for sending these tips in.
Instructables user [trumpkin] recently built an all-hardware based keypad lock for a contest he was entering, and we thought it was pretty neat. The lock uses mostly NAND gates and 555 timers to get the job done, which makes it a nice alternative to similar software-based projects we have seen in the past.
The lock has 6 keys on the keypad, which is connected to the main logic board. The keycode is set using a series of headers at the bottom of the board, and you get 10 chances to enter the proper code before the board locks up completely. If this occurs, a “manual” reset via a button built into the main board is required before any more attempts can be made.
As you can see in the video below, the lock works quite well, but suffers from one shortcoming. Any permutation of the key code can be used to deactivate the lock, which is something [trumpkin] says he would like to improve in the future.
If you are looking for some more security-related reading, be sure to check out these other hacks we have featured in the past.
Continue reading “Hardware-based security keypad keeps it simple”