96 MacBook Pros: Most Expensive Server Rack We’ve Ever Seen

Ever see a standard server rack stuffed full with 8-dozen MacBook Pros? Well now you have.

Now before the torrential downpour of anti-Mac comments come, this actually has a purpose. No seriously. Besides, what company in their right mind would spend that much money on a rack full of paperweights? Kidding.

[Steve] works for a company that designs electronics, and for a particular launch they needed to perform a lot of testing — using MacBook Pros. There are ways he could have emulated OS X on a much cheaper hardware setup, but the whole point was to test the product with Apple hardware. So he took a stroll down to the local Apple store and picked up two pallets worth. Continue reading “96 MacBook Pros: Most Expensive Server Rack We’ve Ever Seen”

Embed with Elliot: There is no Arduino “Language”

This installment of Embed with Elliot begins with a crazy rant. If you want to read the next couple of paragraphs out loud to yourself with something like an American-accented Dave-Jones-of-EEVBlog whine, it probably won’t hurt. Because, for all the good Arduino has done for the Hackaday audience, there’s two aspects that really get our goat.

(Rant-mode on!)

First off is the “sketch” thing. Listen up, Arduino people, you’re not writing “sketches”! It’s code. You’re not sketching, you’re coding, even if you’re an artist. If you continue to call C++ code a “sketch”, we get to refer to our next watercolor sloppings as “writing buggy COBOL”.

And you’re not writing “in Arduino”. You’re writing in C/C++, using a library of functions with a fairly consistent API. There is no “Arduino language” and your “.ino” files are three lines away from being standard C++. And this obfuscation hurts you as an Arduino user and artificially blocks your progress into a “real” programmer.

(End of rant.)

Let’s take that second rant a little bit seriously and dig into the Arduino libraries to see if it’s Arduinos all the way down, or if there’s terra firma just beneath. If you started out with Arduino and you’re looking for the next steps to take to push your programming chops forward, this is a gentle way to break out of the Arduino confines. Or maybe just to peek inside the black box.

Continue reading “Embed with Elliot: There is no Arduino “Language””

Open Source FPGA Toolchain Builds CPU

When you develop software, you need some kind of toolchain. For example, to develop for an ARM processor, you need a suitable C compiler, a linker, a library, and a programmer. FPGAs use a similar set of tools. However, instead of converting source code to machine language, these tools map the intent of your source code into configuration of FPGA elements and the connections between them.

There’s some variation, but the basic flow in an FPGA build is to use a synthesizer to convert Verilog or VHDL to a physical design. Then a mapper maps that design to the physical elements available on a particular FPGA. Finally, a place and route step determines how to put those elements in a way that they can be interconnected. The final step is to generate a bitstream the chip understands and somehow loading it to the chip (usually via JTAG or by programming a chip or an external EEPROM).

One problem with making your own tools is that the manufacturers typically hold the bitstream format and other essential details close to their chest. Of course, anything can be reverse engineered (with difficulty) and [James Bowman] was able to build a minimal CPU using  an open source Lattice toolchain. The project relies on several open source projects, including  IceStorm, which provides configuration tools for Lattice iCE40 FPGAs (there is a very inexpensive development platform available for this device).

We’ve covered IceStorm before. The IceStorm project provides three tools: one to produce the chip’s binary format from an ASCII representation (and the reverse conversion), a programmer for the iCEstick and HX8K development boards, and database that tells other open source tools about the device.

Those tools blend with other open source tools to form a complete toolchain–a great example of open source collaboration. Yosys does the synthesis (one of the tools available on the EDAPlayground site). The place and route is done by Arachne. The combined tools are now sufficient to build the J1A CPU and can even run a simple version of Forth. If you’ve ever wanted to play with an FPGA-based CPU design, you now have a $22 hardware option and free tools.

Continue reading “Open Source FPGA Toolchain Builds CPU”

CommVEx 2015: What Happens When Commodore Users Gather

I’m not getting any younger, in fact I’m getting older by the day.  This fact along with the fact that this year is the 30th anniversary of the Commodore C-128 and the original Commodore Amiga prompted me to attend this year’s CommVEx in Las Vegas lest I not be around for the next significant anniversary. For those that don’t know me, I designed the C-128 at the ripe old age of 25 back in 1984-85, though I would ask that you not hold that against me as it was a very long time ago.

Also this year Dr. Leonard Tramiel, son of Commodore’s founder Jack Tramiel, was able to swing by which was an unprecedented and unforgettable event.

Continue reading “CommVEx 2015: What Happens When Commodore Users Gather”

3D Mouse Drives Robot Arm

You’ve built the perfect robotic arm. How do you drive it? If you are [angrymop] you interface a 3D mouse from 3DConnexion via a few microcontroller boards. The Spacenavigator mouse is a staple anywhere professional CAD people are working, and it looks like it is a natural fit for a robot arm.

According to [angrymop], the Raspberry Pi can read the mouse’s commands via /dev/hidraw (that’s the raw human interface device). Each motion generates two lines of output. Each line has a unique identifying byte and values corresponding to the axis positions.

The Raspberry Pi then uses an SPI interface to talk to an ARM microcontroller and that drives the servos. The arm (the robot arm, not the processor) itself is well done, made from Lego Technic parts and common RC servos. Not that this is the most amazing thing we’ve ever seen built from Technic, but it is still pretty impressive.

You have to wonder if other 3D controllers might be useful for controlling robot arms or how the Spacenavigator would do controlling a bigger, more capable arm. Then again, maybe this arm would be the right size to build something inspired by Escher.

Continue reading “3D Mouse Drives Robot Arm”

Hackaday Prize Worldwide : New Delhi Kicad + Show and Tell

While Mumbai and Bengaluru have an active and large hacker community, New Delhi, India’s capital, seems to have leapfrogged ahead when it comes to hackerspaces – four at last count. So when the latest one in town, Maker’s Asylum, opened it’s doors last month, we decided to put together a hacker congregation to bring the community together and introduce them to the Hackaday Prize. Having already done Hackaday Prize bring-a-hack events in Mumbai and Bengaluru, we thought of doing something more substantial – a day long KiCad EDA workshop followed in the evening by a Show-n-Tell brag show.

Hackaday’s [Matt Berggren a.k.a. @technolomaniac] has done a couple of “Design a PCB from zero to WiFi with Hackaday!” Eagle EDA workshops recently. He designed a simple breakout board that allowed connecting an ESP-01 module to the USB port via an USB-UART cable with level conversion, pull up resistors and push button switches to make it easy to program. We had a slightly delayed start, so I quickly rushed through the awesome presentation that [Matt] has prepared, running through the “What is a PCB?” section and skipping the rest. We also discussed a couple of candidate designs for the day’s workshop – a pair of ATtiny line following robots, a simple Attiny SmartLED controller, but eventually, everyone got excited when I mentioned “ESP-8266″ !

Continue reading “Hackaday Prize Worldwide : New Delhi Kicad + Show and Tell”

Hackaday Prize Entry: Wearable Robotics Toolkit

The Internet overflows with prosthetics projects, and to a large extent this is somewhat understandable. Prosthetic devices are ultimately a custom made for each user, and 3D printers are trying to find a purpose. Put two and two together, and you’re going to get a few plastic limbs.

The electronics required for advanced prosthetics are a bit harder than a 3D scanner and a printer. If you’re designing a robotic leg, you will need to pump several hundred watts through an actuator to move a human forward. For the last few years, [Jean-François Duval] has been working on this problem at the MIT Media Lab Biomechatronics group and has come up with his entry for the Hackaday Prize. It’s a motor and motor control system for wearable robotics that addresses the problems no other project has thought of yet.

The goal of the FlexSEA isn’t to build prosthetics and wearable robotics – the goal is to build the electronics that drive these wearables. This means doing everything from driving motors, regulating power consumption, running control loops, and communicating with sensors. To accomplish this, [Jean-François] is using the BeagleBone Black, a Cypress PSoC, and an STM32F4, all very capable bits of hardware.

So far, [Jean-François] has documented the hardware and the software for the current controller, and has a few demo videos of his hardware in action. You can check that out below.

Continue reading “Hackaday Prize Entry: Wearable Robotics Toolkit”