Tag Archive | "review"

Project Review – Silicon Chip Capacitance Substitution Box

Introduction

Every month Australian electronics magazine Silicon Chip publishes a variety of projects, and in some cases various (well … one of two) electronics retailers will pick up the project and offer it as a kit. However for an increasing number of new projects they don’t, which leaves the interested reader with one option – build the entire project from scratch.

But thankfully this is no longer the case – as the team from Silicon Chip now offer a range of project PCBs and matching front panels for sale directly from their website. Although buying these parts is not the cheapest option, it gives the busy person who likes making things a quick start – or the inexperienced more opportunities to complete a successful project.

So as a test of this new service, I bought the PCB and front panel for the Capacitance Substitution Box project described by Nicholas Vinen in the Juily 2012 issue of SC:

capacitance_article

This is something I’ve meant to make for a while – but didn’t really have the inclination to make one from scratch, so it was neat to see a version published in the magazine. I believe the subjects in the magazine article are oftern prototypes, which explains the difference in colour for the front panel.

The parts arrived in a week after placing the order, and are of a high quality:

capacitance box panel

capacitance pcb front

capacitance pcb rear

When complete, the capacitance substitution box PCB and panel will fit nicely into an Altronics H0151 enclosure, so you don’t need to do any drilling or filing. The next task was to organise the required parts. The rotary switches, terminal posts and the usual odds and ends can be found at Altronics, Jaycar or other suppliers. However the main components – the capacitors – offered two options.

The first option is to simply use capacitors from personal stock or the stores. However the tolerance of these parts can vary wildly, with up to twenty percent either way. This is ok for simple uses, however when values are combined – the tolerance of larger values can negate the lower values completely. So instead I’ve chosen the second option – which involves using brand-name low-tolerance capacitors.

Thus I turned to element14 who stock not only a huge range of not only regular but also the low-tolerance capacitors, and can also have them on my desk usually by the next working day. Finally, it’s nice to have all the parts arrive in little bags… neatly organised ready to go:

capacitors

It’s easy to search for low-tolerance parts with element14, as the automatic filtering has tolerance as a parameter:

element14 capacitors

Furthermore you can also ensure you have the voltage rating of at least 50V DC as well. So after half an hour the capacitor order was completed and arrived when expected – using parts from Panasonic, Vishay, and Wima. The tolerances of our capacitors used varied between one and ten percent, which will help improve the accuracy of the substitution box.

Assembly

The PCB has the capacitor values labelled neatly on the silk-screen, so soldering in all the capacitors was a relatively simple but long operation. Having them arrive in separate packets made life a lot easier. During the soldering process it’s a good idea to have a  break or two, which helps you avoid fatigue and making any mistakes.

capacitance substitution box half finished

There may be a few capacitors that are a little too wide to fit with the others, so they can be mounted on the other side of the PCB:

capacitance substitution box wide capacitor

However they all end up fitting well:

capacitance substitution box half finished

The next step was to configure the first rotary switch for six position use, then cut the plastic stopped from the side of each rotary switch. In the following image you have a before and after example:

capacitance substitution box rotary switches

Now the rotary switches can have their shafts trimmed and then be soldered onto the PCB:

capacitance substitution box switches trimmed

However ensure you have the first rotary switch in the right way – that is the selections are selected across the top half, not the bottom. Remove the nuts from the rotary switches, and double-check all the capacitors are fitted, as once the next step is completed … going back will be difficult to say the least.

At this point the banana sockets can be fitted to the panel, and then soldered into place, and then you’re finished. Just place the panel/PCB combination inside the box and screw it down:

capacitance substitution box complete

Using the Capacitance Substitution Box

Does it work? Yes – however you don’t get exact values, there will always be a tolerance due to the original tolerance of the capacitors used and the stray capacitance of the wires between the box and the circuit (or capacitance meter). Nevertheless our example was quite successful. You can see the box in action with our Altronics LC meter kit in this video.

Again, using the best tolerance capacitors you can afford will increase the accuracy of this project.

Conclusion

Over time this would be a useful piece of equipment to have – so if your experiments or projects require varying capacitor value, this project will serve the purpose nicely. Plus it helps with mental arithmetic and measures of capacitance! Please do not ask me for copies of the entire Silicon Chip article, refusal may offend. Instead – visit their website for a reprint or digital access.

And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in capacitor, kit review, projects, silicon chip, substitution box

Review – Intel Galileo Arduino-compatible Development Board

Introduction

Over the last year or two the rise of the single-board computer has captured the imagination and energy of many people, to the point where popular opinion has been that the Arduino world had been left behind. However this is far from the truth – there’s Arduino-compatible SBCs such as the pcDuino and now we have one from Intel  – the Intel Galileo.

Intel Galileo box

Apparently the Galileo has been available in limited distribution for a few months, and now that the marketing machine has started up – we finally had the chance to order an Intel Galileo last week and now have one as the subject for this review. It’s our first look, based on information we could find at the time and some experimenting.

What’s in the box?

In the retail package we found the Intel Galileo itself:

Intel Galileo box inside

Intel Galileo

… a diagram of what to do in the lid:

Intel Galileo box inside lid

… and a universal AC to 5V 2A DC power supply with various fittings for different regions:

Intel Galileo power supply

The only paper documentation was a safety and regulatory information booklet which gets recycled. We didn’t find a USB cable nor some stand-offs to lift the board off the bench a little.

Specifications

The Galileo is based a new chipset from Intel, the Quark SoC X1000 Application Processor, a 32-bit Intel Pentium-class system on a chip. For the uninitiated, the Galileo is a single-board computer running a small version of Linux that can somewhat emulate an Arduino Uno R3 in software. The hardware specifications are as such (from the Arduino website):

  • 400MHz 32-bit Intel® Pentium instruction set architecture (ISA)-compatible processor o 16 KBytes on-die L1 cache
    • 512 KBytes of on-die embedded SRAM
    • Simple to program: Single thread, single core, constant speed
    • ACPI compatible CPU sleep states supported
    • An integrated Real Time Clock (RTC), with an optional 3V “coin cell” battery for operation between turn on cycles.
  • 10/100 Ethernet connector
  • Full PCI Express* mini-card slot, with PCIe 2.0 compliant features
    • Works with half mini-PCIe cards with optional converter plate
    • Provides USB 2.0 Host Port at mini-PCIe connector
  • USB 2.0 Host connector
    • Support up to 128 USB end point devices
  • USB Device connector, used for programming
    • Beyond just a programming port – a fully compliant USB 2.0 Device controller
  • 10-pin Standard JTAG header for debugging
  • Reboot button to reboot the processor
  • Reset button to reset the sketch and any attached shields
  • Storage options:
    • Default – 8 MByte Legacy SPI Flash main purpose is to store the firmware (or bootloader) and the latest sketch. Between 256KByte and 512KByte is dedicated for sketch storage. The download will happen automatically from the development PC, so no action is required unless there is an upgrade that is being added to the firmware.
    • Default 512 KByte embedded SRAM, enabled by the firmware by default. No action required to use this feature.
    • Default 256 MByte DRAM, enabled by the firmware by default.
    • Optional micro SD card offers up to 32GByte of storage
    • USB storage works with any USB 2.0 compatible drive
    • 11 KByte EEPROM can be programmed via the EEPROM library.

However unlike other SBCs on the market – you don’t get any video or audio output.

Let’s have a quick look around the board. Here you can see the DC socket and microSD card socket:

Intel Galileo DC end

 From the view below you can see the Arduino shield stacking headers and flash memory:

Intel Galileo ICSP end

… more jumpers for settings, a USB host socket, USB connection (client) socket, RS232 via 3.5mm socket (!) and 10/100 Ethernet:

Intel Galileo socket end

… and some nifty jumpers to select 3.3 or 5V operation for shields and IOREF:

Intel Galileo IOREF Vin jumpers

… this jumper pair is to add a 3V battery to keep the real-time clock ticking over when the main supply is removed:

Intel Galileo RTC battery jumpers

Perhaps a CR2032 button cell holder would be preferable, there’s plenty of room on the PCB. Finally – the two reset buttons:

Intel Galileo reset buttons

If you want to reset your emulated Arduino, press the one on the left (labelled I). If you want to reboot the entire computer, press the one on the right (labelled X). This seems a little counter-intuitive, as you would imagine the button closer to the stacking headers would reset the Arduino. Note that if you reboot the computer, the last sketch you’ve uploaded will be removed and need to be uploaded again. Furthermore, more often than not rebooting the Galileo wasn’t entirely successful – and required a full removal of USB, power then replacing the power and USB to get another connection.

Turning the Galileo over reveals some fascinating PCB track patterns, and the mini-PCIe connector:

Intel Galileo bottom 2

Getting Started

Having a slight bent towards Arduino, the first thing we like to do is get the blink sketch running. The documentation is scattered all over the place, so start from maker.intel.com and follow the links listed in the “Explore Intel makers” column. The closest thing to a quick setup guide can be downloaded hereThere’s a video by what sounds to be a ten year old explaining the board – who signs off by telling us it’s ok to break something (hopefully not the Galileo at $77 a pop). Marketing FTW. Eventually we found the official Intel support page for the Galileo, so bookmark that for future reference.

However if you just want to get started as quickly as possible, keep reading. First, download the Arduino IDE for Galileo from here. Next, extract the IDE folder to your root directory – and don’t have any spaces in the folder name. For example, use:

and not:

Now plug in your Galileo – and always plug the 5V power into the Galileo before the USB (use the “USB client” socket). For Windows the USB driver (for “Gadget Serial v2.4″) is in the IDE folder, just point Windows to the top Galileo Arduino IDE folder.

Note that it takes around twenty seconds for the PC to recognise the Galileo via USB (as the Galileo needs time to boot up – it’s running Linux). For Windows users – after loading the IDE, check which COM port has been allocated. For some reason the Galileo can’t deal with COM10 or higher. To change this, head over to the Device Manager. Open Ports (COM & LPT) then right-click the Galileo and click properties:

Intel Galileo Change COM number

Next, click the Port Settings tab, then Advanced:

Intel Galileo Change COM number tab

Then select a free COM port number that’s under 10, close all the dialogue boxes and restart the computer. After the reboot, load the IDE, select the right board and serial port in the Tools menu – then select Firmware Update in the Help Menu. If for some reason you put a memory card in the microSD card slot – remove it before this process.

Intel Galileo Windows Firware Update

A confirmation box will appear, so move forward and wait for the process to finish. Don’t touch the IDE, board or anything near the Galileo until this finishes. Read some kit reviews. The update process took eight minutes for us, however will depend on the speed of your Internet connection.

Intel Galileo Windows Firware Update status

Finally, try the ubiquitous blink sketch. Once uploaded,  the tiny LED next to the coin cell jumpers will blink as requested. Now we’ll explore more about using the Galileo as an Arduino-compatible board.

How Arduino-compatible is the Galileo?

The first thing we like to do with new boards that differ from the classic Uno is to run a speed test, and for this we use the following sketch by Steve Curd from the Arduino forum:

It calculates Newton Approximation for pi using an infinite series. For comparison an Arduino Due takes 690 ms, an Arduino Mega 2560 takes 5765 ms, and a pcDuino v2 can do it in 9 to 43 ms (depending on what else is running on Linux). So out of the box, the Galileo takes 279 ms:

Intel Galileo Arduino speed test

Out of the box there is 262144 bytes available for sketches. As the Arduino is emulated, the hardware for I/O is a little different than you may have expected, and provided by a variety of I2C port expanders, MUXs and so on. For example I2C can only run at 100 kHz in master mode, no slave mode, and similar restrictions on SPI as well. Again, review this page to learn more about the internal hardware differences between an Arduino Uno and Intel Galileo.

Visit this page and scroll down to the block diagram for a visual representation, and while you’re there – review the entire page to learn more about the specific Arduino Uno R3 implementation on the Galileo. A lot of work has been done to allow successful emulation of the Arduino using the Quark CPU and internal OS. For example the EEPROM library just works, and has 11264 bytes of storage.

You can get an idea of what is supported “out of the box” by reviewing the libraries included with the Galileo’s IDE installation, for example:

Intel Galileo Arduino IDE examples

So most of the basic requirements are covered at the time of writing. And unlike some other SBCs emulating Arduino, the onboard Ethernet “just works” as it should with the Ethernet library – and the USBHost library can take advantage of the matching socket on the board. Again – research is the key, so spend some time determining if the Galileo can solve your problems.

One interesting example of the limitations of the “emulated” Arduino is the speed, and this has been highlighted by Al Williams of Dr Dobb’s journal – who ran a simple sketch to see how fast a digital output pin could be set. As GPIO is provided by external SPI- and I2C-based interface ICs, there will be a speed hit. But how much? Naturally we can’t use port manipulation so we’re back to simple digitalWrite functions with the following sketch:

An Arduino Uno running the sketch was clocked at 96.34 kHz:

Arduino Uno digitalWrite test

… and the Intel Galileo was clocked at … 225.2 Hz:

Intel Galileo digitalWrite test

This test isn’t a criticism of the Galileo, just an example of what you need to keep in mind when using it. If you’re curious about the real-time clock it’s accessed via Linux. Finally, there’s a list of known issues on the Intel forum – so check this out to get a grip on what is and is not working in terms of Arduino compatibility. One more thing – you will need a memory card installed if you want the Galileo to remember sketches after power-off.

Update – thanks to our friends (!) at reddit, you can push some I/O faster – see this post in the Intel forum.

Linux – internal

The Galileo arrived pre-loaded with a very light version of Linux, however due to the lack of video output you need to access the “computer” via some old-school methods. And thus one method is via Telnet over Ethernet. If you don’t have a Telnet client, try PuTTY. To get started, ensure you have your Galileo connected to power, client USB to PCm and to your LAN. Then upload the following sketch to your Galileo:

The observant will notice by using the system function you can send instructions to the Linux command line from your Arduino sketch. And any resulting output text can be sent to the serial monitor by directing it to ttyGS0.

Anyhow, the above sketch will run the ifconfig command and return relevant networking data about your Galileo – including its IP address:

Intel Galileo telnet sketch

Once you have the IP address, you can Telnet in and command your Galileo just like it’s 1992:

Intel Galileo poky linux box telnet

Don’t get too excited, there isn’t that much installed (e.g. no gcc or make). For more information on the Poky linux, visit the project page. Apart from running vi my *nix memory is a bit vague, however the onboard system is quite minimal. If you want to do anything serious, such as use a WiFi or other PCIe card – you’ll need to boot your Galileo with an external OS stored on a microSD card. Another way of looking at the Galileo is that it’s a board not for development with, but for running code built on a different system and then loaded onto the Galileo.

Linux – external

As I haven’t been a *nix user for a very long time, it didn’t seem worthwhile to spend a whole day preparing for an installing the external OS on the Galileo for review. However from what I can tell you’ll need to do this to run anything substantial including WiFi adaptors, python, node.js and so on. Which in my personal opinion sort of ruins the Galileo for me. Other SBCs can do all of this a lot easier, cheaper and with better documentation.

Arduino Support

As the Galileo is from Intel and not Arduino, you need to ask for support in the Intel forum. This will be an interesting test for Intel, will they invest in a substantial support effort or just stand back and say it’s all open source? Time will tell. In the meanwhile there is a gallery hosted by Intel with links to different projects.

Conclusion

Once again – remember that the Galileo is a limited single-board computer that emulates (to a certain, varying degree) an Arduino Uno R3. It is a contender if you need to integrate some Arduino-based control with software running on a light Linux machine, and all in a compact board. Or if you want to experiment with USB host and Ethernet on the Arduino platform at the same time, this could be a cheaper and more powerful option. Support is there if you can use Google, however this is not the idea beginners’ Arduino board. So don’t be a sheep and rush out and buy one after reading the marketing blurb – do your own research first.

Personally I would say that if you have a need for the specific hardware interfaces of the Galileo, and have a full understanding of the board limitations – then it’s the board for you. Otherwise if you want to experiment with a full single-board computer with Arduino compatibility, get a pcDuino. Full-sized images are available on flickr.

And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

[Note - Intel Galileo purchased for review by tronixstuff.com and not a promotional consideration]

Posted in arduino, galileo, intel, review, tronixstuff, tutorial

Review – Iteaduino Lite “nearly 100% Arduino-compatible” board

Introduction

Over the last year there have been a few crowd-funded projects that offered very inexpensive Arduino-compatible boards. Frankly most of them weren’t anything out of the ordinary, however one of them is quite interesting due to the particular design of the board, and is the subject of this review.

An established company Iteadstudio ran a successful Indiegogo campaign last December to fund their Iteaduino Lite – Most inexpensive full-sized Arduino derivative board”. Having a spare US$5 we placed an order and patiently waited for the board. Being such a low price it was guaranteed to raise the funding – but was it worth the money? Or the effort? Possibly.

The board

In typical fashion the board arrived in bare packaging:

Iteaduino Lite arrived

 The Iteaduino Lite isn’t that surprising at first glance:

Iteaduino Lite bare top

To the new observer, it looks like an Arduino board of some sort. Nice to see all those GPIO pins with double breakouts. No surprises underneath:

Iteaduino Lite bottom

The URL on the bottom is incorrect, instead visit http://imall.iteadstudio.com/iteaduino-lite.html. Looking at the board in more detail, there are some interesting points of difference with the usual Arduino Uno and compatibles.

The USB interface is handled with the Silabs CP2102 USB to UART bridge IC:

Iteaduino Lite CP2102 USB

The next difference is the power circuitry – instead of using a linear voltage regulator, Itead have used a contemporary DC-DC converter circuit which can accept between 7 and 24V DC:

Iteaduino lite power supply

Furthermore, the entire board can operate at either 5V or 3.3V, which is selected with the slide switch in the above image. Finally – the microcontroller. Instead of an Atmel product, Itead have chosen the LogicGreen LGT8F88 microcontroller, a domestic Chinese product:

Iteaduino Lite LGT8F88A MCU

And there are only two LEDs on the Iteaduino Lite, for power and D13. The LED on D13 ins’t controlled via a MOSFET like other Arduino-compatibles, instead it’s simply connected to GND via a 1kΩ resistor.

Getting started with the Iteaduino Lite

The stacking header sockets will need to be soldered in – the easiest way is to insert them into the board, use an shield to hold them in and flip the lot upside down:

Iteaduino lite stacking headers

Which should give you neatly-installed headers:

Iteaduino Lite ready to use

Watch out for the corners of the board, they’re quite sharp. Next, you need to install the USB driver for the CP2102. My Windows 7 machine picked it up without any issues, however the drivers can be downloaded if necessary.

Finally a new board profile is required for the Arduino IDE. At the time of writing you’ll need Arduino IDE v1.0.5 r2. Download this zip file, and extract the contents into your ..\Arduino-1.0.5-r2\hardware folder. The option should now be available in the Tools > Board menu in the IDE, for example:

Iteaduino Lite Arduino IDE

From this point you can run the blink example to check all is well. At this point you will realise one of the limitations of the Iteaduino Lite – memory. For example:

Iteaduino Lite Arduino IDE memory

You only have 7168 bytes of memory for your sketches – compared to 32, 256 for an Arduino Uno or compatible. The reason for this is the small capacity of  …

The LogicGreen LGT8F88 microcontroller

This MCU is a Chinese company’s answer to the Atmel ATmega88A. You can find more details here, and Itead also sells them separately. The LGT8F88 offers us 8Kbyte of flash memory of which 0.7KB is used by bootloader, 1 KB of SRAM and 504 bytes (count ‘em) of EEPROM. Apparently it can run at speeds of up to 32 MHz, however the LGT8F88 is set to 16 MHz for the Iteaduino Lite.

According to Logic Green, their LGT8F88 “introduce a smart instruction cache, which can fetch more instructions one time, effectively decrease memory accessing operations“. So to see if there’s a speed bump, we uploaded the following sketch – written by Steve Curd from the Arduino forum. It calculates Newton Approximation for pi using an infinite series:

For a baseline comparison, an Arduno Uno R3 completes the calculations in 5563 ms:

Iteaduino Lite Uno speed test

… and the Iteaduino Lite completed it in 5052 ms:

Iteaduino Lite speed test

So that’s around a 10% speed increase. Not bad at all. The LGT8F88 also has the requisite GPIO, SPI, and I2C available as per normal Arduino Uno boards. You can download the data sheet with more technical details from here. Frankly the LGT8F88 is an interesting contender in the marketplace, and if Logic Green can offer a DIP version at a good price, the ATtiny fans will have a field day. Time will tell.

Power Circuit

The DC-DC circuit promises 5V output, with up to 24V DC input – so we cranked the input to 24V,  put a 1A load on the 5V output – and put the DSO over 5V to measure the variations – with a neat result:

Iteaduino lite PSU test

So no surprises there at all, the Iteaduino Lite gives you more flexible power supply options than the usual Arduino board. However an eagle-eyed reader notes that a few of the capacitors are only rated at 25V – especially the two right after the DC socket/Vin. You can see this in the schematic (.pdf). So take that into account, or drop your Vin to something more regular such as below 12V.

Conclusion

The Iteaduino Lite is an interesting experiment in bargain Arduino-compatible boards. However we say “why bother?” and just get a Uno R3-compatible board.

At the end of the day – why bother with this board? For a little extra you can get boards with the ATmega328P or 32U4 which gives you 100% compatibility. Nevertheless, this was an interesting experiment. Full-sized images are available on flickr. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, iteaduino, LGT8F88, review, tronixstuffComments (0)

Easily test and experiment with GSM modules using AT Command Tester

Introduction

Working with GSM modules and by extension Arduino GSM shields can either be a lot of fun or bring on a migraine. This is usually due to the quality of module, conditions placed on the end user by the network, reception, power supply and more.

Furthermore we have learned after several years that even after following our detailed and tested tutorials, people are having trouble understanding why their GSM shield isn’t behaving. With this in mind we’re very happy to have learned about a free online tool that can be used to test almost every parameter of a GSM module with ease – AT Command Tester. This software is a Java application that runs in a web browser, and communicates with a GSM module via an available serial port.

Initial Setup

It’s simple, just visit http://m2msupport.net/m2msupport/module-tester/ with any web browser that can run Java. You may need to alter the Java security settings down to medium. Windows users can find this in Control Panel> All Control Panel Items  > Java – for example:

Java security settings

Once the security settings have been changed, just visit the URL, click ‘accept’ and ‘run’ in the next dialogue box that will appear, for example:

run Java app

And after a moment, the software will appear:

at command tester

Once you’re able to run the AT Command Tester software, the next step is to physically connect the hardware. If you’re just using a bare GSM module, a USB-serial adaptor can be used for easy connection to the PC. For Arduino GSM shield users, you can use the Arduino as a bridge between the shield and PC, however if your GSM shield uses pins other than D0/D1 for serial data transmission (such as our SIM900 shield) then you’ll need to upload a small sketch to bridge the software and hardware serial ports, for example:

Using the software

Once you have the hardware connected and the Arduino running the required sketch, run the software – then click “Find ports” to select the requried COM: port, set the correct data speed and click “Connect”. After a moment the software will interrogate the GSM module and report its findings in the yellow log area:

at command tester connected

 As you can see on the left of the image above, there is a plethora of options and functions you can run on the module. By selecting the manufacturer of your GSM module form the list, a more appropriate set of functions for your module is displayed.

When you click a function, the AT command sent to the module and its response is shown in the log window – and thus the magic of this software. You can simply throw any command at the module and await the response, much easier than looking up the commands and fighting with terminal software. You can also send AT commands in batches, experiment with GPRS data, FTP, and the GPS if your module has one.

To give you a quick overview of what is possible, we’ve made this video which captures us running a few commands on a SIM900-based Arduino shield. If possible, view it in 720p.

Conclusion

Kudos to the people from the M2Msupport website for bringing us this great (and free) tool. It works – so we’re happy to recommend it. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, AT command, GSM, software review, tronixstuff

Tutorial – pcDuino GPIO with Arduino IDE

Introduction

In this tutorial we’ll explain how to use the GPIO pins of the Arduino implementation in the pcDuino v2 and v3. As the v3 is now available you can use it as well, and it’s interchangeable with the v2. Although the pcDuino v2 is Arduino-compatible, there are a few differences that you need to be aware of – in order to make your projects a success and also to avoid any costly mistakes.

pcDuino v2 board

This tutorial builds on the knowledge from the initial review, so if pcDuino v2 is new to you please review this article before moving on. In this instalment we’ll run through the following:

  • ADC (analogue to digital)
  • Digital input and outputs
  • PWM (pulse-width modulation)
  • I2C bus
  • SPI bus

Using ADC pins

Just like an Arduino Uno or compatible, the pcDuino v2 has six ADC pins, in the expected locations:

pcduino v2 ADC pin map

Using the pcDuino v2’s ADC pins is quite straight forward, however you just need to remember a few things about the hardware – that the maximum input voltage on A0 and A1 is 2V – and 3.3V for A2~A5.

Although there is an AREF pin on the board, this function isn’t supported at the time of writing. From the software perspective A0 and A1’s values have a 6-bit resolution and can fall between 0 and 63 (0~2V), otherwise the others have a 12-bit resolution and thus return values between 0 and 4095 (0~3.3V). Using the ADC pins is simple, and demonstrated in the following sketch:

… which results with the following in the console:

pcDuino ADC demo output

Digital outputs

The pcDuino v2’s implementation of digital outputs aren’t anything out of the ordinary – except that you are limited to a maximum voltage of 3.3V instead of the usual 5V. Furthermore you can only source 4mA from each pin. However if you have some 5V-only shields that you must use with your pcDuino v2 – there is a Voltage Translation board that can be used to solve the problem:

pcDuino v2 voltage translation board TBoard

However using 3.3V for new designs shouldn’t be an issue – new sensors, ICs and so on should be 3.3V-compatible. And with the pcDuino v2 you get an extra four digital I/O pins, located next to the SPI grouping as shown below:

pcDuino v2 extra GPIO pins

These are simply addressed as D14~D17. Now back for a quick demonstration with the typical LEDs. As the current sourced from each GPIO pin cannot exceed 4mA, you need to use a resistor to keep things under control. Using the LED wizard, by entering a 3.3V supply, 2.1V forward voltage for our LEDs and a 4mA current – the resistor value to use is 330Ω.

If you’re having a lazy attack and use 560Ω, the current will be around 2.5mA with acceptable results. We’ve done just that with the following demonstration sketch:

… and the results in this video.

 

Digital inputs

When using the digital pins as inputs, just treat them as normal except they have a maximum input voltage of 3.3V for HIGH. Again – just keep thinking “3.3V”.

Using the I2C data bus

The I2C bus (or “two wire interface”) is a common serial data bus used for interfacing all manner of devices with a microcontroller. You can find a background on the I2C bus and Arduino tutorial here. Just like an Arduino Uno R3, the I2C bus pins are both A4 and A5 (for SCL and SDA) and can also be found up near D13, for example.

The limitations for the pcDuino v2’s version of I2C bus are few – the maximum speed is 200 kHz, it only uses 7-bit addresses and you can’t use the pcDuino in slave mode. However there are 2.2kΩ pullup resistors which can save using them with external circuitry.

We demonstrate the I2C bus by writing data to and reading it from a Microchip 24LC256 EEPROM (which is handy in itself as there isn’t any EEPROM function on the pcDuino v2). This is demonstrated with an Arduino Uno in part two of our I2C tutorials.

Connection is very easy – pins 1 to 4 of the EEPROM are connected to GND, pin 5 to SDA, pin 6 to SCL, pin 7 to GND and pin 8 to 3.3V. Finally a 0.1uF capacitor is placed across 3.3V and GND.

pcduino v2 eeprom

The sketch to read and write values to the EEPROM is simple, and apart from the #include <core.h> for the pcDuino all the other functions operate as normal.

… which results with the following output in the console:

pcduino i2c demonstration

As you now know, using I2C isn’t hard at all. A lot of beginners shy away from it – or run screaming for the nearest library for their part. You don’t need libraries – spend a little time now learning about I2C and you’re set for life.

Using the SPI data bus

Again we have some SPI tutorials for Arduino, so check them out first if the concept is new to you. Writing to an SPI device with the pcDuino v2 isn’t tricky at all, you have the 3.3V hardware limitation and the SPI pins are in the same location (D10~D13) or in a separate group on the board:

pcduino v2 SPI pins

Furthermore the maximum SPI speed is 12 MHz and the pcDuino v2’s  implementation of SPI can only work as a master. However in the sketch there are a few differences to note. To demonstrate this we’ll control a Microchip MCP4162 digital rheostat via SPI to control the brightness of an LED. Here is the circuit:

pcDuino v2 MCP4162 SPI demo circuit

And now for the sketch. Take note of the fourth line in void setup() –  this is used to set the SPI bus speed to 12 MHz. You can also reduce the speed with other multipliers such as 32, 64 and 128 to slow it down even further. The other point to note is the use of SPI.transfer(). With the pcDuino v2 there are two parameters – the first is the data to send to the SPI device, and the second is either

if there is another byte of data following immediately, or

if that is the last byte for that immediate transfer. You can see this use of the paramters within the function setValue() in the demonstration sketch below.

When using the SPI bus, relevant data will appear in the console, for example:

pcduino V2 SPI console output

And finally the demonstration video to show you it really works – you can see the output voltage from the rheostat and the matching LED brightness.

Receiving data from the SPI bus is equally as simple, however at the time of writing we don’t have an SPI device to demonstrate this, so please refer the SPI part of the pcDuino guide. Finally, you can’t use PWM on D10 or D11 when using the SPI bus in your sketch.

Pulse-width modulation

You can simulate analogue output using PWM with a pcDuino v2 – however there are two types of PWM pins available. The first is found on digital pins D3, D9, D10 and D11 – they are simulated PWM – and have a low range of zero to twenty at 5 Hz. There are two hardware PWM pins – D5 and D6, which  run at 520Hz and have the full range of 0~255 available in analogWrite(). Once again – they output 3.3V. Furthermore, you can’t use pinMode() functions or the SPI bus if using D10 and/or D11 for PWM.

Conclusion

Now you should have an understanding of the features and limitations of using GPIO pins with your pcDuino v2 Arduino sketches. Stay tuned as we continue with more pcDuino v2 articles and tutorials in the near future. pcDuino boards and accessories are available from tronixlabs. Full-sized images are on flickr.

And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in ADC, arduino, GPIO, I2C, pcDuino, PWM, SPI, tronixlabs, tronixstuff, tutorialComments (0)

Kit Review – Altronics/Silicon Chip ISD2590 Digital Message Recorder

Introduction

Every month Australian electronics magazine Silicon Chip publishes a variety of projects, and in February 1994 they published the “90 Second Digital Message Recorder” project. That was a long time ago, however you can still find the kit today at Altronics (and at the time of writing, on sale for AU$26), and thus the subject of our review.

The kit offers a simple method of recording and playing back 90 seconds of audio, captured with an electret microphone. When mounted in a suitable enclosure it will make a neat way of leaving messages or instructions for others at home.

Assembly

The kit arrives in typical Altronics fashion:

Altronics K9570 90 second message recorder kit package

… and includes everything required including IC sockets for the ISD2590 and the audio amplifier:

Altronics K9570 90 second message recorder kit inclusions

Altronics K9570 90 second message recorder kit components

The PCB missed out on silk-screening – which is a pity:

Altronics K9570 90 second message recorder kit instructions PCB front

however it is from an original design from twenty years ago. The solder mask is neat and helps prevent against lazy soldering mistakes:

Altronics K9570 90 second message recorder kit PCB back

Finally the detailed instructions including component layout and the handy Altronics reference guide are also included. After checking and ordering the resistors, they were installed first along with the links:

Altronics K9570 90 second message recorder kit construction

 If you have your own kit, there is a small error in the instructions. The resistor between the 2k2 and the 10uF electrolytic at the top of the board is 10k0 not 2k2. Moving on, these followed by the capacitors and other low-profile components:

Altronics K9570 90 second message recorder kit construction 4

The rest of the components went in without any fuss, and frankly it’s a very easy kit to assemble:

Altronics K9570 90 second message recorder kit finished

 The required power supply is 6V, and a power switch and 4 x AA cell holder is included however were omitted for the review.

How it works

Instead of some fancy microcontrollers, the kit uses an ISD2590P single chip voice recording and playback IC:

Altronics K9570 90 second message recorder kit ISD2590

It’s a neat part that takes care of most of the required functions including microphone preamp, automatic gain control, and an EEPROM to store the analogue voltage levels that make up the voice sample. The ISD2590 samples audio at 5.3 kHz which isn’t CD quality, but enough for its intended purpose.

Apart from some passive components for power filtering, controls and a speaker amplifier there isn’t much else to say. Download the ISD2590 data sheet (pdf), which is incredibly detailed including some example circuits.

Operation

Once you apply power it’s a simple matter of setting the toggle switch on the PCB down for record, or up for playback. You can record in more than one session, and each session is recorded in order until the memory is full. Then the sounds can be played back without any fuss.

The kit is supplied with the generic 0.25W speaker which is perhaps a little weak for the amplifier circuit in the kit, however by turning down the volume a little the sound is adequate. In this video you can see (and hear) a quick recording and playback session.

Conclusion

This kit could be the base for convenient message system – and much more interesting than just scribbling notes for each other. Or you could built it into a toy and have it play various tunes or speech to amuse children. And for the price it’s great value to experiment with an ISD2590 – just use an IC socket. Or just have some fun  – we did.  Full-sized images are available on flickr

And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in altronics, ISD2590, K9570, kit, kit review, silicon chip, tronixstuffComments (0)

Review – pcDuino v2

Introduction

Updated 29/01/2014 All pcDuino v2 tutorials

Update! The pcDuino version 3 is now available

In the last twelve months or so several somewhat inexpensive single-board computers have burst onto the market, and of those was the pcDuino. This has now evolved into the pcDuino v2,  the topic of our review. The pcDuino v2 is billed as the “mini PC + Arduino”, a combination with much promise. Out of the box it runs a version of Ubuntu 12.04 on Linaro 12.07, or can also run Android Ice Cream Sandwich if so desired.

The pcDuino v2 is a single-board computer like many others, however with some interesting additions – the most interesting being the Arduino-shield hardware connections and pcDuino v2 Arduino development environment. We’ll first run through the pcDuino v2 as a Linux computer, and then delve into the Arduino-compatibility. But first, our test board… which arrived safely in a neat box:

pcDuino v2 box

… which contains the pcDuino v2 itself:

pcDuino v2 board

At first glance you can see the various points of interest, such as the Allwinner A10, which is a 1GHz ARM Cortex A8 CPU:

pcDuino v2 CPU

… the Realtek WiFi add-on board (which is fitted to the pcDuino v2):

pcDuino v2 realtek wifi

… and also a USB socket (for keyboard, mouse, USB hub and so on), a microUSB for USB OTG use, a full-sized HDMI socket for full HD video, RJ45 Ethernet socket,  a microSD socket for expansion, and the Hynix flash memory ICs. From the pcDuino v2 website, the specifications are:

Hardware:

  • CPU – 1GHz ARM Cortex A8
  • GPU – OpenGL ES2.0, OpenVG 1.1 Mali 400 core
  • DRAM – 1GB
  • Onboard Storage – 2GB Flash, microSD card (TF) slot for up to 32GB
  • Video Output – HDMI
  • OS – Linux3.0 + Ubuntu 12.04/Android ICS 4.0
  • Extension Interface Arduino Headers
  • Network interface – 10/100Mbps RJ45 and on-board WiFi module
  • USB Host port 1
  • Requires – Power 5V, 2000mA
  • Overall Size 125mm X 52mm

Software

  • OS – Ubuntu 12.04 (pre-loaded) or Android ICS 4.0
  • APIs – all the Arduino shield pins are accessible with the provided API. 

    It consists of API to access the following interfaces: UART, ADC, PWM, GPIO, I2C, SPI

  • Programming language support – C, C++ with GNU tool chain, Java with standard Android SDK, Python. 

However at the time of writing all models with the date stamp of 17/09/2013 (and newer) have 4G of onboard flash storage – a great little bonus. With the addition of an inexpensive microSD card you can add up to an additional 32 G of storage.

Getting Started

This is the crunch-point for many products – how does one get started? With the pcDuino – very easily. Apart from the computer itself, you’ll need a monitor with HDMI inputs and speakers, a USB keyboard and mouse (with a USB hub – or one of those keyboard/trackpad combinations) and a power supply. The pcDuino v2 requires up to 2A at 5V – a higher-rated plugpack than usual. Don’t be tempted to use a normal USB socket – the pcDuino v2 will not work properly on the available current.

So after plugging all that in with the power the last to connect – the pcDuino v2 fires up in around five seconds, quickly running through the Ubuntu startup process and ended with the configuration screen in around five seconds:

pcDuino v2 board configuration screen

After setting the time zone, language, screen resolution (full HD) and so on it was another ten seconds to the desktop:

pcDuino v2 initial ubuntu desktop

At this point we found by accident that the A10 CPU runs hot – in some warmer permanent installations it could use a heatsink. But I digress. We now have a “normal” computer experience – the WiFi found the home network without any issue and the Chromium web browser runs well considering the speed and the RAM (1G) of the pcDuino v2:

pcDuino v2 chromium browser

The next step is to format the extra onboard storage, which can be done with the usual tool:

pcDuino hard disk volume

We just formatted it to ext4 and moved on. The included software is nothing unexpected, there’s the Chromium web browser, office-style applications, terminal, XBMC, remote-desktop viewer and of course you can hit up the Ubuntu package manager and install what you need.

It’s easy to get carried away and forget you’re not using a typical multi-GHz computer so bear that in mind when software runs a little slower than expected. However working with WordPress and Google Docs inside Chromium was acceptable, and a fair amount of this review was written using the pcDuino v2.

Excluding the Arduino development environment which we look at in the next section, pre-installed programming tools include Python (v2.7), C/C++ with GNU tool chain and Java with the standard Android SDK. At this point we haven’t tried the pcDuino with the Android operating system, however plan to do so in the near future and this will be the subject of a separate article.

At this point we’d say that the pcDuino v2 is a winner in the SBC (single-board computer) stakes, as you don’t need to worry about external WiFi, or deliberating about which version of an OS to use and then having to download it to an SD card and so on… the pcDuino v2 just works as a computer out of the box.

The pcDuino v2 as an Arduino

At this point we’d like to note that the pcDuino v2 is not an Arduino circuit wired up to a computer (such as the Arduino team did with the Yun). Instead, the pcDuino v2 is a computer that can emulate an Arduino – and has the GPIO pins and shield sockets onboard.

So when you run a sketch on the pcDuino v2’s version of the Arduino IDE – the sketch is compiled and then executed using the CPU, not an ATmega microcontroller. Speaking of which, the IDE is a modified version of 1.5.3 which appears identical to the usual IDE:

pcDuino arduino IDE blink

In fact when you compile and upload that blink.ino sketch everything runs as normal, and a small LED situated near D2/3 will blink as normal. However you do need to use more #include statements, for example #include <core.h> for all sketches. When uploading a sketch, a new window appears that will be blank, as shown below – this window needs to stay open otherwise the sketch won’t run

pcDuino v2 running sketch

One of the benefits of using the pcDuino v2 is the extra space available for sketches – a quick compile shows that you can have a fair bit more than your typical ATmega328 – in our example we had 104,857,600 bytes available:

pcDuino Arduino IDE memory

We don’t have a sketch that large, but at least you have some headroom to create them if necessary.

Arduino Hardware support

The shield header sockets are in the standard R3 configuration – and all GPIO is 3.3V and not 5V tolerant. However there is a conversion shield available if necessary. There are also some extra GPIO pins available – another eight, as shown in the following image:

pcDuino v2 extra GPIO

At the time of writing there is support for GPIO use, SPI (up to 12 MHz, master-only), I2C (up to 200 kHz, at 7-bit and master-only), a UART (serial on D0/D1), PWM and ADC on A0~5.

However ADC is a little different, due to the internal reference voltages of the Allwinner CPU. Take note of the following as if you exceed the maximum voltages you could damage your board. Pins A0 and A1 are 6-bit ADCs, which return values from 0 ~ 63, which range from 0V to 2V. Pins A2~A5 are 12-bit ADCs, which return values  from 0 ~ 4095, which range across the full 0V to 3.3V.

There isn’t access to the usual serial monitor in the Arduino IDE as such, instead you need to use an external, hardware-based solution such as connecting a USB-serial adaptor to pins D0/D1 and using another PC as the terminal. And when you press ‘reset’ on your Arduino shields – it resets the entire computer, just not the Arduino emulation – (learned that the hard way!).

However you can output text and data to the console window that appears after uploading a sketch – and doing so is pretty easy, just use prinf as you would in C or C++. For example, the following sketch:

produces the following output in the console window:

printf full example ouput

It would be recommended to read this guide about using the pcDuino v2 as an Arduino which highlights pretty well everything to get you started, including the notes on interrupts and PWM – and this page which explains the headers on the pcDuino v2. Finally, as the “Arduino” is emulated you cannot use the on-board networking capabilities of the pcDuino v2 such as Ethernet, instead you use a shield as you would with a normal Arduino.

At first glance it may seem that the pcDuino v2 is difficult, which it is not. One needs instead to consider their needs and then work with the available features. Just like many other new development boards and systems, the pcDuino v2 (and pcDuino platform) is still quite new – but growing – so more features and compatibility will appear over time.

How much faster is the pcDuino v2 against a normal Arduino board?

There should be a great difference between the Arduino’s microcontroller and the A10 CPU, even taking into account running the OS and emulation. To test this, we’ll use a sketch written by Steve Curd from the Arduino forum. It calculates Newton Approximation for pi using an infinite series. The pcDuino v2 version of the sketch is below:

As mentioned earlier, you can’t see the IDE serial monitor, so an external PC needs to be used. We connected a USB-serial adaptor running at 3.3V I/O to a PC:

pcDuino v2 USB serial

Now back to the sketch. An Arduino Mega 2560 can do the calculation in 5765 ms, a Due 690 ms, and the fastest I saw the emulated Arduino in the pcDuino v2 do it was 9 ms:

pcDuino v2 pi test scores

Wow, that’s quick. However take note that the completion time was all over the place. When it was 9ms, the only application open was the pcDuino v2 Arduino IDE. The completion time increased when opening other applications such as Chromium, formatting a microSD card and so on.

Why is that? As the pcDuino v2 is emulating an Arduino, the CPU needs clock cycles to take care of that and all the other OS tasks – whereas a straight Arduino just runs the code generated by the IDE and compiler. Nevertheless the speed increase is welcome, and opens up all sorts of possibilities with regards to deeper calculations in sketches they may taken too long on existing hardware.

Support and Community

From what I can tell there is a growing base of users (including this one) and like everything else this will help the pcDuino platform develop and evolve over time. There is a Linksprite “Learning Centre” with a growing pcDuino v2 section, the website, wiki, and support forum which are useful sources of information and discussion.

Conclusion – so far

The pcDuino v2 is a great mix of single-board computer and Arduino-compatible power. There is a small learning curve, however the performance gains are more than worth it. Another USB socket wouldn’t go astray, and the documentation and support will increase over time. However we really liked the fact it’s totally plug-and-play with the onboard storage, OS and WiFi – and for a price of around $89 it’s very keen. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, pcDuino, review, tronixstuff, tutorialComments (0)

Old Kit Review – Talking Electronics Fluorescent Simulator

Introduction

Slowly we’re working through the stock of old kits, and in this article we have the “Fluorescent Lamp” simulator from Talking Electronics. To save repeating myself you can read more about Talking Electronics here and watch interviews of the founder Colin Mitchell here.

So why would you want to simulate a fluoro’ tube anyway? Model railways! When your model world moves from day to night, it’s neat to have street lights and so on “flicker” on just like the real thing. And thus you can create this effect as well. It can drive incandescent lamps up to 12V, and allowing it to be powered easily from most layouts.

The kit was originally described in the Talking Electronics book “Electronics for Model Railways” (volume 1) which was full of useful and interesting electronics to liven up any layout. The book may now out of print however at the time of writing this you can download or view most of the projects from the index column of the Talking Electronics website… or contact Talking Electronics if they have any copies of the book (or kit) to sell.

Assembly

Time was not kind to the kit, to be frank it was surprising to find one at all:

Talking Electronics Fluorescent Simulator kit

(Just a note for any over-enthusiastic readers, Talking Electronics is no longer at the address on the bag shown above). However it was complete and ready for assembly. The PCB has a silk-screen with the required component placement information, polarities and so on – a first for the time:

Talking Electronics Fluorescent Simulator PCB top

Talking Electronics Fluorescent Simulator PCB bottom

The instructions and “how it works” are not included with the kit as you were meant to have the book, however TE have made them available as a separate download (.pdf) The kit included everything required to get started, and there’s an LED which replicates the effect so you can test the board without having to watch the connected bulb (which may be a distance away). Finally an IC socket is included :)

Talking Electronics Fluorescent Simulator parts

The actual assembly process was very straight forward, which simply required starting with the low-profile components and working up to the large ones:

Talking Electronics Fluorescent Simulator assembly 1

The only problem with the PCB was the holes – looks like only one drill size had been used (apart from the mounting holes) which made getting that rectifier diode in a little tricky. Otherwise it was smooth sailing.

Talking Electronics Fluorescent Simulator finished 2

Not having a model railway at the moment left me with the simple example of the onboard LED and a small incandescent globe to try with the circuit. You can see the kit working in this video.

John – Why do you publish these “Old Kit Reviews”?

They’re more of  a selfish article, like many electronics enthusiasts I have enjoyed kits for decades – and finding kits from days gone by is a treat. From various feedback some of you are enjoying them, so they will continue for fun and some nostalgia. If you’re not interested, just ignore the posts starting with “Old”!

Conclusion

For a kit from the mid-1980s, this would have solved the problem neatly for model railway enthusiasts. By using two or more of the kits with different capacitor values, many model lights could blink on with seemingly random patterns. However it’s 2014 so you could use a PIC10F200 or ATtiny45 and reduce the board space and increase the blinking potential.

Nevertheless, it was an interesting example of what’s possible with a digital logic IC. Full-sized images and a lot more information about the kit are available on flickr. And if you enjoyed this article, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop”.

visit tronixlabs.com

Have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, 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. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in electronics, kit review, talking electronics, tronixstuff

Old Kit Review – Silicon Chip Transistor Beta Tester

Introduction

After exploring a quiet , dusty electronics store in the depths of suburbia the other week, I came across this kit from Altronics (K2534) which is the subject of this review. The Transistor Beta tester is the second revision of a tester designed by John Clarke for the March 1991 issue of Silicon Chip magazine, and promises to offer a simple way of measuring the gain of almost any NPN or PNP bipolar transistor. But first some public answers to recent feedback…

John – Why do you publish these “Old Kit Reviews”?

They’re more of  a selfish article, like many electronics enthusiasts I’ve enjoyed kits for decades – and finding kits from days gone by is a treat. From various feedback some of you are enjoying them, so I’ll continue with them for fun and some nostalgia. If you’re not interested, just ignore the posts starting with “Old”!

Where’s the schematic?

After publishing a few kit reviews, people have been asking me for the schematics. For kits that are based on magazine articles from Silicon Chip and the like, the details are Copyright and I can’t legitimately give you a copy. You need to contact the magazine or kit supplier. The surviving electronics magazines often run “on the smell of an oily rag” so in order to support them I promote the idea of paying for copies which are obtainable from the magazine. Plus Australia is a small country, where people in this industry know each other through first or second connections – so I don’t want to annoy the wrong people. However Google is an awesome tool,  and if you want to make your own beta tester there are many example circuits to be found – so have fun.

Back to the review – what is “beta”?

Apart from a letter of the Greek alphabet and a totally-underrated form of VCR format, beta is a term used to define the amount of gain of a transistor. From the guide:

Silicon Chip transistor beta tester what is beta

Assembly

Here’s our kit from 1991, rescued from the darkness of the store:

Silicon Chip transistor beta tester packaging

Which contained the nice box, plus all the required components except for an IC socket, and a few screws and mounting nuts that should have been included. The instructions looked to be a photocopy of a photocopy, harking back to the 1980s…

Silicon Chip transistor beta tester contents

Silicon Chip transistor beta tester components

Looks like an off-brand 555 has been used (or substituted), however a bit of research indicated that it is most likely from LG Semiconductor:

Silicon Chip transistor beta tester off brand 555

The PCB was made to the usual standard at the time, just drilled:

Silicon Chip transistor beta tester PCB rear

Silicon Chip transistor beta tester PCB front

The front panel was well done, and kindly pre-drilled by a previous customer. The kit came with a 3mm LED however this mystery person had drilled the hole out for a 5mm:

Silicon Chip transistor beta tester front panel

… but hadn’t cut the oblong for the slide switch wide enough. But the biggest problem was that the PCB was just a smidge too wide for the included enclosure:

Silicon Chip transistor beta tester PCB not fitting

Nevertheless it was time to get started, and the resistors were measured, lined up and fitted:

Silicon Chip transistor beta tester resistors lined up

Then the rest of the components fitted as normal, however they need to stay below the horizontal level of the slide switch bezel:

Silicon Chip transistor beta tester assembly 1

… which was somewhat successful. Then to fit the potentiometer, battery snap …

Silicon Chip transistor beta tester assembly 2

and the test leads:

Silicon Chip transistor beta tester assembly 3

 And we’re finished:

Silicon Chip transistor beta tester finished

How it works

Operation is quite simple, just wire up the test leads to the transistor’s base, collector and emitter – set the PNP/NPN switch and press test. Then you turn the knob until the LED just turns on – at which point the scale indicates the gain.

“Modern-day” replacements

Digital technology has taken over with this regard, and a device such as the one below can not only give the gain, but also the component details, identify legs, and much more:

Silicon Chip transistor beta tester modern tester gain

I’ll be sticking with this one for the time being. Jaycar have discontinued the analyser shown above, but Altronics have the “Peak” unit which looks even more useful.

Conclusion

Well… that was fun. A lot of promise, however with a few details not taken care of the kit was just a bit off. Considering this was around twenty years old and possibly shop-soiled I can’t complain. For the record the good people at Altronics have a great line of kits. Full-sized images and a lot more information about the kit are available on flickr.

And while you’re here – are you interested in Arduino? Check out my new book “Arduino Workshop” from No Starch Press.

ledborder

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in altronics, K2534, kit review, test equipment, tronixstuffComments (3)

Kit Review – Jaycar “Short Circuits” 3 Digit Counter

Introduction

Time for another kit review and in this instalment we have a look at the “3 digit counter” kit from Jaycar. This is part of a much larger series of kits that are described in a three volume set of educational books from Jaycar titled “Short Circuits”.

Aimed at the younger readers or anyone who has an interest in learning electronics, these books (volumes one, two and three) are well written and with some study and practice the reader will make a large variety of projects and learn quite a bit. They could be considered as a worthy 21st-century replacement to the old Dick Smith “Funway…” guides.

The purpose of this kit is to give you a device which can count upwards between zero and 999 – which can be used for various purposes and also of course to learn about digital electronics.

Assembly

The kit arrives in typical retail fashion:

Jaycar Short Circuits Counter Kit packaging

Everything you need to make the counter is included except for the instructions – which are found in the “Short Circuits” volume two book – and IC sockets. Kits for beginners with should come with IC sockets.

Jaycar Short Circuits Counter Kit contents

The components are separated neatly in the bag above, and it was interesting to see the use of zero ohm resistors for the two links on the board:

KJ8234 Jaycar Short Circuits Counter Kit components

The PCB is excellent. The silk screening and solder-mask is very well done.

KJ8234 Jaycar Short Circuits Counter Kit PCB top

Jaycar Short Circuits Counter Kit PCB bottom KJ8234

Furthermore I was really, really impressed with the level of detail with the drilling. The designer has allowed for components with different pin spacing – for example the 100 nF capacitor and transistors as shown below:

Jaycar Short Circuits Counter Kit PCB detail KJ8234

The instructions in the book are very clear and are written in an approachable fashion:

Jaycar Short Circuits Counter Kit instructions KJ8234

Jaycar Short Circuits Counter Kit instructions two KJ8234

There’s also a detailed explanation on how the circuit works, some interesting BCD to decimal notes, examples of use (slot cars!) and a neat diagram showing how to mount the kit in a box using various parts from Jaycar – so you’re not left on your own.

Construction went well, starting with the low-profile parts:

Jaycar Short Circuits Counter Kit assembly 1 KJ8234

… then the semiconductors:

Jaycar Short Circuits Counter Kit assembly 2 KJ8234

… then the higher-profile parts and we’re finished:

Jaycar Short Circuits Counter Kit assembly finished KJ8234

There wasn’t any difficulty at all, and the counter worked first time. Although I’m not a new user, the quality of PCB and instructions would have been a contributing factor to the success of the kit.

How it works

The input signal for the counter (in this case a button controlling current from the supply rail) is “squared-up” by an MC14093 schmitt-trigger IC, which then feeds a MC14553 BCD counter IC, which counts and then feeds the results to a 4511 BCD to 7-segment converter to drive the LED digits which are multiplexed by the MC14553. For the schematic and details please refer to the book. Operation is simple, and demonstrated in the following video:

However you can feed the counter an external signal, by simply applying it to the input section of the circuit. After a quick modification:

Jaycar Short Circuits Counter Kit counter input KJ8234

… it was ready to be connected to a function generator. In the following video we send pulses with a varying frequency up to 2 kHz:

Conclusion

This is a neat kit, works well and with the accompanying book makes a good explanation of a popular digital electronics subject. There aren’t many good “electronics for beginners” books on the market any more, howevert the “Short Circuits” range from Jaycar really fit the bill.

So if you’re looking to learn more about electronics or start someone else off, head in to Jaycar and have a look. Readers from outside Australia are also covered. Full-sized images are available on flickr.

And while you’re here – are you interested in Arduino? Check out my new book “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

[Note - kit and book purchased without notifying the supplier]

Posted in education, electronics, jaycar, kit, kit review, KJ8234, tronixstuffComments (4)

Tutorial – Send email with the Arduino Yún

Introduction

This is the third in a series of tutorials examining various uses of the Arduino Yún. In this article we’ll examine how your Arduino Yún can send email from a Google email account. Doing so gives you a neat and simple method of sending data captured by the Arduino Yún or other notifications.

Getting Started

If you haven’t already done so, ensure your Arduino Yún can connect to your network via WiFi or cable – and get a Temboo account (we run through this here). And you need (at the time of writing) IDE version 1.5.4 which can be downloaded from the Arduino website.

Finally, you will need a Google account to send email from, so if you don’t have one – sign up here. You might want to give your Arduino Yún an email address of its very own.

Arduino Yun Yún front

Testing the Arduino Yún-Gmail connection

In this first example we’ll run through the sketch provided by Temboo so you can confirm everything works as it should. This will send a simple email from your Arduino Yún to another email address. First, copy the following sketch into the IDE but don’t upload it yet:

Before uploading you need to enter five parameters – the email address to send the email with, the password for that account, the recipient’s email address, and the email’s subject line and content. These can be found in the following lines in the sketch – for example:

So enter the required data in the fields above. If you’re sending from a Google Apps account instead of a Gmail account – that’s ok, just enter in the sending email address as normal. Temboo and Google will take care of the rest.

Finally, create your header file by copying the the header file data from here (after logging to Temboo) into a text file and saving it with the name TembooAccount.h in the same folder as your sketch from above. You know this has been successful when opening the sketch, as you will see the header file in a second tab, for example:

arduino yun temboo header file

Now you can upload the sketch, and after a few moments check the recipient’s email account. If all goes well you will be informed by the IDE serial monitor as well (if your Yún is connected via USB). It’s satisfying to see an email come from your Arduino Yún, for example in this short video.

If your email is not coming through, connect your Arduino Yún via USB (if not already done so) and open the serial monitor. It will let you know if there’s a problem in relatively plain English – for example:

Error
A Step Error has occurred: “An SMTP error has occurred. Make sure that your credentials are correct and that you’ve provided a fully qualified Gmail
username (e.g., [email protected]) for the Username input. When using Google 2-Step Verification, make sure to
provide an application-specific password. If this problem persists, Google may be restricting access to your account, and you’ll need to
explicitly allow access via gmail.com.”. The error occurred in the Stop (Authentication error) step.
HTTP_CODE
500


So if this happens, check your email account details in the sketch, and try again.

Sending email with customisable subject and content data

The example sketch above is fine if you want to send a fixed message. However what if you need to send some data? That can be easily done. For our example we’ll generate some random numbers, and integrate them into the email subject line and content. This will give you the framework to add your own sensor data to emails from your Arduino Yún. Consider the following sketch:

Review the first section at the start of void loop(). We have generated two random numbers, and then appended some text and the numbers into two Strings – emailContent and emailSubject.

These are then inserted into the SendEmailChoreo.addInput lines to be the email subject and content. With a little effort you can make a neat email notification, such as shown in this video and the following image from a mobile phone:

arduino yun email demonstration

Conclusion

It’s no secret that the Yún isn’t the cheapest development board around, however the ease of use as demonstrated in this tutorial shows that the time saved in setup and application is more than worth the purchase price of the board and extra Temboo credits if required.

And if you’re interested in learning more about Arduino, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop” from No Starch Press.

tronixstuff

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, email, gmail, iot, temboo, tutorial, YúnComments (5)

Old Kit Review – Silicon Chip Mini Stereo Amplifier

Introduction

In this review of an older kit we examine the aptly-named “Mini Stereo Amplifier” from Dick Smith Electronics (catalogue number K5008), based on the article published in the October 1992 issue of Silicon Chip magazine.

The purpose of the kit is to offer a stereo 1W+1W RMS amplifier for use with portable audio devices that only used headphones, such as the typical portable tape players or newly available portable CD players. I feel old just writing that. At the time it would have been quite a useful kit, paired with some inexpensive speakers the end user would have a neat and portable sound solution. So let’s get started.

Assembly

Larger kits like this one that couldn’t be retailed on hanger cards shipped in corrugated cardboard boxes that were glued shut. They looked good but as soon as a sneaky customer tore one open “to have a look” it was ruined and hard to sell:

Dick Smith Electronics K5008 Stereo Amplifier Kit box

The amplifier kit was from the time when DSE still cared about kits, so you received the sixteen page “Guide to Kit Construction” plus the kit instructions, nasty red disclaimer sheet, feedback card, plus all the required components and the obligatory coil of solder that was usually rubbish:

Dick Smith Electronics K5008 Stereo Amplifier Kit all contents

However the completeness of the kit is outstanding, everything is included for completion including an enclosure and handy front panel sticker:

Dick Smith Electronics K5008 Stereo Amplifier Kit enclosure face sticker

… all the sockets, plenty of jumper wire and even the rubber feet:

Dick Smith Electronics K5008 Stereo Amplifier Kit components

The PCB is from the old-school of design – without any silk-screening or solder mask:

Dick Smith Electronics K5008 Stereo Amplifier Kit PCB front

Dick Smith Electronics K5008 Stereo Amplifier Kit PCB rear

However the instructions are quite clear so you can figure out the component placement easily. Which brings us to that point – all the components went in with ease:

Dick Smith Electronics K5008 Stereo Amplifier Kit PCB partial assembly

… then it was a matter of wiring in the sockets, volume potentiometer and power switch:

Dick Smith Electronics K5008 Stereo Amplifier Kit socket wiring

Instead of using a 3.5mm phono socket for power input, I used a 9V battery snap instead. The amplifier can run on voltages down to 1.8V so it will do for the limited use I have in mind for the amplifier. However in the excitement of assembly I forgot the power switch:

Dick Smith Electronics K5008 Stereo Amplifier Kit PCB forgot the switch

However it wasn’t any effort to rectify that. You will also notice three links on the PCB, which I fitted instead of making coils (more on this later). So at that point the soldering work is finished:

Dick Smith Electronics K5008 Stereo Amplifier Kit PCB finished

Now to drill out the holes on the faceplate. Instead of tapering out the slots on the side of the housing, I just drilled all the holes on the front panel:

Dick Smith Electronics K5008 Stereo Amplifier Kit panel

Turns out the adhesive on the front panel sticker had lost its mojo, so I might head off and get some white-on-black tape for the label maker. However in the meanwhile we have one finished mini stereo amplifier, which reminds me of an old grade seven electronics project:

Dick Smith Electronics K5008 Stereo Amplifier Kit finished

How it works

The amplifier is based on the STMicro TDA2822M (data sheet .pdf) dual low-voltage amplifier IC. In fact the circuit is a slight modification of the stereo example in the data sheet. As mentioned earlier, the benefit of this IC is that it can operate on voltates down to 1.8V, however to reach the maximum power output of 1W per channel into 8Ω loads you need a 9V supply. The output will drop to around 300 mW at 6V.

Finally the Silicon Chip design calls for a triplet of coils, one each on the stereo input wires – used to prevent the RF signal being “shunted away” from the amplifier inputs. The idea behind that was some portable radios used the headphones as an antenna, however we’ll use it with the audio out from a mobile phone so it was easier to skip hand-winding the coils and just put links in the PCB.

Using the Amplifier

The purpose of this kit was to have some sound while working in the garage, so I’ve fitted a pair of cheap 1W 8Ω speakers each to a length of wire and a 3.5mm plug as shown in the image above. And for that purpose, it works very well. In hindsight it turns out the speakers were rated at 1W peak not RMS, however they still sound great.

Conclusion

Another kit review over. This is a genuinely useful kit and a real shame you can’t buy one today. And again – to those who have been asking me privately, no I don’t have a secret line to some underground warehouse of old kits – just keep an eye out on ebay as they pop up now and again. Full-sized images and much more information about the kit are available on flickr.

And while you’re here – are you interested in Arduino? Check out my new book “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in DSE, kit review, tronixstuffComments (1)

Kit Review – Altronics 3 Digit Counter Module

Introduction

In this review we examine the three digit counter module kit from Altronics. The purpose of this kit is to allow you to … count things. You feed it a pulse, which it counts on the rising edge of the signal. You can have it count up or down, and each kit includes three digits.

You can add more digits, in groups of three with a maximum of thirty digits. Plus it’s based on simple digital electronics (no microcontrollers here) so there’s some learning afoot as well. Designed by Graham Cattley the kit was first described in the now-defunct (thanks Graham) January 1998 issue of Electronics Australia magazine.

Assembly

The kit arrives in the typical retail fashion:

Altronics K2505 Counter Module Kit

And includes the magazine article reprint along with Altronics’ “electronics reference sheet” which covers many useful topics such as resistor colour codes, various formulae, PCB track widths, pinouts and more. There is also a small addendum which uses two extra (and included) diodes for input protection on the clock signal:

Altronics K2505 Counter Module Kit instructions

The counter is ideally designed to be mounted inside an enclosure of your own choosing, so everything required to build a working counter is included however that’s it:

Altronics K2505 Counter Module Kit parts

No IC sockets, however I decided to live dangerously and not use them – the ICs are common and easily found. The PCBs have a good solder mask and silk screen:

Altronics K2505 Counter Module Kit PCBs

Altronics K2505 Counter Module Kit PCBs rear

With four PCBs (one each for a digit control and one for the displays) the best way to start was to get the common parts out of the way and fitted, such as the current-limiting resistors, links, ICs, capacitors and the display module. The supplied current-limiting resistors are for use with a 9V DC supply, however details for other values are provided in the instructions:

Altronics K2505 Counter Module Kit

Altronics K2505 Counter Module Kit

Altronics K2505 Counter Module Kit

At this point you put one of the control boards aside, and then start fitting the other two to the display board. This involves holding the two at ninety degrees then soldering the PCB pads to the SIL pins on the back of the display board. Starting with the control board for the hundreds digit first:

Altronics K2505 Counter Module Kit

Altronics K2505 Counter Module Kit

… at this stage you can power the board for a quick test:

Altronics K2505 Counter Module Kit

… then fit the other control board for the tens digit and repeat:

Altronics K2505 Counter Module Kit

Now it’s time to work with the third control board. This one looks after the one’s column and also a few features of the board. Several functions such as display blanking, latch (freeze the display while still counting) and gate (start or stop counting) can be controlled and require resistors fitted to this board which are detailed in the instructions.

Finally, several lengths of wire (included) are soldered to this board so that they can run through the other two to carry signals such as 5V, GND, latch, reset, gate and so on:

Altronics K2505 Counter Module Kit

These wires can then be pulled through and soldered to the matching pads once the last board has been soldered to the display board:

Altronics K2505 Counter Module Kit

 You also need to run separate wires between the carry-out and clock-in pins between the digit control boards (the curved ones between the PCBs):

Altronics K2505 Counter Module Kit

For real-life use you also need some robust connections for the power, clock, reset lines, etc., however for demonstration use I just used alligator clips. Once completed a quick power-up showed the LEDs all working:

Altronics K2505 Counter Module Kit

How it works

Each digit is driven by a common IC pairing – the  4029 (data sheet) is a presettable up/down counter with a BCD (binary-coded decimal) output which feeds a 4511 (data sheet) that converts the BCD signal into outputs for a 7-segment LED display. You can count at any readable speed, and I threw a 2 kHz square-wave at the counter and it didn’t miss a beat. By default the units count upwards, however by setting one pin on the board LOW you can count downwards.

Operation

Using the counters is a simple matter of connecting power, the signal to count and deciding upon display blanking and the direction of counting. Here’s a quick video of counting up, and here it is counting back down.

Conclusion

This is a neat kit that can be used to count pulses from almost anything. Although some care needs to be taken when soldering, this isn’t anything that cannot be overcome without a little patience and diligence. So if you need to count something, get one ore more of these kits from Altronics. Full-sized images are available on flickr. And while you’re here – are you interested in Arduino? Check out my new book “Arduino Workshop” from No Starch Press – also shortly available from Altronics.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in altronics, cmos, counter, K2505, kit, kit review, LED, tronixstuffComments (0)

Tutorial – Google Docs and the Arduino Yún

Introduction

This is the second in a series of tutorials examining various uses of the Arduino Yún. In this article we’ll examine how your Arduino Yún can send data that it captures from the analogue and digital inputs and a real-time clock IC to an online Google Docs spreadsheet. Doing so gives you a neat and inexpensive method of capturing data in real-time and having the ability to analyse the data from almost anywhere, and export it with very little effort.

Getting Started

If you haven’t already done so, ensure your Arduino Yún can connect to your network via WiFi or cable – and get a Temboo account (we run through this here). And you need (at the time of writing) IDE version 1.5.4 which can be downloaded from the Arduino website. Finally, you will need a Google account, so if you don’t have one – sign up here.

Arduino Yun Yún front

Testing the Arduino Yún-Google Docs connection

In this first example we’ll run through the sketch provided by Temboo so you can confirm everything works as it should. First of all, create a spreadsheet in Google Docs. Call it “ArduinoData” and label the first two columns as “time” and “sensor”, as shown in the screen shot below:

Arduino Yun Google Docs Spreadsheet

Always label the required columns. You can call them whatever you need. For new Google users, the URL shown in my example will be different to yours. Next, copy the following sketch to the IDE:

Now look for the following two lines in the sketch:

This is where you put your Google account username and password. For example, if your Google account is “[email protected]” and password “RS2000Escort” the two lines will be:

Next, you need to insert the spreadsheet name in the sketch. Look for the following line:

and change your-spreadsheet-title to ArduinoData. 

Finally, create your header file by copying the the header file data from here (after logging to Temboo) into a text file and saving it with the name TembooAccount.h in the same folder as your sketch from above. You know this has been successful when opening the sketch, as you will see the header file in a second tab, for example:

Arduino Yun sketch header file

Finally, save and upload your sketch to the Arduino Yún. After a moment or two it will send values to the spreadsheet, and repeat this every sixty seconds – for example:

Arduino Yun Google Docs Spreadsheet data

If your Yún is connected via USB you can also watch the status via the serial monitor.

 One really super-cool and convenient feature of using Google Docs is that you can access it from almost anywhere. Desktop, tablet, mobile… and it updates in real-time:

Arduino Yun_ Google Docs Spreadsheet_data_mobile

So with your Yún you can capture data and view it from anywhere you can access the Internet. Now let’s do just that.

Sending your own data from the Arduino Yún to a Google Docs Spreadsheet

In this example we’ll demonstrate sending three types of data:

With these types of data you should be able to represent all manner of things. We use the RTC as the time and date from it will match when the data was captured, not when the data was written to the spreadsheet. If you don’t have a DS3232 you can also use a DS1307.

If you’re not familiar with these parts and the required code please review this tutorial. When connecting your RTC – please note that SDA (data) is D2 and SCL (clock) is D3 on the Yún.

The sketch for this example is a modified version of the previous sketch, except we have more data to send. The data is captured into variables from the line:

You can send whatever data you like, as long as it is all appended to a String by the name of rowdata. When you want to use a new column in the spreadsheet, simply append a comma “,” between the data in the string. In other words, you’re creating a string of CSV (comma-separated values) data. You can see this process happen from the line that has the comment:

in the example sketch that follows shortly. Finally, you can alter the update rate of the sketch – it’s set to every 60 seconds, however you can change this by altering the 60000 (milliseconds) in the following line:

Don’t forget that each update costs you a call and some data from your Temboo account – you only get so many for free then you have to pay for more. Check your Temboo account for more details.

So without further ado, the following sketch will write the values read from A0~A3, the status of D7 and D8 (1 for HIGH, 0 for LOW) along with the current date and time to the spreadsheet. Don’t forget to update the password, username and so on as you did for the first example sketch:

… which in our example resulted with the following:

Arduino Yun Google Docs Spreadsheet time date data

… and here is a video that shows how the spreadsheet updates in real time across multiple devices:

 Conclusion

It’s no secret that the Yún isn’t the cheapest devleopment board around, however the ease of use as demonstrated in this tutorial shows that the time saved in setup and application is more than worth the purchase price of the board and extra Temboo credits if required.

And if you’re interested in learning more about Arduino, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in arduino, DS3232, Google Docs, iot, spreadsheet, temboo, tronixstuff, tutorial, YúnComments (10)

Old Kit Review – Diesel Sound Simulator for Model Railroads

Introduction

In this review of an older kit (circa 1993~1997) we examine the Diesel Sound Simulator for Model Railroads kit from (the now defunct) Dick Smith Electronics, based on the article published in the December 1992 issue of Silicon Chip magazine.

The purpose of this kit is to give you a small circuit which can fit in a HO scale (or larger) locomotive, or hidden underneath the layout – that can emulate the rumbling of a diesel-electric locomotive to increase the realism of a train. However the kit is designed for use with a PWM train controller (also devised by Silicon Chip!) so not for the simple direct-DC drive layouts.

K3030 diesel sound simulator kit

Assembly

The diesel sound kit was from the time when DSE still cared about kits, so you received the sixteen page “Guide to Kit Construction” plus the kit instructions, nasty red disclaimer sheet, feedback card, plus all the required components and the obligatory coil of solder that was usually rubbish:

K3030 diesel sound simulator kit contents

Everything required to get going is included, except IC sockets. My theory is it’s cheaper to use your own sockets than source older CMOS/TTL later on if you want to reuse the ICs, so sockets are now mandatory here:

K3030 diesel sound simulator kit parts

The PCB is from the old school of “figure-it-out-yourself”, no fancy silk-screening here:

K3030 diesel sound simulator kit PCB

K3030 diesel sound simulator kit PCB bottom

Notice the five horizontal pads between the two ICs – these were for wire bridges in case you needed to break the PCB in two to fit inside your locomotive.

Actual assembly was straight-forward, all the components went in without any issues. Having two links under IC2 was a little annoying, however a short while later the PCB was finished and the speaker attached:

K3030 diesel sound simulator kit finished

How it works

As mentioned earlier this diesel sound kit was designed for use with the Silicon Chip train PWM controller, so the design is a little different than expected. It can handle a voltage of around 20 V, and the sound is determined by the speed of the locomotive.

The speed is determined by the back EMF measured from the motor – and (from the manual) this is the voltage produced by the motor which opposes the current flow through it and this voltage is directly proportional to speed.

Not having a 20V DC PWM supply laying about I knocked up an Arduino to PWM a 20V DC supply via an N-MOSFET module and experimented with the duty cycle to see what sort of noises could be possible. The output was affected somewhat by the supply voltage, however seemed a little higher in pitch than expected.

You can listen to the results in the following video:

I reckon the sound from around the twenty second mark isn’t a bad idle noise, however in general not that great. The results will ultimately be a function of a lower duty-cycle than I could create at the time and the values of R1 and R2 used in the kit.

 Conclusion

Another kit review over. With some time spent experimenting you could generate the required diesel sounds, a Paxman-Valenta it isn’t… but it was a fun kit and I’m sure it was well-received at the time. To those who have been asking me privately, no I don’t have a secret line to some underground warehouse of old kits – just keep an eye out on ebay and they pop up now and again. Full-sized images and much more information about the kit are available on flickr.

And while you’re here – are you interested in Arduino? Check out my new book “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in DSE, electronics, K3030, kit, kit review, model railway, tronixstuffComments (2)

Kit Review – Altronics Pocket Oscillator

Introduction

In this review we examine the Pocket Oscillator Kit from Altronics, based on an design from (the now defunct) February and March 1989 editions of Electronics Australia magazine. The purpose of this oscillator is to give you a high quality, portable square or sine wave generator that can be used to test audio equipment, speaker response, fool about with oscilloscopes (!), and so on. The prototype basic specifications are as follows:

  • Frequency range: 41~1082 Hz and 735 Hz~18.1 kHz
  • Output: 1.27V RMS sine, 1.45V peak square
  • Load: 1.0V RMS sine into 330 Ω
  • Distortion: 0.16% THD at 1 kHz

Assembly

The kit is packaged in typical form, without any surprises:

Altronics K2544

In the usual Altronics fashion, the instructions are accompanied with a neat “electronics reference sheet” which covers many useful topics such as resistor colour codes, various formulae, PCB track widths, pinouts and more. The kit instructions are based on the original magazine article and include a small addendum which isn’t any problem.

Altronics_K2544_instructions

Unlike some kits, everything is included to create a finished product (except for the IC socket):

Altronics K2544 parts

… including a nice enclosure which has the control instructions screen-printed on the lid…

Altronics K2544 enclosure

However at this point I think the definition of a “pocket” is the same used by Sir Clive Sinclair when he had those pocket televisions. At this time I won’t use the enclosure as my drill press is in storage, however look forward to fitting the kit within at a later point. The PCB has a neat solder mask and silk screen:

Altronics K2544 PCB top

Altronics K2544 PCB bottom

Assembly was pretty straight forward, the original design has tried to minimise PCB real-estate, so all the resistors are mounted vertically. The signal diodes take this a step further – each pair needs to be soldered together:

Altronics K2544 diodes

… then the pair is also mounted vertically:

Altronics K2544 diodes mounted

However it all works in the end. The rest of the circuit went together well, and we used our own IC socket for the opamp:

Altronics K2544 assembled PCB

From this point you need to wire up the power, switches and potentiometers:

Altronics K2544 assembly

… and consider mounting the whole lot in the enclosure (or before assembly!):

Altronics K2544 lid

However as mentioned earlier, I just went for the open octopus method for time being:

Altronics K2544 finished

How it works

The oscillator is based around the Texas Instruments TL064 opamp, and due to copyright I can’t give you the schematic. For complete details on the oscillator, either purchase the kit or locate the February and March 1989 edition of Electronics Australia magazine. However the waveforms from the oscillator looked good (as far as they can on a DSO):

Altronics Pocket Audio Oscillator K2544 sine wave output

Altronics Pocket Audio Oscillator K2544 sine wave output

Altronics Pocket Audio Oscillator K2544 square wave output

Altronics Pocket Audio Oscillator K2544 square wave output

Conclusion

The oscillator works well, however the PCB layout could have been a little lot easier on the end-user. It’s time for a redesign, possibly put all the contacts for external switches around the perimeter – and allow space for the diodes to lay normally. Nevertheless – this is a neat kit, and still quite popular after all these years. For the price you get a few hours of kit fun and a useful piece of test equipment. So if you’re into audio or experimenting, check it out. Full-sized images are available on flickr.

And while you’re here – are you interested in Arduino? Check out my new book “Arduino Workshop” from No Starch Press – also shortly available from Altronics.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

[Note - kit purchased without notifying the supplier]

Posted in altronics, K2544, kit, kit review, tronixstuffComments (3)

Review – “Ardublock” graphical programming for Arduino

Introduction

After helping many people get started with the world of Arduino and electronics,  we still find a small percentage of people who are turned off by the concept of programming or have trouble breaking larger tasks into smaller ones with regards to writing algorithms for their code/sketch.

So after being introduced to a new graphical programming tool called “Ardublock“, we were excited about the possibilities wanted to share it with our readers. Ardublock provides a truly graphical and non-coding solution to controlling an Arduino, that is an open-source product and thus free to download and try for yourself.

Installation

Ardublock is a Java application that runs from inside the Arduino IDE, which can be downloaded from here. It’s only one file, that needs to be placed in a new folder in the Arduino IDE. The folder names must be the same as shown below:

ardublock installation folder

Once you’ve copied the file, simply open the Arduino IDE and select Ardublock from the Tools menu:

arduino ide tools menu ardublockFrom which point a new window appears – the Ardublock “development environment”:

ardublock development environment

 Using Ardublock

It’s quite simple – you simply select the required function from the menu on the left and drag it into the large area on the right. For a quick example where we blink the onboard LED on and off – watch the following video:

 

The following image is the screen capture of the program from the video:

ardublock LED Blink

As you can see the “blocks” just fit together, and parameters can be changed with the right mouse button. After a few moments experimenting with the Ardublock software you will have the hang of it in no time at all.

And thus you can demonstrate it to other people and show them how easy it is. And there is much more than just digital output controls, all the functions you’re used to including I2C, variables, constants, servos, tone and more are available.

The only technical thing you need to demonstrate is that the Arduino IDE needs to stay open in the background – as once you have finished creating your program, Ardublock creates the required real Arduino sketch back in the IDE and uploads it to the board.

This is also a neat function – the user can then compare their Ardublock program against the actual sketch, and hopefully after a short duration the user will have the confidence to move on with normal coding.

Conclusion

Ardublock provides a very simple method of controlling an Arduino, and makes a great starting point for teaching the coding-averse, very young people or the cognitively-challenged. It’s open source, integrates well with the official IDE and works as described – so give it a go.

And if you enjoyed this review, or want to introduce someone else to the interesting world of Arduino – check out my book (now in a third printing!) “Arduino Workshop” from No Starch Press.

tronixstuff

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in ardublock, arduino, software, software review, tronixstuff, tutorialComments (3)

Review – NXP LPC800-MAX Development Board

Introduction

Now and again we examine various development boards designed for use with the mbed development platform for ARM microcontrollers, such as the the original mbed unit and the Freescale Freedom FRDM-KL25Z – and now we have another one from NXP … their new LPC800-MAX development board:

LPC800-MAX front PCB

LPC800-MAX rear PCB

Although the LPC800-MAX works with the mbed online compiler, you’re not limited to that. NXP have also supplied free offline development tools based on the Eclipse IDE.

Hardware specification

The board is based on the NXP LPC812 with an ARM Cortex-M0+ Core running at 30 MHz. The LPC812 has 16KB flash memory, and 4KB RAM. For I/O you have 3 x USARTs, 2 x SPI ports,  one comparator, and one I2C port. The serial lines are brought out to a separate serial expansion connector to allow easy connection to a range of expansion boards from the manufacturer. An RGB LED is fitted to the board for all the “hello, world” fun you could want, and for extra I/O (and I2C practice) there’s a four-channel NXP PCF8591 ADC (and also gives you one DAC as well – convenient) along with a PCA9672 I/O expander IC for more GPIO. 

If you’re using the offline development IDE you can also make use of the NXP hardware debugging interface as well. Users of the physically-narrow range of NXP LPC development boards will also recognise the two parallel rows of pinouts down the length of the PCB, and Arduino users will recognise the header sockets (more on those later). When you receive the board – you just receive the board, so you’ll need a typical microUSB cable. Finally, you can download the LPC800 MAX schematic for further examination.

What is mbed anyway?

mbed is a completely online development environment. That is, in a manner very similar to cloud computing services such as Google Docs. However there are some pros and cons of this method. The pros include not having to install any software on the PC – as long as you have a web browser and a USB port you should be fine; any new libraries or IDE updates are handled on the server leaving you to not worry about staying up to date; and the online environment can monitor and update your MCU firmware if necessary.

However the cons are that you cannot work with your code off-line (no working in-flight) and there may be some possible privacy issues. Here’s an example of the environment:

mbed compiler screen

As you can see the IDE is quite straight-forward. All your projects can be found on the left column, the editor in the main window and compiler and other messages in the bottom window. There’s also an online support forum, an official mbed library and user-submitted library database, help files and so on – so there’s plenty of support.

Code is written in C/C++ style and doesn’t present any major hurdles. When it comes time to run the code, the online compiler creates a downloadable binary file which is copied over to the hardware via USB, from which point you reset the board and off it goes.

If you’re using the LPC800-MAX with mbed, be sure to follow the “Getting Started” guide and also check for the latest firmware from the mbed handbook. And although the mbed board appears as a USB storage device, you can still have serial communication with a PC using a virtual serial port via the USB cable connected between the PC and the LPC800-MAX.

Arduino form-factor compatibility

You will notice the header sockets physically match the Arduino Uno R3 specification, so you can drop in an Arduino shield. However the board runs on 3.3V and is 5V-tolerant, so it’s preferable your shields or new designs are good for 3.3V operation. Furthermore, as the onboard LPC812 doesn’t have as much analogue and digital I/O as an ATmega328P found on the Arduino Uno, the extra I/O are provided by two external ICs via I2C. Four analogue inputs are provided by the onboard NXP PCF8591 ADC (and also gives you one DAC as well – convenient) – and the equivalent A4 and A5 pins are not ADC, instead they’re just I2C SDA and SCL respectively.

The extra digital I/O pins are provided via I2C by the aforementioned PCA9672 I/O expander IC. Upon reflection you’d have to be very keen to use a specific Arduino shield as some extra coding would be required to deal with the required I/O – however on the other hand you can easily add external circuitry with blank Arduino protoshields for new projects. Finally, here’s a pin map of the shield connectors.

LPC-800 pin map

Not a fan of mbed? Offline tools

NXP have also made their LPCXpressoIDE based on Eclipse available for free download for all platforms – http://lpcware.com/lpcxpresso/download. The free version is good for up to 256 KB code size (provided you register the software) which more than covers the requirements for this and other LPC800 products:

LPCXpresso IDE screenshot

For more information and support, there is a huge repository of information on the NXP website.

Where to get an LPC800-MAX

The board is manufactured and sold by Embedded Artists. At the time of writing the board retails for €15, which is around US$21. NXP also have a range of LPC800 microcontrollers, including very inexpensive through-hole 8-pin versions which are available from the usual retailers. And adafruit of all places have a US$13 starter pack based around the DIP LPC810, which is an interesting 32-bit alternative to the ATtinys out there.

Conclusion

If you’re interested in working with the NXP LPC800-series of microcontrollers, the LPC800-MAX board is a very convenient development board considering the included debugger, Arduino protoshield capability, external GPIO expander and ADC/DAC and onboard LED – as well as the free IDE.

If you enjoy the mbed development environment, the board gives you another hardware option. However if you’re an Arduino user looking for a cheap way of getting a faster board whilst using your existing environment – this is not for you. The product under review was purchased without the knowledge of the supplier.

Full-sized images can be found on flickr. And while you’re here – are you interested in Arduino? Check out my new book “Arduino Workshop” from No Starch Press.

In the meanwhile have fun and keep checking into tronixstuff.com. Why not follow things on twitterGoogle+, subscribe  for email updates or RSS using the links on the right-hand column? And join our friendly Google Group – dedicated to the projects and related items on this website. Sign up – it’s free, helpful to each other –  and we can all learn something.

Posted in LPC800, LPC800-MAX, LPCxpresso, mbed, review, tronixstuffComments (0)

Tutorial – Arduino and the MAX7219 LED Display Driver IC

Use the Maxim MAX7219 LED display driver with Arduino in Chapter 56 of our Arduino Tutorials. The first chapter is here, the complete series is detailed here.

Introduction

Sooner or later Arduino enthusiasts and beginners alike will come across the MAX7219 IC. And for good reason, it’s a simple and somewhat inexpensive method of controlling 64 LEDs in either matrix or numeric display form. Furthermore they can be chained together to control two or more units for even more LEDs. Overall – they’re a lot of fun and can also be quite useful, so let’s get started.

Here’s an example of a MAX7219 and another IC which is a functional equivalent, the AS1107 from Austria Microsystems. You might not see the AS1107 around much, but it can be cheaper – so don’t be afraid to use that instead:

MAX7219 AS1107

When shopping for MAX7219s you may notice the wild price fluctuations between various sellers. We’ve researched that and have a separate article for your consideration.

 At first glance you may think that it takes a lot of real estate, but it saves some as well. As mentioned earlier, the MAX7219 can completely control 64 individual LEDs – including maintaining equal brightness, and allowing you to adjust the brightness of the LEDs either with hardware or software (or both). It can refresh the LEDs at around 800 Hz, so no more flickering, uneven LED displays.

You can even switch the display off for power saving mode, and still send it data while it is off. And another good thing – when powered up, it keeps the LEDs off, so no wacky displays for the first seconds of operation. For more technical information, here is the data sheet: MAX7219.pdf. Now to put it to work for us – we’ll demonstrate using one or more 8 x 8 LED matrix displays, as well as 8 digits of 7-segment LED numbers.

Before continuing, download and install the LedControl Arduino library as it is essential for using the MAX7219.

Controlling LED matrix displays with the MAX7219

First of all, let’s examine the hardware side of things. Here is the pinout diagram for the MAX7219:

MAX7219 pinout

The MAX7219 drives eight LEDs at a time, and by rapidly switching banks of eight your eyes don’t see the changes. Wiring up a matrix is very simple – if you have a common matrix with the following schematic:

LED matrix pinoutsconnect the MAX7219 pins labelled DP, A~F to the row pins respectively, and the MAX7219 pins labelled DIG0~7 to the column pins respectively. A total example circuit with the above matrix  is as follows:

MAX7219 example LED matrix circuit

The circuit is quite straight forward, except we have a resistor between 5V and MAX7219 pin 18. The MAX7219 is a constant-current LED driver, and the value of the resistor is used to set the current flow to the LEDs. Have a look at table eleven on page eleven of the data sheet:

MAX7219 resistor tableYou’ll need to know the voltage and forward current for your LED matrix or numeric display, then match the value on the table. E.g. if you have a 2V 20 mA LED, your resistor value will be 28kΩ (the values are in kΩ). Finally, the MAX7219 serial in, load and clock pins will go to Arduino digital pins which are specified in the sketch. We’ll get to that in the moment, but before that let’s return to the matrix modules.

In the last few months there has been a proliferation of inexpensive kits that contain a MAX7219 or equivalent, and an LED matrix. These are great for experimenting with and can save you a lot of work – some examples of which are shown below:

MAX7219 LED matrix modules

At the top is an example from ebay, and the pair on the bottom are the units from a recent kit review. We’ll use these for our demonstrations as well.

Now for the sketch. You need the following two lines at the beginning of the sketch:

The first pulls in the library, and the second line sets up an instance to control. The four parameters are as follows:

  1. the digital pin connected to pin 1 of the MAX7219 (“data in”)
  2. the digital pin connected to pin 13 of the MAX7219 (“CLK or clock”)
  3. the digital pin connected to pin 12 of the MAX7219 (“LOAD”)
  4. The number of MAX7219s connected.

If you have more than one MAX7219, connect the DOUT (“data out”) pin of the first MAX7219 to pin 1 of the second, and so on. However the CLK and LOAD pins are all connected in parallel and then back to the Arduino.

Next, two more vital functions that you’d normally put in void setup():

The first line above turns the LEDs connected to the MAX7219 on. If you set TRUE, you can send data to the MAX7219 but the LEDs will stay off. The second line adjusts the brightness of the LEDs in sixteen stages. For both of those functions (and all others from the LedControl) the first parameter is the number of the MAX7219 connected. If you have one, the parameter is zero… for two MAX7219s, it’s 1 and so on.

Finally, to turn an individual LED in the matrix on or off, use:

which turns on an LED positioned at col, row connected to MAX7219 #1. Change TRUE to FALSE to turn it off. These functions are demonstrated in the following sketch:

And a quick video of the results:

How about controlling two MAX7219s? Or more? The hardware modifications are easy – connect the serial data out pin from your first MAX7219 to the data in pin on the second (and so on), and the LOAD and CLOCK pins from the first MAX7219 connect to the second (and so on). You will of course still need the 5V, GND, resistor, capacitors etc. for the second and subsequent MAX7219.

You will also need to make a few changes in your sketch. The first is to tell it how many MAX7219s you’re using in the following line:

by replacing X with the quantity. Then whenever you’re using  a MAX7219 function, replace the (previously used) zero with the number of the MAX7219 you wish to address. They are numbered from zero upwards, with the MAX7219 directly connected to the Arduino as unit zero, then one etc. To demonstrate this, we replicate the previous example but with two MAX7219s:

And again, a quick demonstration:

Another fun use of the MAX7219 and LED matrices is to display scrolling text. For the case of simplicity we’ll use the LedControl library and the two LED matrix modules from the previous examples.

First our example sketch – it is quite long however most of this is due to defining the characters for each letter of the alphabet and so on. We’ll explain it at the other end!