TKJ Electronics

Kickstarter successfully funded

Lauszus — Fri, 19 Apr 2013 14:16:44 +0000

We are very pleased to announce that our Kickstarter for the Balanduino balancing robot has successfully been funded by $13,494 which we are very happy about.

We have just received stickers from our printing company and have decided to give a little bonus in form of a signed Balanduino post card. We will be shipping this post card and stickers to all of our backers who have pledged $10 or more, within next week.

All the source code including the firmware, schematic, PCB layout and mechanical drawings for the frame is available at Github: https://github.com/TKJElectronics/Balanduino.

If you are not a backer, but are still interested in the project, you should checkout the Kicstarter: http://www.kickstarter.com/projects/tkjelectronics/balanduino-balancing-robot-kit and our previous blog post: http://blog.tkjelectronics.dk/2013/03/balanduino-balancing-robot-kit/.

That’s all for now. Please let us know in the comments below if you got any questions or comments regarding the project.

The Balanduino

Balanduino Kickstarter almost finished

Lauszus — Sat, 13 Apr 2013 22:41:00 +0000

Hello to all of our followers. This is just a short reminder that the Kickstarter of our Balancing robot, the Balanduino, is nearly finished.
We have already reached our goal of $10.000, but of course it would be great to get even more backers and pledges.

In the meanwhile we have recorded a new video of the robot with a GoPro mounted on the top.

http://www.youtube.com/watch?v=CvFcnb_9anM

For more information check out the prevouis blog post: http://blog.tkjelectronics.dk/2013/03/balanduino-balancing-robot-kit/ and the Kickstarter page.

Balanduino – Balancing Robot Kit (Kickstarter)

Thomas Jespersen — Mon, 18 Mar 2013 22:14:51 +0000

Hello all fellow blog readers.
Most of you might be aware of the Balancing robot project we have been working on for quite a while, if not please have a look here: The Balancing Robot.

We have now been working on this project in over a year, fine tuning the balance and stability of the robot and adding even other features and control options.

And NOW we are ready to announce this Balancing robot to be sold as a kit, named Balanduino.

The Balanduino

The Balanduino kit consists of an Arduino compatible main board with the necessary sensors to keep the robot balanced automatically.

Furthermore the main board contains a USB Host controller, the MAX3421E, which library for the Arduino we have been expanding a lot recently, adding support for many of the most popular game controllers.
This USB Host controller together with a USB Bluetooth dongle enabled you to remotely control the Balanduino with your Android phone, PS3, Wii or Xbox controller and even your Windows, Linux or Mac PC.

We have decided to start a Kickstarter to help us fund the manufactury of the initial production run of the Balanduino kit, to get it to the market as quick as possible.

Click here to see the Balanduino Kickstarter

Balanduino Kickstarter

On the Kickstarter page you can read some much more detailed information about the Balanduino robot, the hardware and software parts.

We have decided to offer the Balanduino kit in some different variants to suit your taste and budget. So whether you would like to get a complete kit with everything you need to get started building your own copy of the Balanduino robot, or if you would like to build the mechanical structure yourself, you can get the exact version from the Kickstarter.

Our Kickstarter price for a complete kit with the controller board, Bluetooth dongle, two geared motors with encoders, wheels, hubs, a 4000mAh 3S LiPo battery and charger and the mechanical structure is only $299.

Below you will find a video demonstration of the Balanduino and all of it’s features, including a technical overview and a demonstration of the different controller options.

We hope you will fund our project to get it going and especially get yourself a small balancing robot to play with, expand and explore a completely new world of Hobby Robotics.

High resolution image can be found here: Balanduino.png

LPC4350 board – which parts would you like to see reviewed

Thomas Jespersen — Sun, 03 Mar 2013 21:04:22 +0000

We have just recently bought a one of the latest evaluation kits from Hitex, featuring the new dual-core LPC4350 from NXP – the LPC4350 Evaluation Board.

LPC4350 Getting Started Kit

The processor consists of two cores, an ARM Cortex-M0, as the low-level processor and the high-end ARM Cortex-M4. Even though the two cores are of a different kind and with independently different features, they both run at a frequency of up to a stunning 204MHz.

NXP LPC4350 Block diagram

The LPC4350 has a number of great periphirals as you can see in the block diagram above. First of all the processor comes with 1MB of Flash and 264KB of RAM.
If either the Flash or RAM is not enough there is a great way to expand this either with Parallel Flash, NAND Flash, SPI Flash and for the RAM with SRAM or even the inexpensive SDRAM.
Furthermore the processor comes with a different number of external connection periphirals such as USB Client, USB Host, Ethernet, UART, CAN, I2C and SPI.

When you think that should be it you will notice the LCD periphiral.
We are very eager to test this periphiral though we have already tested NXP’s LCD periphiral before on the CoiNel Tech LPC4088 MiO, though we are missing a review of this.

With this new LPC4350 evaluation board from Hitex we are able to test all of these features and even more as it comes full-fitted with anything from extra RAM to Audio Input and Output amplifiers.

LPC4350 Evaluation Board

Here are some of the board features.

CPU: LPC4350 (ARM Cortex-M4 with Cortex-M0)
Power-over-Ethernet
Ready for energy consumption analysis with PowerScale of the complete board, the CPU-core and other peripherals
SDRAM, SRAM, FLASH, qSPI flash
Temperature sensor, SD card-connector
CAN, UART, USART, Ethernet, USB (Host, Device, OTG)
Debug with standard ARM JTAG and JTAG + Trace connector
Ready for Jennic ZigBee module
Small onboard display and external display / LCD/TFT interface
HDMI interface
Media connector to connect well known MP3-Player
Push buttons, joystick and LEDs
Wrap field with power and GND
Audio IN and OUT, microphone IN, headphones OUT and a D-Class amplifier
Motor Contrli interface for NXP inverter board
VADC with OPAmp circuit

So the question to our fellow readers is now which of these periphirals you would like us to dig into and investigate further by making a demonstration project.

A final unfortunate note is that all of the evaluation board materials, such as the demonstration projects, is made for the expensive Keil or IAR compilers. So for hobbyists like many of our readers, it has become difficult to start developing and using these boards without buying these tools or downloading them illegally.
We have a solution for that, as we have managed to make a project for both the LPC4088 on the “CoiNel Tech LPC4088 MiO board” and for the LPC4350 on this board, within the free CooCox CoIDE.

Keep posted for more information about that.

Drive LCD TFT displays with an FPGA

Thomas Jespersen — Fri, 22 Feb 2013 22:56:33 +0000

FPGA’s can be very advanced to get started using, especially if you are used to microcontrollers.
But when you first get the right feeling and the proper mindset you will soon see the endless possibilities with the programmable logic.

One of the great aspects of the logic is the speed and the full control of what happens at every single clock cycle.
With this full control it doesn’t takes many lines of code to generate a very time-critical signal such as a video signal.

In this short post I will walk thru our current test setup with an FPGA, the Spartan 3E, controlling a 18-bit 7″ 800×480 TFT display.

Spartan 3E controlling a 800×480 TFT LCD

In the image above you can the TFT display at the top and the FPGA board at the bottom.
In between of these you will see a small green connector board, which is our own 7-inch LCD Breakout board with the required switch-mode power supply for powering the LED backlight, together with the interface connector with the 18-bit color signals, Pixel Clock, Data Enable and PWM.

7″ LCD Breakout board

The schematic of the board can be found here: A5-LCD_Breakout.pdf

The FPGA board itself is the inexpensive, low-level, “Spartan 3E Sample Pack“.
Though any FPGA board with the required I/O pins available can of course be used.

“Spartan 3E Sample Pack” FPGA board

The VHDL code for this project, including the Xilinx Project files, can be downloaded here: FPGA_LCD_TFT_Control.zip
I will try to do a short summary of what happens in the code and why I have decided to make it such.

VHDL Code walkthru
To control a TFT display you have to generate the following two timed signals: DCLK (Pixel clock) and DE (Data Enable).
In the datasheet of the display you will be able to find the specific timing parameters of these signals, which also explains when to display the color data of each pixel.
At page 6 of the datasheet of our display we can see the timing table. From this table we will notice the required CLK frequency of around 33.26MHz. Generating this Pixel clock source is one of the major aspects of generating the video signal.

Clock: entity work.DCM_Module(Behavioral)
generic map (PERIOD => 20.0, DIV => 27, MUL => 18)
port map (CLK_IN => CLK, CLK_OUT => PixelClock);

Within the code for the FPGA I have decided to use the built in DCM (Digital Clock Manager) periphiral of the FPGA’s, to generate 33.33MHz from the on board 50MHz oscillator. This is done by diving the Input frequency by 27 and then multiply this by 18.
50MHz / 27 = 1.85MHz * 18 = 33.33MHz

Now when we have this clock signal internally in the FPGA too, we can use this signal to count the clock pulses, equal to each ‘pixel’, and then we are ready to create the timing of the DE signal.
According to the datasheet we have an 800 pixels (clock cycles, Tcph, too) wide display area where the Data Enable has to be on.
For every line scan we have a total of between 1000 and 1200 ‘pixels’, whereof between 200 and 400 are outside of the screen. These ‘off-screen’ pixels are used to sync the video signal.

When we have done a single line scan there is 479 more to go within the visisble display area. Yet again we do also have some ‘off-screen’ lines, in this case between 10 and 110 lines, to do the sync.

To ease the generation of the Data Enable signal and to take care of the current scan/pixel position, I have made two counters: Hcount and Vcount.
The Hcount is used to take care of the current Horizontal pixel, going from 0 to 799 when inside the visible display area, and then continuing from 799 to about 1200 for the ‘off-screen’ pixels.
The Vcount is used to take care of the current Vertical pixel, going from 0 to 479 when inside the visible display area, and then continuing from 479 to about 590 for the ‘off-screen’ pixels.

The Data Enable pin is then controlled by this single line of code:

DE <= '1' when ((Hcount < TDEH) and (Vcount < TDE)) else '0';

Where the TDEH and TDE are definitions as found in the datasheet. In the top of our VHDL code all these timing definitions has been programmed as constants:

constant TDEH: integer := 800;
constant TDEL: integer := 256;
constant TDEB: integer := 45;
constant TDE: integer := 480;

So now we have managed to generate both the DCLK (Pixel clock) and the required DE (Data Enable) signal with the proper timing parameters.
The Hcounter will keep counting up to (TDEH+TDEL), which is the total horizontal pixel count (including the ‘off-screen’ pixels). Afterwards it resets to 0 and increase 1 to the Vcount, moving the “cursor” one line down.
This is then repeated until the Vcounter reaches the end at (TDE+TDEB) where it resets to 0 too.

Finally it is now just a matter of setting the 18-bit digital color lines to the proper pixel color at each clock cycle and then we have a functioning display system.

Documentation added for the USB Host Library

Lauszus — Wed, 20 Feb 2013 14:14:14 +0000

I’m happy to announce that documentation is now available for all the libraries I have written for the USB Host Shield library.
The documentation is available at the following link: http://felis.github.com/USB_Host_Shield_2.0.
The documentation is generated using Doxygen which is a free documentation-generator based upon the header files in the source code.

For instance the following comment will end up looking like this in the documentation:

I hope this will be useful for people who is new to the USB host library or even people who just want a quick overview.
If you spot any typos or got any comments please let me know in the comments below.

Bluetooth controlled RGB light strip

Thomas Jespersen — Sun, 20 Jan 2013 20:49:04 +0000

In December last year we developed a small Bluetooth controlled RGB light strip for the christmas tree, to be controlled with your Android smartphone

The demonstration of the project and the smartphone control can be seen in the video below.

http://www.youtube.com/watch?v=pZSADQihV_Y

The main aspect of the project is to use an Arduino to parse incoming Serial commands to enable and set different effects for the attached RGB strip.
The code for the project, including the Arduino code and the Android application project, can be found on GitHub: AndroidControllableLights

Another interesting aspect of the project was to enable wireless update of the Arduino sketch, using the Bluetooth serial connection. Scroll down in this post if you are only interested in figuring out how this can be done.

RGB Strip
The RGB strip contains 50 pixels, each with an individual WS2801 chip. These chips makes it possible to control the colors of each pixel on the strip using serially clocked and latched data with only 2 pins. The data pin of the strip is connected to Arduino pin 8, while the clock pin is connected to pin 9.
By using the WS2801 library by Adafruit the control of the colors on the strip is fairly easy task.

setStripColor(R, G, B);
strip.show();

Animations and effects
The next step is the control of the lights and some different effects and animations.
In this project I have decided to make the following effects:

Set color directly
Fading between set colors
Snap between set colors
Scroll of set color pattern
Running fade og set colors

Parsing of Serial commands
We are now ready to parse incoming Serial data and interpret it as commands to enable, set or disable the effects.
I decided to make the following commands which is then parsed when received Serially, either from the Bluetooth module or from a PC connected using USB.
The first byte of a command package is the command byte, descriping the command of the package. The next bytes are all parameters as described below. Each parameter is terminated with a ‘;’ character, also when only one parameter is needed.

The project contains the following commands:

0x0F – Set color [Parameters: 3 bytes of 3 char each]
0×01 – Add fade color [Parameters: 3 bytes of 3 char each]
0×02 – Reset fade colors [Parameters: None]
0×03 – Set Speed/Delay [Parameters: 1 integer of 5 chars]
0×04 – Enable fade effect [Parameters: None]
0×05 – Add snap color [Parameters: 3 bytes of 3 char each]
0×06 – Reset snap colors [Parameters: None]
0×07 – Enable snap effect [Parameters: None]
0×08 – Add scrolling color [Parameters: 3 bytes of 3 char each]
0×09 – Reset scrolling colors [Parameters: None]
0x0A – Enable scrolling effect [Parameters: None]
0x0B – Add running fade color [Parameters: 3 bytes of 3 char each]
0x0C – Reset running fade colors [Parameters: None]
0x0C – Enable running fade effect [Parameters: None]
0x0E – Disable any effect [Parameters: None]

Android Application
The most difficult part for me was the Android application.
I managed to put down a relatively simple but powerfull application to control send the specific Serial commands over Bluetooth to the Arduino.
The Android project can also be found on GitHub: ColorLightsController

“Color Lights Controller” – the Android control application

To help me get started with the Bluetooth communication I have used the following tutorial: ANDROID AND ARDUINO BLUETOOTH COMMUNICATION
And for the color selector I found this great AmbilWarna Color Picker together with a tutorial on how to use it in your own application.

OBS. The current version doesn’t have any device selection dialog for the Serial Bluetooth module, so the module name is “pre-programmed” into the application: if(device.getName().equals(“quadcopter”))

So you will have to change this accordingly before starting the application on your own phone.

Wirelles (Bluetooth) update of the Arduino
One final aspect of the project, was the ability to update the Arduino sketch wirelessly, so I didn’t always have to connect a USB cable.
As the Bluetooth module I am using doesn’t have any DTR pin for resetting the board, starting the Arduino bootloader, I had to improvise and implement this “reset into bootloader” myself.

I started trying the most known reset solution, the Watchdog. But the problem with our goal in resetting into the bootloader is, that when you do a Watchdog reset an internal flag is set which then skips the bootloader.
So a real “hardware” reset is necessary.

A solution for this was to connect an analog output pin (PWM pin) to the Reset pin of the Arduino. I decided to use pin 7.
By using an Analog output pin the state of it is left unchanged while the Arduino is booting, making sure that it doesn’t go into a “restart-loop”.

We are now able to hardware-reset the board by writing 0 to that pin (GND), which sets it up and drives the reset pin low!

void resetIntoBootloader(void)
{
analogWrite(7, 0);
}

While we have now overcome the issue of the DTR connection we still need to know when to execute the resetIntoBootloader function.
This is where the specific Arduino bootloader character sequence comes in handy.

When you press the upload button of your Arduino IDE your board is reset due to the DTR pin and the IDE then starts spitting out “0 0 0 0 0 “.
We can use this sequence to check for a zero and then a space, and if that is recognized then execute the resetIntoBootloader function.

char bootloaderPrelimary = 0;
void checkBootloader(char serialChar)
{
if (bootloaderPrelimary == 0) {
if (serialChar == '0')
bootloaderPrelimary = 1;
} else {
if (serialChar == ' ')
resetIntoBootloader();
else
bootloaderPrelimary = 0;
}
}

Everytime we receive a character we need to check it with this ‘checkBootloader’ function first, to see if it is some bootloader characters.

I have implemented this in the top of the main loop, before doing any of the command parsing.
So for everytime we receive a character we check it to see if it is a bootloader character, and if not, we are going to parse it as a command byte.

You can see the lines of code you will have to add to your loop function here: Bootloader check sequence

Finally you will have to remember to set your Bluetooth module to a Baud-rate of 57600 – as this is the rate the Arduino bootloader is using.
That is also why the sketch is set to use 57600 as the buad-rate.

I guess this is it for now.
I hope you enjoyed this small but handsome Christmas lighting project.

Happy new year everyone!

USB Host Shield is now available in the webshop

Lauszus — Thu, 17 Jan 2013 19:45:07 +0000

This is a short announcement regarding the USB Host Shield from Circuits@Home, which we are now carrying in in our store.
By buying the official shield you will support the continous development of the library and get support from us!
The shield can be found and bought here: USB Host Shield 2.0 for Arduino.

The shield can be used with almost any kind of Arduino including the most popular Arduino Uno, Arduino Mega, Arduino Leonardo etc. If you are in doubt if your Arduino is supported please don’t hesitate to write a comment below.

The USB Host Shield will allow you to use any of the Bluetooth and USB libraries I wrote.

In case you missed it I have written several libraries for the shield including:

The Serial Port Protocol (SPP)
Emulate a serial port via Bluetooth, which allows you to send data back and fourth wirelessly.

PS3 controllers
All the official controllers are supported both via USB and Bluetooth.

Xbox controllers
Both the wireless and wired controllers are supported. You will need a special wireless receiver to use the wireless controller.

Wiimotes
The Wiimote is supported including the build IR camera. The Motion Plus and Nunchuck extensions are also supported. The Wii U Pro Controller is supported as well.

The USB Host Shield support several other devices including:

USB to serial converters – FTDI, PL-2303, ACM, as well as certain cell phones and GPS receivers are supported.
Android ADK
Digital cameras
HID device, such as keyboards, mice and joysticks
USB MIDI driver

The source code can be found at Github:
https://github.com/felis/USB_Host_Shield_2.0.

More information can be found at Circuits@Home.

Xbox 360 receiver added to the USB Host Library

Lauszus — Fri, 28 Dec 2012 23:45:35 +0000

You asked for it and here it is.
I finally got the time to implement support for Wireless Xbox 360 controllers to the USB Host Library. This is done via a Xbox 360 Wireless receiver that is normally intended for Windows computers.

The source code can be found at github: https://github.com/felis/USB_Host_Shield_2.0/blob/master/XBOXRECV.cpp
There is an example as well: https://github.com/felis/USB_Host_Shield_2.0/blob/master/examples/Xbox/XBOXRECV/XBOXRECV.ino.

The receiver supports up to four controllers internally, so it was fairly easy to implement it.

~~Actually I havn’t tested the library with more than one controller, but if somebody out there could confirm if it’s working or not, with more than one controller, I would really appreciate it!~~
Thanks to Tim, multiple controllers is now confirmed to work!

If you need to use more than four controllers you will need to connect a second receiver via a USB hub which is also supported by the library.
Simply add the following to the start of your Arduino sketch:

USBHub Hub1(&Usb);
USBHub Hub2(&Usb);

Note that you might need to add more instances depending on how many chips there is inside your USB hub.

You will also need to create another instance of the XBOXRECV class like so:

USB Usb;
XBOXRECV Xbox1(&Usb);
XBOXRECV Xbox2(&Usb);

For more information regarding the protocol see the following pages: http://tattiebogle.net/index.php/ProjectRoot/Xbox360Controller/WirelessUsbInfo and https://github.com/Grumbel/xboxdrv/blob/master/PROTOCOL.

Inexpensive 2×16 LCD display (HD44780)

Thomas Jespersen — Thu, 06 Dec 2012 20:56:00 +0000

Small and inexpensive LCD module

We at TKJ Electronics have just received a big bunch of inexpensive 2×16 Alphanumeric character display with a built in HD44780 controller, making it easy compatible with the Arduino or any other microcontroller.

2 by 16 characters though without backlight

You have full control of both lines of 16 characters with either a 4-bit or 8-bit control scheme, requiring a minimum of only 6 I/O pins on the microcontroller.
The display comes without backlight but has room and connections for it if the display is flipped up. Further more there is two holes in the side for screw mount, making it even easier to integrate with the cabinet of your next project.

Please visit our Webshop for a short detailed description including a download link for the datasheet: LCM-S01602DTR/M

Or have a look at the video below to see the LCD in action using an Arduino MEGA.

http://www.youtube.com/watch?v=QJoFUpqNGvA

For the interested hackers the code for the demonstration in the video can be found below.

// include the library code:
#include

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

char i;
const char message1[17] = "2x16 LCD Display";

void setup() {
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
}

void loop() {
// Print a message to the LCD.
lcd.clear();

lcd.setCursor(0, 0);
lcd.print("TKJ Electronics");
lcd.setCursor(0, 1);
lcd.print("LCM-S01602DTR/M");
delay(2000);

lcd.setCursor(16, 0);
lcd.autoscroll();
for (i = 0; i < 16; i++) {
lcd.print(message1[i]);
delay(100);
}
lcd.noAutoscroll();

for (i = 0; i < 4; i++) {
lcd.setCursor(16, 1);
lcd.print(" ");
delay(500);
lcd.setCursor(16, 1);
lcd.print(" Only $5.00 ");
delay(500);
}

delay(1000);
}