WiFi to ethernet adapter for an ethernet-ready TV

THIS PROJECT, AND THE AMENDEMENT BELOW ARE NOW REPLACED BY A NEW UP TO DATE VERSION YOU CAN FIND HERE
**********************************************************************************************

IF YOU ARE INTERESTED IN TRYING OUT THIS PROJECT THEN PLEASE READ THE AMENDMENT PUBLISHED ON MAR 19th 2015 HERE

I have an internet ready Panasonic TV which can connect via a wired ethernet cable to a suitable internet-connected router, or via a wireless connection using a Panasonic usb wifi Dongle. Unfortunately this is quite expensive in the region of £50-£60 pounds and I couldn’t justify the expense for the limited number of times I might use it. However, it occurred to me that it should be possible to build a wireless to ethernet adapter using a raspberry pi.

If you do not want to wade through the whole article (although I hope you will) you can jump to the end where a zip file is available to download with instructions to enable you to get up and running quickly

I had previously built a wireless access point using the Rpi based on the Pi-Point Article amended according to the article by Jens Segers to allow for the fact that I was using an Edimax EW-7811Un wireless adapter which requires a special modified hostapd. (The basis of these articles has been nicely brought together by Dave Conroy in a form which is much easier to follow here. What I now required was basically something working in the opposite direction.

I Googled the topic and found a project  by Glenn Lockwood to configure a Raspberry Pi as a Wireless-to-Wired Ethernet Bridge…just what I wanted Most of the work is contained in his article which is excellent, but I found one major gotcha which caught me out and took some time to solve. There were also one or two points which could be made a bit clearer, and I will take the opportunity to start from scratch in developing this project with full step by step details to make it easy for you to follow.

What you need:
A Raspberry Pi Model B (256 or 512Mb is ok) and psu
An SD card 2Mb or larger and a usb SD card reader (if your PC does not have an SD card slot)
A usb WiFi adapter. I used the Edimax  EW-7811Un currently £7.95 from play.com
and ethernet cable to connect the Rpi to the TV

A PC or Mac with a card reader to enable you to setup the SD card.

I assume that you also have an internet connection via a wireless broadband router with a spare ethernet socket into which a PC (or Rpi) can be plugged. In my case this is a Netgear DGND3300v2. This router should be set up to configure attached computers via DHCP, i.e. to automatically configure its network IP address and DNS etc, By default the Rpi expects this to be the case when an ethernet cable is plugged in to its ethernet port,

Stage one: Setting up your RaspberryPi SD card
Install the latest Raspian distribution onto the SD card. You can download it here onto your PC (currently latest is 2013-05-25-wheezy-raspian.zip)
You then unzip it (on Windows 7 right click on the zip file and select extract all)
Also downloaded Win32DiskImager from here, again unzipping the downloaded file
insert your SD card into the usb card reader and plug this into a free usb slot on your PC.
Note carefully which drive it mounts on (in my case drive F)
Now run Win32DiskImager by double clicking the unzipped file
insert your SD card note you can double click any image to see a larger copy, and then use the back button on your browser to return

select the correct drive letter for your SD card…Be certain you get this right
and click the blue folder icon to navigate to the wheezy-raspian image
Then click the Write button, acknowledge the warning dialog that pops up and you will write the image to your SD card which will take a minute or two. You should get a dialog box saying Write Successful when it completes.
quit the win32DiskImager program and you should see your SD card in the relevant drive (F). it will contain the Boot partition for the raspberry PI. About 40Mb or so of files.
Eject the card from the PC and insert it into your Raspberry Pi.

Stage 2: Booting the Raspberry Pi and setting up the network interfaces
Initially it is easiest to set up the Rpi with an hdmi monitor connected, together with a keyboard and mouse, and an ethernet cable connected to your router. Leave the usb WiFi adapter aside to start with.
Plug in the SD card, and connect the power, and all being well the Rpi should boot up and show the raspi-config screen. This lets you carry out some initial configuration.
Working through the choices,:
1: select Expand the Filesystem. It won’t have much effect if you are using a 2Gb SD card, but will give you extra free space if you have a bigger capacity card.
2: Change the user password for the pi user, from the default raspberry to something else you can remember
3: leave the option boot to desktop unset. Since we will not use the desktop for this project we want the Rpi to boot to command line
4: Set the time-zone appropriate for your location (I chose Europe, London)
5: Although I have a camera on my Rpi, you probably won’t want one on this project so you can leave unset
6: Ignore 6 just now
7: ignore 7. no need to overclock for this project
8: select option 8 and adjust Memory split so that only 32Mb is allocated to the GPU. We won’t be using graphics so it is better to have more memory for other purposes
Also enable ssh. This will enable us to talk to the Rpi directly from our PC later, which is convenient when setting it up.
now use the right arrow key to select finish and press return, Select the default Reboot and press return again
When the boot process completes, log in as the user pi with your newly chosen password

The first thing to check is that your Rpi is connected to the network and the internet.

Type ping google.com press return and you should see something like the following
terminate the process by typing ctrl+C (shown as ^C)

pi@raspberrypi ~ $ ping google.com
  PING google.com (173.194.41.69) 56(84) bytes of data.
  64 bytes from lhr08s01-in-f5.1e100.net (173.194.41.69): icmp_req=1 ttl=56 time=11.1 ms
  64 bytes from lhr08s01-in-f5.1e100.net (173.194.41.69): icmp_req=2 ttl=56 time=11.3 ms
  64 bytes from lhr08s01-in-f5.1e100.net (173.194.41.69): icmp_req=3 ttl=56 time=11.2 ms
  64 bytes from lhr08s01-in-f5.1e100.net (173.194.41.69): icmp_req=4 ttl=56 time=10.7 ms
  ^C
  --- google.com ping statistics ---
  4 packets transmitted, 4 received, 0% packet loss, time 3005ms
  rtt min/avg/max/mdev = 10.797/11.120/11.307/0.198 ms
  pi@raspberrypi ~ $

This shows that packets are travelling to and from google.com on the internet

find out the ip address allocated to your Rpi by typing the command ip addr

pi@raspberrypi ~ $ ip addr
  1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN
  link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  inet 127.0.0.1/8 scope host lo
  2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
  link/ether b8:27:eb:8e:b7:42 brd ff:ff:ff:ff:ff:ff
  inet 192.168.1.17/24 brd 192.168.1.255 scope global eth0
  pi@raspberrypi ~ $

This shows the adapter eth0 has (in my case) an ip address 192.168.1.17
(the address you get will depend upon the range of addresses that your router is set up to serve by DHCP. In my case it is in the range 192.168.1.10 to 192.168.1.50 Other routers may have for example ranges of 192.168.0.10 to 192.168.0.50 or 10.0.0.18 to 10.0.0.50 or 10.0.1.10 to 10.0.1.50) In most cases you can configure the range. If you have a different range you may have to alter some of the addresses used later when we configure the wireless adapter on the Rpi

At this stage I prefer to work from my main computer and to use an SSH connection to the Rpi. SSH stands for Secure Shell and is a way of connecting to the Rpi from an external computer via a network connection as if you were typing directly on the Rpi locally.

On a PC the easiest way to do this is to download a program called putty from here. Choose the link to putty.exe and download it to your PC
Double click the putty.exe file and accept that you want to run it
Add the Rpi ip address in the Host Name (or IP address) box
Type Rpi in the Saved Sessions box and click save. (This is to make it quicker next time you open the link)

Then click Open  You will see the warning below, to which you respond Yes

now log in to the Rpi using the username pi and your saved password
All being well you will see a similar screen to the one below

On a Mac computer you don’t need putty. The built in Terminal App has an option to open an SSH connection. Just start terminal and in the resulting window you can type
ssh pi@192.168.1.17 and press return, filling in the password when prompted.

Now that we have a SSH connection to the Rpi we can dispense with the connected keyboard, mouse and use it “headless”. To do this in your putty or mac ssh terminal type
sudo shutdown -h now
and press the return key. This will shut down the Rpi and break the ssh connection
Switch off the power to the Rpi, remove the keyboard and mouse (you can retain the monitor if you wish just now) and plug in the WiFi usb adapter
Reconnect the power to reboot the Rpi.
When the boot process is complete and the login pormpt is showing on the monitor reconnect via SSH using putty (or your Mac)
When you start Putty you can select Rpi and load in the details to save typing before clicking on Open, and logging in as pi with your password

Now we are going to setup the Wireless connector which uses the interface wlan0
To do this we need to edit the network interfaces file. This is in the directory /etc/network To do this we will use the built in editor called nano
In case of accidents we will first backup the existing configuration file

Type the following commands  (as shown in the illustration below)
cd /etc/network
ls
sudo cp interfaces interfaces.bak
ls
sudo nano interfaces

This opens up the nano editor with the existing contents of the interfaces file

use the arrow keys to move down to the end of the file, then press the back arrow key (above return key) to delete the last three lines of text
iface wlan0 inet manual to iface default inet dhcp

Then add the lines below

iface wlan0 inet static
 address 192.168.1.98
 netmask 255.255.255.0
 broadcast 192.168.1.255
 gateway 192.168.1.1
 wpa-ssid "XXXXXXXXXXX"  (substitute your values for xxxxxx in these two lines)
 wpa-psk "XXXXXXXXXXXX"
 wpa-group TKIP CCMP
 wpa-key-mgmt WPA-PSK

after allow-hotplug wlan0
to give a screen like the one below

Note the blacked out sections contain the name of your router WiFi ssid identifier and the pass phrase (psk) to enable a computer to connect to it. These will be the same as you used when connecting any wifi computer to your router. Substitute your own values
Now type ctrl+o to write out the modified interfaces file, followed by pushing the return key, followed by ctrl+x to exit the editor. If you type cat interfaces you should see the contents of the file as below

auto lo
iface lo inet loopback
 iface eth0 inet dhcp
allow-hotplug wlan0
 iface wlan0 inet static
 address 192.168.1.98
 netmask 255.255.255.0
 broadcast 192.168.1.255
 gateway 192.168.1.1
 wpa-ssid "XXXXXXXXXXX" (XXXXXXX will have your own values instead)
 wpa-psk "XXXXXXXX"
 wpa-group TKIP CCMP
 wpa-key-mgmt WPA-PSK

The additional lines will set up the wireless interface (wlan0) with a static or fixed address, in this case 192.168.1.98 I have chosen this address as  it is on the same network as the addresses served by the router when using dhcp, but outside that range (192.168.1.10 to 92.168.1.50), so there is no chance of another computer being allocated the same address
If your router serves a different range you will have to choose your own appropriate address here. The broadcast address is used to address all computers on the same network, and the gateway is the address to which packets are routed when the address is not on the same network, e.g. Google’s address 173.194.41.69 used in the earlier ping example.
The wpa-ssid and wpa-group entries should contain the values appropriate to your own wireless router
The best way to activate the new settings is to reboot the Rpi by typing
sudo shutdown -r now
the -r parameter causes it to reboot. Previously we used -h to halt the Rpi i.e. shut it down

all being well, when the Rpi reboots on the hdmi monitor you should see that two ip addresses are displayed at the end of teh boot sequence. In my case

192.168.1.17 and 192.168.1.98 these being the dhcp supplied 192.168.1.17 address for eth0 and the static address 192.168.1.98 for the wlan0 interfaces

If you reconnect via ssh as previously described and type ip addr

you will see something like this

1: lo: <LOOPBACK,UP,LOWER_UP> mtu 16436 qdisc noqueue state UNKNOWN 
  link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  inet 127.0.0.1/8 scope host lo
 2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
  link/ether b8:27:eb:8e:b7:42 brd ff:ff:ff:ff:ff:ff
  inet 192.168.1.17/24 brd 192.168.1.255 scope global eth0
 3: wlan0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
  link/ether 80:1f:02:8a:05:cf brd ff:ff:ff:ff:ff:ff
  inet 192.168.1.98/24 brd 192.168.1.255 scope global wlan0

showing details of the internal loopback address and the two external eth0 and wlan0 interfaces

Stage 3 reconfiguring the ethernet eth0 interface

Now that we have the permanent static address setup for the wireless interface, we can connect to the Rpi through that, and the reassign the ethernet eth0 connection to a separate network to which the tv will be connected. I have chosen to use the network 192.168.2.0 and allocate 192.168.2.1 to the Rpi. Later the TV will get an address which will be on the same new network.

First we set up the new ssh connection. Close the existing ssh connection by typing exit and then restart putty and setup a connection to 192.168.1.98 (you can save the settings as RpiWlan as we did before for Rpi and the 192.168.1.17 address)

Open it and connect with username pi and your usual password

(in the case of a Mac simply type ssh pi@192.168.1.98 in a terminal window)

In both cases accept the new credentials as we did when first connecting to 192.168.1.17

Now we need to return to the interfaces file and amend it.

type cd /etc/network
sudo nano interfaces
to load the file into the nano editor as before

Alter the file so that it reads

# The loopback network interface
 auto lo
 iface lo inet loopback
# the internal (wired) network interface
 allow-hotplug eth0
 iface eth0 inet static
  address 192.168.2.1
  network 192.168.2.0
  netmask 255.255.255.0
  broadcast 192.168.2.255
  gateway 192.168.2.1
# the external (wifi) interface
 allow-hotplug wlan0
 iface wlan0 inet static
 address 192.168.1.98
 netmask 255.255.255.0
 broadcast 192.168.1.255
 gateway 192.168.1.1
 wpa-ssid "XXXXXXXXXXX" (insert your own values for XXXXXX in these two lines)
 wpa-psk "XXXXXXXXXX"
 wpa-group TKIP CCMP
 wpa-key-mgmt WPA-PSK

Notice that we have added some comment lines starting with a # to help understand the three different sections of the file

nano hints
To insert a blank line, move to the beginning of a line and press return
To delete a line position the cursor on the line and press ctrl+k
use the backspace arrow to delete characters
When you have finished amending the file use ctrl+o to write out the amended file, selecting the existing filename to overwrite by pressing return. Then select ctrl+x to exit the editor

you can type cat interfaces to check the file contents

if you spot a mistake just use sudo nano interfaces to edit the file again

Once you are happy unplug the ethernet lead, as we can no longer connect via eth0 to our normal network and reboot the pi (sudo shutdown -r now), then reconnect via ssh

on the Rpi monitor you should see two ip addresses shown at the end of the boot process 192.168.2.1 and 192.168.1.98

stage 4 Setting up forwarding and NAT

We now have the correct addresses setup on our two network interfaces. we need to concentrate on how they are connected together. We want packets sent from the TV on the 192.168.2.0 network to travel across to the 192.168.1.0 network connecting to it via the wlan0 interface on 192.168.1.98 Any responses to traffic it sends out have to be rerouted back to the 192.168.2.0 network and travel back to the TV via the wired eth0 interface.

The two networks have different address ranges, so a process called NAT or Network Address Translation is carried out whereby packets from the TV are coded up to appear to come from 192.168.1.98  When replies come to these packets they have the address 192.,168.1.98 stripped and are returned to the originating TV on 192.168.2.100. Just as devices on the internet cannot see your PC directly, but only the router through which it connects to the internet, neither can devices on your normal network see the TV directly.

The rules which govern this transfer of packets and the translation are generated by a package called iptables which is included in the raspian distribution. Full details of how the rules work goes a bit beyond the scope of this article, but there are numerous places on the internet where you can get more information about how they work, such as this one

The rules are stored in memory, and are normally lost when you reboot, so it is necessary to store them so that they can be reloaded, which is done conveniently every time the network interfaces are reinitialised.

The rules can be entered manually one by one, but it is more convenient to write a bash script, which is really just a list of commands which are executed one after another to carry out the same process more easily.

The rules are held in tables, and if you are going to play around with these it is a good idea to start with a script which will reset everything to the default setup with no rules in place.

I found the script below which does this job

#!/bin/sh
 IPTABLES="$(which iptables)"
# RESET DEFAULT POLICIES
 $IPTABLES -P INPUT ACCEPT
 $IPTABLES -P FORWARD ACCEPT
 $IPTABLES -P OUTPUT ACCEPT
 $IPTABLES -t nat -P PREROUTING ACCEPT
 $IPTABLES -t nat -P POSTROUTING ACCEPT
 $IPTABLES -t nat -P OUTPUT ACCEPT
 $IPTABLES -t mangle -P PREROUTING ACCEPT
 $IPTABLES -t mangle -P OUTPUT ACCEPT
# FLUSH ALL RULES, ERASE NON-DEFAULT CHAINS
 $IPTABLES -F
 $IPTABLES -X
 $IPTABLES -t nat -F
 $IPTABLES -t nat -X
 $IPTABLES -t mangle -F
 $IPTABLES -t mangle -X

you can set this up in the home directory for the user pi by typing
cd ~/ (in the ssh terminal window)
nano resetiptables

and then copying and pasting the script into the nano editor window and saving the file as detailed previously. [You can copy by selecting the text and using ctrl+C (PC) or command+C (Mac) then right click to paste in Putty or right click and choose paste (Mac) ]

You can check if it works by typing cat resetiptables to list the script. If it hasn’t worked you can delete the file with rm resetiptables and try again

the script sets IPTABLES to the address of where your iptables program is (/sbin/iptables) and then repeatedly calls the program with the following command lines to clear out existing rules and set up the default policies

when you have created the file, one step remains which is to set its attributes to allow it to be executable. This is done by typing chmod 755 resetiptables
Finally you can run the script but this needs to be done with system privileges using sudo by typing

sudo ./resetiptables

a bit of an anticlimax as you won’t see anything, all being well

You can check there are no filter changes by typing sudo iptables -L

and no nat rules by typing sudo iptables -t nat -L

now we need to create the rules necessary to set up the forwarding and NAT that we require

the following script will program iptables to do that

#!/bin/sh
 IPT=/sbin/iptables
 LOCAL_IFACE=eth0
 INET_IFACE=wlan0
 INET_ADDRESS=192.168.1.98
# Flush the tables
 $IPT -F INPUT
 $IPT -F OUTPUT
 $IPT -F FORWARD
$IPT -t nat -P PREROUTING ACCEPT
 $IPT -t nat -P POSTROUTING ACCEPT
 $IPT -t nat -P OUTPUT ACCEPT
# Allow forwarding packets:
 $IPT -A FORWARD -p ALL -i $LOCAL_IFACE -o $INET_IFACE -j ACCEPT
 $IPT -A FORWARD -i $INET_IFACE -o $LOCAL_IFACE -m state --state ESTABLISHED,RELATED -j ACCEPT
# Packet masquerading
 #$IPT -t nat -A POSTROUTING -o $LOCAL_IFACE -j MASQUERADE
 $IPT -t nat -A POSTROUTING -o $INET_IFACE -j SNAT --to-source $INET_ADDRESS

Again you can type nano setupiptables copy and paste this into the window and save and exit as previously described. You can check that the process has worked by typing
cat setupiptables

as before you must make the script executable by typing chmod 755 setupiptables

then type sudo ./setupiptables to execute it. As before, if it works there should be no visible response. However we can dump the rules stored by iptables using the command sudo iptables-save > dump.txt which saves the files in a file named dump.txt

we can then inspect that text file using the command cat dump.txt which produces something similar to

# Generated by iptables-save v1.4.14 on Fri Jul 19 21:23:10 2013
*mangle
:PREROUTING ACCEPT [696:64118]
:INPUT ACCEPT [656:51596]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [331:40584]
:POSTROUTING ACCEPT [331:40584]
COMMIT
# Completed on Fri Jul 19 21:23:10 2013
# Generated by iptables-save v1.4.14 on Fri Jul 19 21:23:10 2013
*nat
:PREROUTING ACCEPT [45:5986]
:INPUT ACCEPT [35:2292]
:OUTPUT ACCEPT [0:0]
:POSTROUTING ACCEPT [0:0]
-A POSTROUTING -o wlan0 -j SNAT --to-source 192.168.1.98
COMMIT
# Completed on Fri Jul 19 21:23:10 2013
# Generated by iptables-save v1.4.14 on Fri Jul 19 21:23:10 2013
*filter
:INPUT ACCEPT [254:19512]
:FORWARD ACCEPT [0:0]
:OUTPUT ACCEPT [123:14100]
-A FORWARD -i eth0 -o wlan0 -j ACCEPT
-A FORWARD -i wlan0 -o eth0 -m state --state RELATED,ESTABLISHED -j ACCEPT
COMMIT
# Completed on Fri Jul 19 21:23:10 2013
# Generated by iptables-save v1.4.14 on Fri Jul 19 21:23:10 2013
*raw
:PREROUTING ACCEPT [6030:609376]
:OUTPUT ACCEPT [2047:267991]
COMMIT

This is actually an important file, saving the rules in an intermediate format understood by iptables, as we can later use the command iptables-restore to load the rules back in after a reboot

we do this by copying the file dump.txt to the /etc/interfaces dirctory, renaming it on the way as iptables, and adding a further line to the interfaces file

type sudo cp dump.txt /etc/network/iptables

then cd /etc/network followed by sudo nano interfaces to place the interfaces file in the nano editor. Move down to the end of the file using the cursor keys. press return for a blank line and add the line

pre-up iptables-restore < /etc/network/iptables

then exit using ctrl+o to write the modified file then push the return key and then type ctrl+x to exit the editor

Check the contents using cat interfaces

we have to tell the kernel program to allow packet forwarding

This is done by editing the file /etc/sysctl.conf

type sudo nano /etc/sysctl.conf

scroll down the file using the down arrow key until you see a line that says
# Uncomment the next line to enable packet forwarding for IPv4
and remove the # at the start of the next line, changing
#net.ipv4.ip_forward=1
to
net.ipv4.ip_forward=1

Then write out the file using ctrl+o followed by return and then ctrl+x to exit the editor

type the command sudo sysctl –system to enable the forwarding and you should see something like the link below. {NB for some reason the two – – in the command above merge to one. The command should have – – system at the end, but no spaces between them}

* Applying /etc/sysctl.conf …
kernel.printk = 3 4 1 3
net.ipv4.ip_forward = 1
vm.swappiness = 1
vm.min_free_kbytes = 8192

showing that ipv4 forwarding is enabled

Stage 5 fixing the routing

We are nearly done, there remains one problem, which stumped me for ages, and which is not mentioned in the original article by Glenn Lockwood

The kernel maintains a routing table that helps it to know where to send packets with different addresses

The contents can be seen with the command route

This produces

Kernel IP routing table
Destination  Gateway      Genmask        Flags Metric Ref Use Iface
default      192.168.2.1  0.0.0.0        UG    0      0   0   eth0
192.168.1.0  *            255.255.255.0  U     0      0   0   wlan0
192.168.2.0  *            255.255.255.0  U     0      0   0   eth0

This shows that any packets addressed to a network apart from 192,168.2.x (which will be routed via eth0 on 192,168,2,1 or 192.168.1.x which will be routed via wlan0 on 192,168,1,98 will by default be routed via the ethernet port on 192.168.2.1
This is not at all what we want. We want packets to unknown networks on the internet to be routed via the wlan0 interface to our network router and from thence to the internet.
In otherwords we want the default gateway to be 192.168.1.1 via wlan0 and NOT 192.168.2.1 via eth0

This is easily achieved with the two commands route del default gw 192.168.2.1 etho to remove the unwanted one and route add default gw 192.168.1.1 wlan0 to add the required one. However the question is when and where to do it. We can only apply these commands once the routing table has been set up, namely once the network interfaces have been configured. There are hooks to invoke commands after an interface has come up, but we don’t what these to happen until both interfaces are active.

The solution I have chosen is to add a script to perform the commands which is placed in the directory /etc/init.d and which is invoked at the end of the booting sequence once the interfaces have been set up.

The script can be created first in the pi home directory

type cd ~/ to get there

then nano setuproutes to edit the new file called setuproutes

paste or type the following into the nano editor window

#!/bin/sh
#/etc/init.d/setuproutes
#
### BEGIN INIT INFO
# Provides: default routes for wlan0
# Required-Start: $syslog $network
# Required-Stop: $syslog
# Should-Start:
# Should-Stop:
# X-Start-Before:
# X-Stop-After:
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# X-Interactive: false
# Short-Description: adjust default routes
# Description: removes default route 192.168.2.1 adds default route 192.168.1.1
### END INIT INFO
sudo route del default gw 192.168.2.1 eth0
sudo route add default gw 192.168.1.1 wlan0
exit 0

The line # Required-Start: $syslog $network ensures that the script is not started and run until the system logging and the network interfaces have been set up. The INIT information is required for any init.d script (which normally start and stop computer services to function properly. The actual meat of the script is in the last three lines, exit 0 ensuring that exits cleanly.
Use ctrl+o followed by pushing return to write it, then exit the editor with ctrl+x

set the execution attributes with chmod 755 setuproutes

sudo cp setuproutes /etc/init.d to put a copy in the init.d directory

To activate it to run during the boot sequence type sudo update-rc.d setuproutes defaults

reboot using sudo shutdown -r now then connect to the pi on 192.168.1.98 via ssh again as detailed before. Check that the routing table is now correct using route

You should get

Kernel IP routing table
Destination  Gateway      Genmask        Flags Metric Ref Use Iface
default      192.168.1.1  0.0.0.0        UG    0      0   0   wlan0
192.168.1.0  *            255.255.255.0  U     0      0   0   wlan0
192.168.2.0  *            255.255.255.0  U     0      0   0   eth0

showing that the default route is now correct

As final icing on the cake, we will add a dhcp server so that an IP address can be obtained automatically for the TV or any other computer plugged in to the Rpi ethernet socket. (One other use for the project would be to connect a small network switch with say5 or 6 ports on it to the Rpi to enable several computers to be serviced by the Rpi on their own mini network.)

Type sudo apt-get install isc-dhcp-server and the server package should be downloaded and installed from the internet. (If the package cant be found type sudo apt-get update followed by sudo-apt-get install isc-dhcp-server )
Note when the server is installed you may get an error message saying it can’t be started. This is normal as we have not yet configured it.
The dhcp server configuration file is stored at /etc/dhcp/dhcpd.conf We will keep a copy of this for reference and then substitute it with a new file.

Type sudo mv /etc/dhcp/dhcpd.conf /etc/dhcp/dhcpd.conf.orig to make a copy
then create a new blank file using sudo nano /etc/dhcp/dhcpd.conf

paste the following text into the file

#
# Configuration file for ISC dhcpd for Debian
#
#
ddns-update-style none;
option domain-name "rbn.local";
option domain-name-servers 192.168.1.1;
default-lease-time 600;
max-lease-time 7200;
authoritative;
log-facility local7;
#let the server know about network 192.168.1.0 but offer no service here
subnet 192.168.1.0 netmask 255.255.255.0{
}
#configure service for network 192.168.2.0 (the ethernet port)
subnet 192.168.2.0 netmask 255.255.255.0 { 
 range 192.168.2.10 192.168.2.50;
 option routers 192.168.2.1;
}

Then write it using ctrl+o and press return, then exit nano using ctrl+x

Check the contents of the file using cat /etc/dhcp/dhcpd.conf
(If your main home network is NOT on 192.168.1.x you will have to amend some of teh addresses in this file to suit. e.g. if your main router is  on 10.0.0.1)

You can now restart the dhcp server using
sudo service isc-dhcp-server restart
you will probably see the messages

[FAIL] Stopping ISC DHCP server: dhcpd failed!
[ ok ] Starting ISC DHCP server: dhcpd.

The Fail occurs because the server was not running to start with. What you want is the ok for the server starting

Stage 6 Testing and setting up the TV

At long last the project is complete. All that remains is to try it out. You can check its operation with a spare laptop or pc first if you like. Connect the Rpi ethernet socket to the ethernet socket on the laptop or PC and reboot the Rpi. The laptop or PC should be set so that its ethernet adapter will pick up an IP address using dhcp, which will usually be the case by default. All being well you should be able to access the internet from the laptop or PC.

My TV is a Panasonic Viera TX-L37E5B The Menu has an option to gonfigure the network interface. This is set up for a wired connection (to the Rpi!) and set to obtain an IP address automatically (via DHCP). After a short pause the IP address was automatically populated with 192.168.2.11 and I was able to access the various internet options provided by the TV software.

I hope that you have found this article interesting to follow. I have learned a lot in developing it.

Quick install for the impatient

Finally for those who want to try this out quickly, I have saved a zip file containing all the scripts and configuration files used in a file called tvrouter,zip which can be downloaded fromhttp://r.newman.ch/tvrouter.zip The best way to utilise this is get an Rpi setup and working (read stage 1 of the article to see how to do this if necessary) and then to download it to your home directory (assuming the Rpi is connected to the internet) using wget http://r.newman.ch/tvrouter.zip
then type unzip tvrouter.zip
cd tvrouter
ls to see the files
The file README.txt contains the instructions for how to quickly install them
cat README.txt

Image showing the TV picking up its DHCP supplied IP address