[S.PiC] has been working on a computer case styled to look like the Vulture mech from Battletech. We’re not sure if his serious faced cat approves or not, but we do.

The case is made from artfully cut plywood. We kind of hope he keeps the wood aesthetic. However, that would be getting dangerously close to steampunk. So perhaps a matching paint job at the end will do. In some of the videos we can how he’s cleverly incorporated the computer’s components into the design of the case. For example, the black mesh on the front actually hides the computer’s power supply intake fan.

The computer inside is a small micro-itx formfactor one. Added as peripherals to it [S.Pic] has pulled out the hacker-electronics-tricks bible. From hand soldered LED grids to repurposed Nokia LCD screens, he has it all. In one video we can even see the turret of the mech rotating under its own power.

It looks like the build still has a few more steps before completion, but it’s already impressive enough to be gladly worth the useful table space consumed on any hacker’s desk. Video after the break.

[Derryn Harvie] from the MakeHackVoid maker space hacked a $10 IR Thermometer and made it talk USB. Sounds easy? Read on.

He opened it up in the hope of finding, and tapping into, a serial bus. But he couldn’t find one, and the main controller was a COB blob – hidden under unmarked black epoxy. Normally this is a dead-end.  (We’ve seen some interesting approaches to decapping epoxy blobs, and even ICs with lasers.)

But [Derryn] went his own way – intercepting the data going from the micro-controller to the LCD display, and reverse engineering it using another microcontroller. He scraped off the solder mask over the tracks leading to the LCD display, and used an oscilloscope to identify the common drive lines. He then used a function generator to excite each of the LCD common lines and the segments lines to build a complete matrix identifying all the combinations that drove the segments. With all the information decoded, wires were soldered so he could hook up an Arduino, and the cut tracks repaired.

Since the LCD was a multiplexed display, the bias voltages were at four levels. Luckily, he could extract most of the LCD information by reading just eight of the segment drive lines, using up all of the analog inputs on the Arduino. Perhaps a different microcontroller with more ADC inputs would have allowed him to display more LCD functions. Well, he can always upgrade his upgrade later. If you have a similar hack to implement, then [Derryn]’s code could be useful to get started.

Thanks, [csirac2] for sending us this tip from MakeHackVoid.

There are cheap LCDs available from China, and when plugged into an Arduino, these displays serve as useful interfaces or even shinier baubles for your latest project. [Michael] picked up a few of these displays in the hope of putting a few animated .GIFs on them. This is an impossible task with an ATMega microcontroller – the Arduino does not have the RAM or the processing power to play full-screen animations. It is possible to display 3D vector graphics, with an updated graphics library [Michael] wrote.

The display in question uses the ILI9341 LCD driver, found in the Adafruit library, and an optimized 3D graphics driver. Both of these drivers have noticeable flicker when the animation updates, caused by the delay between erasing a previous frame and when a new frame is drawn.

With 16-bit color and a resolution of 320×240 pixels, there simply isn’t enough memory or the processing power on an ATMega microcontroller to render anything in the time it takes to display a single frame. There isn’t enough memory to render off-screen, either. To solve this problem, [Michael] built his render library to only render pixels that are different from the previous frame.

Rendering in 3D presents its own problems, with convex surfaces that can overlap themselves. To fix this, [Michael]’s library renders objects from front to back – if the pixel doesn’t change, it doesn’t need to be rendered. This automatically handles occlusions.

In a demo application, [Michael]’s LCD and Arduino can display the Stanford bunny, a low-poly 3D face, and geometric object. It’s not a video game yet, but [Michael] thinks he can port the classic game Spectre to this platform and have it run at a decent frame rate.

Video of the demo below.

Julian Hespenheide is an interaction designer based in Germany who submitted to Arduino blogpost a writing machine called émile. It’s an interactive installation created in collaboration with Irena Kukric, David Beermann, Jasna Dimitrovskais and using Baudot code - a binary 5-bit code, predecessor of ASCII and EBCDID – intended for telecommunication and electronic devices, representing the entire alphabet.

It runs on Arduino Uno and  translates the bauds (/?b??d/, unit symbol Bd) into moving objects that are being sent over physical tracks in order to illustrate  a simple computational process of 5-bit binary information transmission:

The machine was built in six days with four people. In our group we came to the conclusion, that not every process in a computer is really transparent and it already starts when you type a simple letter on a keyboard. To unwrap this “black box” of data transmission, we set our goal to build a small writing machine where you can literally see bits rolling around. After some research we got back to the beginnings of Telefax machines and data transmission using Baudot-code. We then quickly designed punchcards and mapped them to a slightly altered baudot code table and cut them with a laser cutter from 5mm plywood.
Whenever a marble hits a switch, a short timer goes off and waits for input on the other switches. If no other marbles are hitting those switches, we finally translate the switches that have been hit into the corresponding letter.

Take a look at the machine in action:

A pretty color LCD screen, an Arduino, a buzzer and a joystick is all you need for a minimalist gaming console for under $20. At least, that’s all [João Vilaça] needed to get this sweet version of Tetris up and running. (He’s working on Breakout right now.)

It’s a testament to the current state of the hardware hacking scene that [João] could put this device together in an afternoon for so cheap, presumably after waiting a while for shipments from China. The 320×240 SPI color TFT LCD screen used to cost twice as much as this whole project did. And wiring it up is a simple matter of connecting this pin to that pin. Almost child’s play.

Equally impressive is the state of open source software. A TFT library from Seeed Studios makes the screen interface a piece of cake. [João] wrote his own sound and joystick code, and of course the Tetris gameplay itself, but it’d be much more than a few weeks’ work without standing on the shoulders of giants. Check out [João]’s Github for the project code and stick with us after the break for a demo video and some of our other favorite Arduino gaming hacks.

Now, we’ve seen a whole lot of Arduino-based gaming platforms around here before, and they range from the simplistic black-and-white to the bells-and-whistles of the Gameduino which tacks an FPGA onto your Arduino to enable sprites, awesome sound, and VGA output. But we’ve also got a place in our hearts for simplicity and comprehensibility, and [João]’s device and code has got those in spades.

If you’re ready to push your Arduino skills beyond blinking LEDs, [João]’s game project should be on your reading / building list. We can’t wait to see Breakout.

Introduction

Using a large TFT LCD with various development boards can often be a trial – from dedicating eight or more GPIO pins to working with a flaky software library or memory limitations. Personally I have thought “there must be a better way”, and thus usually results in shifting the concept over to a single-board computer such as a Raspberry Pi to get the job done.

However this is no longer necessary – thanks to the team at Itead Studio and now available from Tronixlabs. They have developed a series of TFT LCDs which include enough onboard hardware, a graphic processor unit and memory to be a self-contained display solution whose output can be created with a WYSIWYG editor and be controlled using simple serial text commands.

For a quick demonstration, check out the following video:

As you can see the display can be quite complex, and with some imagination you can create a neat interface for your project. And once the interface has been uploaded to the display, all your development board needs to do is communicate with the Nextion displays via a TTL-level USART  (serial port).

Hardware

Nextion displays are available in a wide range from 2.4″ through to 7″ at varying resolutions – with all having a resistive touch screen:

On the rear of an example 4.3″ unit we can see the brains behind the Nextion – an STM32F microcontroller, 16MB of flash memory and a meaty Altera MAXII FPGA. :

… and the 2.4″ version which has 4MB of flash memory:

And as shown above you can see from the images there is a microSD card socket on each display, and the only external connections are 5V and GND plus TX/RX for serial data to your system. For testing purposes with a Windows-based PC you can use a simple USB-TTL serial cable. This could also be used for a more permanent solution between a Raspberry Pi, or any USB-enabled PC.

Software

The display interface is created used an IDE (integrated development environment) which is currently available for Windows. Using the IDE, you can import images for use in the interface, determine touch areas, add  buttons, progress bars, gauges and much more.

Furthermore there is a simulator and debugger tool which allows you to test your interface on the PC or directly to the Nextion unit. The simulator also allows for sending and receiving commands with the display so you can quickly test your code.

The simulator is also a demonstration of how the Nextion can be controlled via USB-TTL serial cable from a PC, thus great for secondary displays via processing, python etc – or from any software that can communicate via the PC’s serial port. And much cheaper than a secondary display if you only want to display certain types of data.

To create an interface is easy, you first start with a background image or a solid colour. Then you can add objects such as buttons for user-input, or define an area of the screen to a “touch-zone” – which, when pressed, will send a value out to the connected device. You can also add text zones, which will display incoming text from the connected device – along with progress bars and gauges.

For an ideal example of all this together, watch the following video:

Conclusion

Although the units I had for test were prototype review units supplied by Itead, they worked as expected and really do solve the problem of creating a contemporary user-interface without typing up microcontroller resources. Nextion displays are now available from our Tronixlabs store.

And finally a plug for my own store – tronixlabs.com – offering a growing range and Australia’s best value for supported hobbyist electronics from adafruit, DFRobot, Freetronics, Seeed Studio and much much more.

As always, have fun and keep checking into tronixstuff.com. Why not follow things on twitter, Google+, subscribe  for email updates or RSS using the links on the right-hand column, or join our forum – dedicated to the projects and related items on this website.

The post Review – Nextion TFT Human Machine Interface appeared first on tronixstuff.

There are plenty of GPS navigation units on the market today, but it’s always fun to build something yourself. That’s what [middelbeek] did with his $25 GPS device. He managed to find a few good deals on electronics components online, including and Arduino Uno, a GPS module, and a TFT display.

In order to get the map images on the device, [middelbeek] has to go through a manual process. First he has to download a GEOTIFF of the area he wants mapped. A GEOTIFF is a metadata standard that allows georeferencing information to be embedded into a TIFF image file.  [middelbeek] then has to convert the GEOTIFF into an 8-bit BMP image file. The BMP images get stored on an SD card along with a .dat file that describes the boundaries of each BMP. The .dat file was also manually created.

The Arduino loads this data and displays the correct map onto the 320×240 TFT display. [middelbeek] explains on his github page that he is currently unable to display data from two map files at once, which can lead to problems when the position moves to the edge of the map. We suspect that with some more work and tuning this system could be improved and made easier to use, of course for under $25 you can’t expect too much.

Now that the Apple wristwatch is on its way, some people are clamoring with excitement and anticipation. Rather than wait around for the commercial product, Instructables user [Aleator777] decided to build his own wearable Apple watch. His is a bit different though. Rather than look sleek with all kinds of modern features, he decided to build a watch based on the 37-year-old Apple II.

The most obvious thing you’ll notice about this creation is the case. It really does look like something that would have been created in the 70’s or 80’s. The rectangular shape combined with the faded beige plastic case really sells the vintage electronic look. It’s only missing wood paneling. The case also includes the old rainbow-colored Apple logo and a huge (by today’s standards) control knob on the side. The case was designed on a computer and 3D printed. The .stl files are available in the Instructable.

This watch runs on a Teensy 3.1, so it’s a bit faster than its 1977 counterpart. The screen is a 1.8″ TFT LCD display that appears to only be using the color green. This gives the vintage monochromatic look and really sells the 70’s vibe. There is also a SOMO II sound module and speaker to allow audio feedback. The watch does tell time but unfortunately does not run BASIC. The project is open source though, so if you’re up to the challenge then by all means add some more functionality.

As silly as this project is, it really helps to show how far technology has come since the Apple II. In 1977 a wristwatch like this one would have been the stuff of science fiction. In 2015 a single person can build this at their kitchen table using parts ordered from the Internet and a 3D printer. We can’t wait to see what kinds of things people will be making in another 35 years.

Kerbal Space Program is a space simulation game. You design spacecraft for a fictional race called Kerbals, then blast those brave Kerbals into space. Sometimes they don’t make it home.

If controlling spacecraft with your WASD keys isn’t immersive enough for you, [marzubus] has created a fully featured KSP control console. It sports a joystick, multiple displays, and an array of buttons and switches for all your flight control needs. The console was built using a modular approach, so different controls can be swapped in and out as needed.

Under the hood, three Arduinos provide the interface between the game and the controls. One Arduino Mega runs HoodLoader2 to provide joystick data over HID. A second Mega uses KSPSerialIO to communicate with the game over a standard COM port interface. Finally, a Due interfaces with the displays, which provide information on the current status of your spacecraft.

All of the parts are housed in an off the shelf enclosure, which has a certain Apollo Mission Control feel to it. All [marzubus] needs now is a white vest with a Kerbal badge on it.

[Bayres’] dad setup a webcam as a surveillance camera for a remote property. The only problem was that the only stable Internet connection they could get at this property was DSL. This meant that the external IP address of the webcam would change somewhat often; the needed a way to keep track of the external IP address whenever it changed. That’s when [Bayres] built a solution using Arduino and an Ethernet shield.

The main function of this device is to monitor the public IP address and report any changes. This is accomplished by first making a request to checkip.dyndns.org. This website simply reports your current public IP address. [Bayres] uses an Arduino library called Textfinder in order to search through the returned string and identify the IP address.

From there, the program compares this current value to the previous one. If there is any change, the program uses the Sendmail() function to reach out to an SMTP server and send an e-mail alert to [Beyres’] dad. The system also includes a small LCD. The Arduino outputs the current IP address to this display, making it easy to check up on the connection. The LCD is driven by 74HC595 shift register in order to conserve pins on the Arduino.

The system is also designed with a pretty slick setup interface. When it is booted, the user can enter a configuration menu via a Serial terminal. This setup menu allows the user to configure options such as SMTP server, email address, etc. These variables are then edited and can be committed to EEPROM as a more permanent storage solution. Whenever the system is booted, these values are read back out of the EEPROM and returned to their appropriate variables. This means you can reconfigure the device on the fly without having to edit the source code and re-upload.