Click on the Organise button in a Windows folder:

And select the Folder and search option:

On the search tab select “Always search filenames and contents” option:

Close this dialog and search as normal, this might take a while but you should get your results!

The most basic navigation simulation is shown above, navigating from one point to the other with NO obstructions!

I have setup a test environment in VB.NET where the start and end positions can be defined by clicked the left and right mouse buttons in the workspace. An obstruction can be defined by dragging a rectangle in the workspace. The system works on a very simple system of checking whether a particular vector between two points is clear of obstructions, if an obstruction is found between the two points then the program creates a list of which obstruction corners it can move directly to without hitting anything. From each of these potential paths the system iterates through and checks whether it can reach the target from there and so on.

The function for checking whether the path between two points is clear of obstructions is given below.

      ''' <summary>
      ''' This method checks if the vector path between two points is clear of obstruction
      ''' </summary>
      ''' <param name="pntStart">The start point</param>
      ''' <param name="pntEnd">The end point</param>
      ''' <returns>True if the vector between the two points is clear of obstructions, else False if an obstruction is found</returns>
      Private Function blnVectorClear(ByVal pntStart As Point, ByVal pntEnd As Point) As Boolean
            'Work out the gradient between the two points
            Dim dblX As Double = 0
            Dim dblY As Double = 0
            Dim dblGradient As Double = (pntEnd.Y - pntStart.Y) / (pntEnd.X - pntStart.X)

            'If the dominent axis is the Y axis
            If Math.Abs(pntEnd.Y - pntStart.Y) > Math.Abs(pntEnd.X - pntStart.X) Then
                  'Invert the gradient
                  dblGradient = 1 / dblGradient

                  'Determine whether to work up-down or down-up
                  Dim intStep As Double = 1
                  If (pntEnd.Y - pntStart.Y) < 1 Then
                        intStep = -intStep
                  End If

                  'Loop through each point in the Y plane
                  For intY As Double = 0 To (pntEnd.Y - pntStart.Y) Step intStep
                        'Calculate the position in the X axis for this Y position
                        'y = mx + c but where x & y are reversed!
                        dblX = (dblGradient * intY) + pntStart.X
                        dblY = intY + pntStart.Y

                        'If there is an obstruction in this position
                        If blnCheckCollision(dblX, dblY) Then
                              'Vector is not clear!
                              Return False
                        End If
                  Next
            Else
                  'Determine whether to work left-right or right-left
                  Dim intStep As Integer = 1
                  If (pntEnd.X - pntStart.X) < 1 Then
                        intStep = -1
                  End If

                  'Loop through each point in the X plane
                  For intX As Double = 0 To (pntEnd.X - pntStart.X) Step intStep
                        'Calculate the position in the Y axis for this X position
                        'y = mx + c
                        dblX = intX + pntStart.X
                        dblY = (dblGradient * intX) + pntStart.Y

                        'If there is an obstruction in this position
                        If blnCheckCollision(dblX, dblY) Then
                              'Vector is not clear!
                              Return False
                        End If
                  Next
            End If

            'Vector has been checked and is not obstructed!
            Return True
      End Function

      ''' <summary>
      ''' This function checks whether a specified point in the workspace is within one of the defined obstructions
      ''' </summary>
      ''' <param name="dblX">The X position within the workspace to check</param>
      ''' <param name="dblY">The Y position within the workspace to check</param>
      ''' <returns>True if the position is within an obstruction</returns>
      Private Function blnCheckCollision(ByVal dblX As Double, ByVal dblY As Double) As Boolean
            'Loop through each of the boxes defined as obstructions
            For Each objBox In m_colBoxes
                  'If the X and Y position given is within the bounds of this obstruction
                  If dblX > objBox.Left And dblX < objBox.Right And dblY > objBox.Top And dblY < objBox.Bottom Then
                        'Collision found!
                        Return True
                  End If
            Next

            'No obstruction found
            Return False
      End Function

Future development needs to work out all of the possible paths between the two points and calculate the most efficient route to take.

The device uses an NXP LPC1768 ARM Cortex M3 processor embedded on a small footprint development board with some great features for quick development.

• Built in 3.3V regulator
• Debugging USB port
• Online development environment with access to lots of peripheral libraries
• Simple device programming by copying binary onto device as if it was a USB drive
• Ethernet capability with just an Ethernet Magjack socket
• Additional USB connectivity
• CAN Bus
• Analog inputs and output
• PWN outputs
• SPI, I2C and Serial interfaces

The mbed’s are around £40 which although isn’t as cheap as some of the Arduino based solutions around is actually quite reasonable for the performance and features available. It also uses 0.1″ (2.54mm) pitch headers that are designed to fit directly onto a breadboard.

One of the unique things about this device is that it is not just a processor on a board, it is actually two processors, an Ethernet PHY, flash memory power supply components and status LEDs. The main M3 processor runs the application as normal but a secondary processor handles communication with the PC and exposes the mbed as both a USB drive and a USB serial port. When the application is compiled a binary is saved onto the flash chip of the mbed via the USB interface (just like saving files onto a USB key drive), then when the mbed is reset the secondary processor boots up first and checks which binary file on the flash drive is the latest and then saves this program to the main processor. The main processor is then started as normal. The secondary processor also exposes a USB Serial port which can be used to debug the program and send data to it.

This little device is well worth checking out if your interested in embedded programming and is a simple way to get started with ARM based development.

PPTP

First of all there was PPTP…

PPTP was fairly easy to setup but not without its own difficulties!

The first step was to setup the server:

• Add the Routing and Remote Access Role with VPN.
• In RAS (Routing and Remote Access), add a Policy to allow VPN access by adding a rule for Virtual (VPN) Port and granting the policy access. We also added a condition that limited the users able to logon to a specific “VPN Users” group.
• Set the authentication methods you wish to use, we selected only MS-CHAP v2. Do this both in the VPN policy you just created and in the properties of the server in RAS (security tab).
• In ports, select PPTP. Enable and enter a number of ports to allow at any one time.

Next setup the firewall/router to allow VPN traffic trough:

Open the following ports on the firewall:

• TCP 1701 (PPTP)
• IP Protocol 47 (GRE) – Note: Protocol NOT UDP or TCP

Setup the client PC to connect:

• Create a VPN connection.
• Enter the IP to connect to.
• In TCP/IP properties within the VPN properties, go to Advanced and UN-check “Use default gateway on remote network”, otherwise all your internet traffic will be routed through the VPN connection and there is no need for it (normally).
• Enter the domain user credentials of someone with access to connect to VPN.
• Windows XP users may need to start off with the Windows firewall disabled.

Connect… Done! (maybe…)

This is where we came across our major head-scratcher with PPTP… It didn’t work externally! Our first thought… the firewall! It had to be the firewall! After days and days of playing with different combinations and configurations we decided to swap to a different ADSL modem. Straight away, connected! The moral: don’t eliminate anything; don’t presume the modem will allow VPN traffic!

Tip: Always test the VPN connection from an internal connection (i.e. not through the router/modem) where possible before testing externally. If it doesn’t work locally then you stand no chance from the outside world!

L2TP

Next there way L2TP…

L2TP with IPSec is much more secure than PPTP and is a better choice, however there is more to go wrong!

Setup the server (presuming you already have PPTP working):

• In the security tab (RAS, Server Properties) check the ‘Allow custom IPSEC policy for L2TP connection’ box and enter a passkey.
• In ports select L2TP, enable it and enter the number of ports you would like to use.

Setup the firewall:

Open the following ports on the firewall:

• IP Protocol 50
• IP Protocol 51
• UDP 4500 (NAT-T traffic)
• UDP 500
• UDP 1701 (L2TP)

Setup the client:

• Copy your existing (working I hope) PPTP connection and edit it.
• In the networking tab, select L2TP.
• In IPSec setting, enter the pre-shared key you chose on the server.

Connect… Does it work? Yes – Great, go home and take a break! No – Read on…

Microsoft Windows Registry Fix

Firstly there is the thing that Microsoft forgot to explain properly that you might have come across but weren’t sure whether you needed to do it. In XP and Vista you need to add a key to the registry! Yes it’s strange but true! This is where we wasted hours not getting things up and running.

• Open the registry editor (ask for help if you are not sure at this point!)
• Navigate down to \Computer\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\IPSec\ (on XP)
• Navigate down to \Computer\HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\PolicyAgent\ (on Vista)
• Enter the following as a new DWORD value
  • AssumeUDPEncapsulationContextOnSendRule
  • Set the value to 2
• Reboot the computer (you must reboot for the change to take affect)

Try connecting again, it may just work.

Debugging

If not then there are a few debugging tips that may help you figure out where the problem is. First you need to establish where the problem is.

VPN Connection Stages

Although the following isn’t a complete list of stages that are performed when VPN connects it outlines the basic stages of connecting for these purposes:

• Host is looked up (DNS).
• Client connects to server to establish an IPSec security association (SA) through Internet Key Exchange (IKE) on port 500.
• IPSec Phase 1 (Main Mode) is established with IKE.
• IPSec Phase 2 (Quick Mode) is established with IKE
• Establish Encapsulating Security Payload (ESP) on protocol 50.
• L2TP tunnel is established on UDP port 1701 between the SA endpoints.

The first check is that the server IP address is correct, confirm by connecting via PPTP again (if this is working). Ping the server (if ping is let through the firewall). Confirm manually the IP address of the server.
Next, evidence of the VPN connection (if it is reaching the server) can be seen in the system security event log. On the server open up the windows event log and clear the security log. Try connecting from the client and then refresh the log and look for a RemoteAccess entry. Check the details, this might be your connection.

If the connection is not seen in the eventlog check the firewall settings (at both ends). Check the RAS VPN policy and settings are correct.

If the connection is in the event log then it is reaching the server at least. There are now a few things that can be checked: Enable IKE logging, Check client SA is being established and debug packets being sent/received on the client and server.

Enable IKE Logging

On the Windows 2003 server, run the following to disable logging and free access to the log file:
netsh ipsec dynamic set config ikelogging 0

Navigate to C:\WINDOWS\Debug\ and delete the Oakley.log file

Run:
netsh ipsec dynamic set config ikelogging 1

Attempt to connect from the client.

Run:
netsh ipsec dynamic set config ikelogging 0

Open the Oakley.log file in the C:\WINDOWS\Debug\ directory.

If there is no entries in the file (or it does not exist) then an IPSec connection request hasn’t even started. If there is log entries then read through carefully and look for the two phases of IPSec (Main Mode and Quick Mode). If all is working, there should be entries stating that Phase 1 SA is accepted and Phase 2 SA is accepted. If there are errors in the log then these need to be looked up and fixed.

Check client is establishing IPSec over IKE

On the client open up MMC (run: mmc.exe). Add a snap-in and add the IP Security Monitor. Expand the Main mode and Quick mode tree to see the two SA folders. Open the properties for the client in the MMC console and set the auto-refresh to every 1 second. Now start to connect via VPN, watch to see if an entry appears in the Main Mode SA, if it does, check the Quick Mode SA. If an entry appears in here then IPSec is being established and probably isn’t the problem. If not then check those IKE logs on the server again, something is not working here.

Packet debugging

Packet debugging can give a good indication of what is and what isn’t happening during the VPN connection sequence. There are a few good packet analysis applications about but I use <a href=’http://www.wireshark.org/’ target=’_blank’>Wireshark</a>.

Install on one or both machines and start off listening on the network adapater that VPN is connecting out of on that machine. I also recomend filtering the packets based on the destination of the VPN server otherwise you’ll get loads of extra packets and things get confusing fast!
Enter: (ip.src == 1.2.3.4) || (ip.dst == 1.2.3.4) into the filter box (where 1.2.3.4 is the IP of the VPN server. If running Wireshark on the server, enter the IP of the host trying to connect (public IP if connecting across WAN).
Then attempt to connect VPN… there should be at least some packets showing up, if not check the filter entered is correct.

What you should see may vary slightly with each setup but the general flow is as follows:

• ISAKMP – Identity Protection (Main Mode)  =  There should be 5 or 6 of these as ‘Main Mode’ (phase 1) is established.
• ISAKMP – Quick Mode  =  There should be about 4 of these as ‘Quick Mode’ (phase 2) is established.
• ESP packets  =  If connected, plenty of these should come flooding in.
• UDPENCAP  =  UDP Encapsulation packets – these are UDP packets that are encapsulated for passing through NAT.

Note: Look out for packets only showing in one direction, each stage there should be packets back and forth from/to the server.
If you see all of the above but it is still not connecting, check your security settings – username/password, pre-shared key, turn off any firewalls (including Windows firewall) and check the <a href=”vpn.html#registryfix”>Windows registry hack</a> has been performed and the PC rebooted.

Synopsis

The purpose of this project was to develop a stepper motor driver for 2-phase unipolar stepper motors that has built in current control. The eventual target project for this driver is for my CNC milling machine that I am currently planning out. This needs a few elements that are combined to provide a full driver.

• Firstly a method of providing the required coil sequencing to step the motor backwards and forwards.
• Once this is established the current being supplied to the motor coils needs to be limitted in some way to stop melting anything… The obvious option here is to use a chopper circuit.
• Once the driver is up and running a power supply needs to be built to cope with the current the motors require.
• Finally an intelligent controller is required to provide the correct number of steps for a required distance of travel. Many simply use a PC parallel port for this on CNC projects but I want this to be more of a stand-alone driver that can be used for other things. Ideally I will include ethernet control so that I can run the CNC machine remotely from the comfort of my living room instead of the cold garage and negates the need for a dedicated control PC.

The device

The device is based around an L297 driver IC that performs the translation step (ie takes clock and direction input and generates the correct output sequence for driving the stepper) and has current limitting abilities. Additional logic and driver circuitry is then added to drive the motor coils. Each motor driver is fully independant of the other drives and is controlled with its own clock and direction signals, has a seperate current limitter setting and should not interfere with each other.

• Circuit diagram
  C7, C8 and C10 provide PSU filtering.
  R1 and R2 set the output voltage of the LM317 regulator.
  R6 (variable) and C1 set the chopper frequency.
  R11 is a pull-up for the direction line to ensure it stays ‘stable’.
  R4 and C6 provide a filter for the direction line.
  R10 and C2 provide a filter for the pulse line.
  R12 is a pull-down to disable the outputs until set high.
  R3 pulls H/F up so it can be toggled on or off easily by JP1.
  R14 and R8 (variable) set the VRef reference voltage that determines the motor current.
  C3 gives some voltage stability to the reference voltage.
  C4 and C5 provide filters for the current sense lines.
  R9 and R10 reduce current flowing from the sense resistors to the L297.
  R7 and R13 are the sense resistors used to measure the current flowing through the motor coils.
• The finished product photos will be added soon

Development choices, tips and debugging

In reaching this final solution I went through many designs, some of my own, some through various searches on the net. The final design is a combination of a few of the most common designs that can be found on the internet. One useful site I used is http://www.pminmo.com/ there are some good designs of stepper drivers and also a bulletin board where people share experiences and the owner gives great help. A good resource for describing stepper motors is Jones on Stepping Motors

FET choice

The FETs must be chosen to allow the switching of each coil in the motor at full current. They must also be able to cope with the inductive EMF spike generated by the motor that could otherwise destroy the FET. Some circuits show diodes being used to help control this spike and protect the FET, however in my experiments they caused more problems than they solved and generated a lot of heat. My circuit solution is simply to use FETs that are rated high enough to cope with this spike without the diode. Approximetly I have spec’d this as around 4 times the supply voltage, however there may be a better calculation to work out the exact requirement.
The next thing to consider is the logic level that will be used to turn the FETs on/off, referred to as Vgs (voltage across the gate-source junction). In practice Vgs = Vcc – Vsense. ie The voltage across the FET gate is the supply voltage less the voltage across the sense resistor. The voltage across the sense resistor must therefore be controlled/limitted and the FET spec’d to work with ‘what is left’. The sense resistor voltage is limitted by the L297 device by means of the current limitting circuitry. When Vsense (voltage across the sense resistor) reaches the reference voltage into the L297 Vref pin the inhibit output lines drop, in turn switching off the FETs and dropping Vsense. This sequence repeats giving an oscillating voltage across the sense resistor, this is known as the chopper action. In practise when measuring this ‘chopped’ voltage the reading is approx 2/3 of Vref, but for our calculations (giving us some VAT) it is best to use Vref itself in the calculations. So re-writing the previous formula: Vgs = Vcc - Vref.
We set Vref between 0-1V and use a supply voltage of 5V for the logic. So Vgs = 5 - 1 = 4V. Now we need to refer to the datasheet of our FET and look at the Vgs vs Ids graph and ensure that when Vgs=4V the graph is not in its linear section (ie it has levelled out) and is therefore fully switched on. This will give us the best possible performance out of the FET. Note that some FETs do not switch on fully until Vgs >= 5/6/7 volts. Be careful in choosing different FETs paying attention to this specification.

After trying a few different models I eventually chose to use the IRL640 FETs as they performed the best and matched all of my required specifications. They have a Vds of 200V, meaning they should cope well with the inductive motor spike without needing diodes and a Ids of 17A, which is more than enough for the steppers motors I will ever use. These come in a TO220 package so are easy to mount and heatsink.

Misc circuit choices and information

The clock and direction pins use RC filters to help to stop interference giving invalid clocks to the L297. Although the exact resistor and capacitor values are not critically important they must not limit the step rate required for our maximum clock speed. The max allowed frequency to pass through the filter is t=RC. The L297 needs a step width of 500nS to operate, therefore we do not want to stop pulses greater than this. Choosing to allow steps of 200nS (ie 0.0002 seconds) through will give us a maximum clock speed of 5kHz. This will allow most steppers to reach top speed. Therefore R*C (R in KOhm, C in pF) will give us the actual pulse width allowed (in nS). Therefore a 2.2K resistor and a 100pF capacitor provides a reasonable filter.

The sense resistors should be metal film type and not wirewound, as the inductive properties of the wirewound resistors add additional complication and do not work as well as non-inductive types.

The ideal chopper frequency for the driver needs to be set for the motor being used, too high or too low a frequency can cause audible noises/buzzes and/or run the motors hot.

Always ensure the FETs are heatsinked, even if they don’t get hot it is not worth risking. Be aware though that most FETs (including the IRL640′s) have the tab as the drain and need to be isolated from the other FETs tabs. This means that they either need seperate heatsinks that do not touch each other, or a common heatsink with isolating mounts.

Current calculations

Setting the values for the sense resistors is perhaps the only main change to the circuit design that will be needed based on the motor being used. The calculation we will use is Motor current Imax = Vref / Rsense. We ideally want to limit the current for the motor to its maximum when Vref is at its maximum, therefore we cannot (in theory) damage the motor by turning Vref up too high. We have already stated that Vref should not exceed 1.0V, so we can simplify the calculation to Imax = 1 / Rsense or Rsense = 1 / Imax. So with a motor with a maximum current of 2A per coil, Rsense = 1 / 2 = 0.5 Ohms. The power then disapated through the resistor is Psense = Isense * Vsense. Vsense should not be greater than 1.0V, so taking this as a worst case maximum, Psense = Isense * 1 = Isense, so the power disapated is equal to the motor current value (in this case 2Watts). At this rating, ensure the resistors used are rated to this value, and expect them to get nice and warm! In practice you may find that a lower power rating is ok to use as you won’t run the motor at full current and the voltage across the sense resistor doesn’t actually reach Vref, but feel free to have a play. Cooling the resistors with a fan is not such a bad idea, and with some thought the same fan can cool the FET heatsink also.

Fault finding

The first thing to check in the event the motor is not behaving correctly is that the wiring is correct, check and double check each pin on the L297, 74AC08 and FETs. Once you are sure everything is correct, check for shorts across the board. Next switch on the power and check the supply voltage to each IC. Once this is done ensure the four LED’s are switching as the clock line is pulsed, if not then there is something wrong with the L297/AND gate circuit side, to confirm remove the motor and if possible the motor supply voltage (leaving the logic level voltage on). These should follow this sequence:
1001
1010
0110
0101
If this sequence is correct then check the FETs. Switch off the power and check the following using a multimeter:
Resistance measure:
Pin 1-2: should be nothing *(nothing)
Pin 2-3: should be approx 3 MegOhms *(2.5MOhms)
Pin 1-3: should be nothing *(100 Ohms)
Diode measurement setting:
Pin 1-2: should be nothing *(nothing)
Pin 2-3: should be 0.5V *(0.5V)
Pin 1-3: should be nothing *(0.1V)
*The values shown in brackets were measured from a blown (dead) device, although a blown device will not always show these values this is just one case.

Limitations

• The supply voltage should be no higher than approx 50V – I need to confirm the exact maximum voltage.

Future expansion and development

• The next stage of development is to include this design into an ethernet based 3-axis stepper motor controller. This then will be used to control my CNC miller.
• Once the 3-axis controller is complete and the CNC miller running I will produce some ‘final’ PCB boards for the drivers.
• Also a high current PSU needs to be built to drive all 3 motors (2A/phase 2-phase ON = 4A per motor. 4A * 3 = 12A).

To test N channel MOSFETs for basic functionality, follow these steps:

• 1: Ensure the MOSFET is out of circuit, then place the DVM into the Diode test position. Attach the positive lead (Red) to the Drain terminal, and the negative lead (Black) to the Source terminal. Confirm an Open circuit condition.
• 2: Leaving the negative lead (Black) attached to the Source Terminal, remove the positive lead (Red) and briefly attach it to the Gate terminal. This applies a voltage to the gate of the MOSFET through the DVM’s internal battery.
• 3: Repeat Step 1. This time, confirm device conduction.
• 4: Attach the negative lead (Black) to the Gate Terminal, and the positive lead (Red) to the Source terminal. This turns the device off by reversing the Gating voltage (making it more negative). Repeat Step 1, and confirm an Open circuit condition.
• 5: If the MOSFET has a built in Protection Diode (this is connected across the Drain and Source Terminals), attach the negative lead (Black) to the Drain terminal, and the positive lead (Red) to the Source terminal. Confirm a forward voltage drop of between 0.2 to 0.8V DC.

For P channel MOSFETs reverse the multimeter probe polarity.

transistor testing …

NPN transistors can be tested by using the diode test on a digital volt meter. A working transistor should test correctly between the base and collector and between the base and emitter (Negative probe on base). There should be no continuity between the collector and the emitter.
For PNP transistors reverse the multimeter probe polarity.

Install Apache then MySQL with default options. Download and unzip PHP to C:\PHP\ (or other suitable directory).

Apache Config

Edit the httpd.conf file and add the following lines:

LoadModule php5_module C:\php\php5apache2_2.dll

AddType application/x-httpd-php .php

AddType application/x-httpd-php-source .phps

(Modify the php dll version according to the PHP version – these files can be seen in the php directory. Pick the one that is most appropriate).

Find the line containing DirectoryIndex, append index.php to the list of default files. E.g:
#
# DirectoryIndex: sets the file that Apache will serve if a directory
# is requested.
#

DirectoryIndex index.html index.php

Test Apache

Restart apache from the server monitor.

Navigate to http://localhost/index.html

If Apache is working, a test page should be being displayed.

Test PHP

Create a new file in the docroot, index.php.
Enter the following line:

Navigate to http://localhost/index.php

If PHP is working, a full page of PHP information will be displayed.

PHP Config

From the PHP directory, copy the “php.ini-recommended” file into the windows folder (default: C:\WINDOWS\). Open the INI file and make the following modifications:

• short_open_tag = on
• doc_root = C:\Program Files\Apache Software Foundation\Apache2.2\htdocs\ (set to actual apache docroot)
• extension_dir = “c:/php/ext/”

Save and close the php.ini file.

MySQL for PHP

• Uncomment the extension=php_mysql.dll line in the c:\windows\php.ini file.
• Copy the “libmysql.dll” file from the PHP directory into the c:\windows\system32\ directory. (this is one thing that is often forgotten about in other setup guides).
• Restart apache
• Refresh the phpinfo file we created. If the MySQL module is working it will be shown in the list of available modules on the page.

Resetting the MySQL server root password

• Create a new text file “c:\mysql.txt” and place in the text:

UPDATE mysql.user SET Password=PASSWORD(‘newpassword’) WHERE User=’root’;

FLUSH PRIVILEGES;

• • Stop the MySQL service
  • From the command prompt, navigate to the MySQL bin directory
  • Run the following command:
    • mysqld.exe –init-file=c:\mysql.txt –console

      ''' <summary>
      ''' Move selected items up or down in the specified listview
      ''' </summary>
      ''' <param name="lvwListView">The listview to manipulate</param>
      ''' <param name="blnMoveUp">True to move items up, False to move them down</param>
      Private Sub MoveItemsInListView(ByRef lvwListView As ListView, ByVal blnMoveUp As Boolean)
            Try
                  'Set the listview index to limit to depending on whether we are moving things up or down in the list
                  Dim intLimittedIndex As Integer = (lvwListView.Items.Count - 1)
                  If blnMoveUp Then intLimittedIndex = 0

                  'Define a new collection of the listview indexes to move
                  Dim colIndexesToMove As New List(Of Integer)()

                  'Loop through each selected item in the listview (multiple select support)
                  For Each lviSelectedItem As ListViewItem In lvwListView.SelectedItems
                        'Add the item's index to the collection
                        colIndexesToMove.Add(lviSelectedItem.Index)

                        'If this item is at the limit we defined
                        If lviSelectedItem.Index = intLimittedIndex Then
                              'Do not attempt to move item(s) as we are at the top or bottom of the list
                              Exit Try
                        End If
                  Next

                  'If we are moving items down
                  If Not blnMoveUp Then
                        'Reverse the index list so that we move items from the bottom of the selection first
                        colIndexesToMove.Reverse()
                  End If

                  'Loop through each index we want to move
                  For Each intIndex As Integer In colIndexesToMove
                        'Define a new listviewitem
                        Dim lviNewItem As ListViewItem = CType(lvwListView.Items(intIndex).Clone(), ListViewItem)

                        'Remove the currently selected item from the list
                        lvwListView.Items(intIndex).Remove()

                        'Insert the new item in it's new place
                        If blnMoveUp Then
                              lvwListView.Items.Insert(intIndex - 1, lviNewItem)
                        Else
                              lvwListView.Items.Insert(intIndex + 1, lviNewItem)
                        End If

                        'Set the new item to be selected
                        lviNewItem.Selected = True
                  Next
            Catch ex As Exception
                  Trace.WriteLine("MoveItemsInListView() has thrown an exception: " & ex.Message)
            Finally
                  'Set the focus on the listview
                  lvwListView.Focus()
            End Try
      End Sub

We wanted a cheaper alternative to an ipad but with similar features, and I think this could be the solution!

Initial testing is positive, it is easy to use, relitively fast (ok not quite so much as an ipad but certainly faster than some others I have tried) and it seems robust.

One main disappointment is the lack of google market place out of the box but there are ways round this for installing apps so its not a show-stopper.

Typing is quick and responsive (i’m typing this post on it now) although occassionally you will have to be a bit more ‘positive’ pressing the likes of the home button for it to respond.

Wireless LAN setup without any issues and internet access is very useable. I think it may get borrowed for some weekends for living room browsing……

I have for a while now been looking for a solution for backing up my important files and photos online. After much research and testing various backup providers I found that CrashPlan offered the best value vs quality of service.

Crashplan provides both a Windows and a Linux service that can be used to backup files, in particular interest is that the service can be run in a ‘headless’ mode whereby the service can be run on a linux box and administered from a windows desktop client.

I currently use a QNAP TS-210 NAS box to backup all of my data and my ideal setup is to keep this in place and automatically backup everything on it to the internet.

On a standard Linux box this setup is simple and straight-forward, unfortunately things on the QNAP are not so straight forward because it uses a Kirkwood Marvel Atom processor that the java jre that crashplan uses does not directly support.

I have used a number of resources in order to achieve my working setup, these acknowledgements are given at the bottom of this post.

The problem
The main problem in running the CrashPlan engine on the QNAP is that the java runtime that it installs fails to start the service correctly, reporting an error in the engine_error.log file. To try and rectify this I removed and reinstalled CrashPlan without installing the bundled java environment. I chose to manually install the java sdk using ipkg. This enabled the service to start but it immediately stopped with an invalid jtux error in the engine_output.log file. Google searching revealed that this meant that the java jtux library needs to be recompiled on the QNAP itself in order to generate a working jtux library file. After multiple attempts I found that I could not re-build this library on the QNAP firmware as the required packages could not be installed (or I simply couldn’t find the correct combination of packages to install).

Debian Squeeze on the QNAP
I came across an interesting article that detailed how to install Debian on the QNAP and decided I would give this route a try in order to achieve what I wanted. This proved the correct choice. I followed this article in order to install Debain which went quite smoothly. The main steps for this were:

First create backups of the QNAP flash blocks:
cat /dev/mtdblock0 > mtd0
cat /dev/mtdblock1 > mtd1
cat /dev/mtdblock2 > mtd2
cat /dev/mtdblock3 > mtd3
cat /dev/mtdblock4 > mtd4
cat /dev/mtdblock5 > mtd5

Download the flash installer:
cd /tmp
busybox wget ftp://ftp.debian.org/debian/dists/testing/main/installer-armel/current/images/kirkwood/network-console/qnap/ts-219/initrd.gz
busybox wget ftp://ftp.debian.org/debian/dists/testing/main/installer-armel/current/images/kirkwood/network-console/qnap/ts-219/kernel
busybox wget ftp://ftp.debian.org/debian/dists/testing/main/installer-armel/current/images/kirkwood/network-console/qnap/ts-219/flash-debian
busybox wget ftp://ftp.debian.org/debian/dists/testing/main/installer-armel/current/images/kirkwood/network-console/qnap/ts-219/model


Run the flash installer, this will load the installer into flash so that upon the next reboot it will load the Debian installer:

sh flash-debian


This will display something similar to:

Updating MAC address...
Your MAC address is XX:XX:XX:XX:XX:XX
Writing debian-installer to flash... done.
Please reboot your QNAP device.


Reboot your NAS box. The NAS will start to boot and the status led will flash red/green for a short while before turning solid green and then it will give a short beep to indicate it is ready.

Debian Installer Setup
As the NAS doesn’t have a display you need to SSH into the installer. If the NAS was setup before with a static IP it is likely this IP will still be used, if not it may have booted from DHCP. Login to SSH with the username: installer and the password: install.

Follow the installer GUI to setup the NAS box as required. The Installer Guide may help with the options available. I setup RAID0 to maximise my available disk space and otherwise used quite standard setup options. If I re-install the box again I will further detail these setup pages. For disk partitioning I used the ‘Guided Partitioning’ option and chose to use the entire disk (without LVM) and to basic partition split. After this I setup RAID0 choosing the two large partitions to RAID.

Setup Debian
Setup your Debian installation as required, I setup Apache, MySQL, and Samba to start with. Format your RAID partition using mke2fs and mount it by adding it to /etc/fstab.

Install Packages
Installed required packages in order to get crashplan working.
apt-get install openjdk-6-jdk
apt-get install make
apt-get install gcc
apt-get install libjna-java

Install CrashPlan
cd /usr/
wget http://download.crashplan.com/installs/linux/install/CrashPlan/CrashPlan_3.0.1_Linux.tgz
tar xfz CrashPlan_3.0.1_Linux.tgz
cd CrashPlan-install
./install.sh

Choose default paths for installation but choose NOT to install the embedded java runtime.

Patch jtux
Download the jtux patch file from this discussion post.

cd /usr/
wget http://basepath.com/aup/jtux/jtux.tar.gz
tar zxfv jtux.tar.gz
Copy jtux.PS3-YDL6.1.patch.txt into jtux path
patch <jtux.PS3-YDL6.1.patch.txt
nano Makefile
Set JAVA_INCLUDE = /usr/lib/jvm/java-6-openjdk/include
make

I have now attached my compiled version of the jtux library: libjtux.so

Backup existing crashplan jtux library:
cp /usr/local/crashplan/libjtux.so /usr/local/crashplan/libjtux.so.bak

Copy new file in:
cp libjtux.so /usr/local/crashplan/

Patch CrashPlanEngine:
cd /usr/local/crashplan/bin/
nano CrashPlanEngine
Replace line starting with FULL_CP:
FULL_CP=”/usr/share/java/jna.jar:$TARGETDIR/lib/com.backup42.desktop.jar:$TARGETDIR/lang”

Start CrashPlan Engine:
./CrashPlanEngine start

At this point your CrashPlan engine should be starting, check its status with ./CrashPlanEngine status
Be patient though, it may take a few minutes for the service to come up fully. Check whether it is listening with: netstat -na | grep 4243 and see if any ports are open, once they are you should be able to connect using the CrashPlan desktop client.

CrashPlan Client
Configure your desktop client as per the guide on the CrashPlan support site: Configuring a Headless Client. I used Putty to SSH into the box, creating a tunnel and then connected using the client software.

You should now be able to login and setup backups as normal.

I selected my raid disk directory for backup and left it to upload my entire backup storage to the cloud!

If I have time I want to perform some further tests in order to see if I could have re-compiled the jtux library on the QNAP firmware without installing Debian and also I would like to provide some more detail (for my own reference as much as anything) on how the RAID partitions were setup.

Although not tested, I believe this method will work for any Marvel cpu device, including the QNAP TS-110, QNAP TS-119, QNAP TS-119P+, QNAP TS-210, QNAP TS-219, QNAP TS-219P QNAP TS-219P+, Sheevaplug and ReadyNAS equivalents. Please let me know if you have installed on any of these or any other devices.

Good luck!