Sometimes we want to use internet browser on Raspberry Pi, there are many that we can install and run, but most of them will be unusable due to theirs relatively high requirements. There are some nice alternatives to popular browser though. I consider browser such as Firefox, Chromium and Opera totally unusable on Raspberry Pi (even though you can run them). There is a second category of browsers, they are written usually especially for Linux, for example: Epiphany, Iceweasel, Icecat, Konqueror, Dillo. From these the last one seemed fastest for me. There is also option to use browser from third category: text browsers. Most popular are Lynx and Links. Lynx is great when you don’t care about graphics but sometimes we just need to see some images. There is nice solution for that. We can use Links in graphic mode.
Typing pacman -S links in console won’t help us, it won’t run in graphic mode because it wasn’t configured to do that at the time of compilation. We need to compile it on our own. Go there http://links.twibright.com/download.php and download package. When you’re ready unpack it with (I’m not sure if Arch has tar by default, if now: pacman -S tar):
tar -zxvf links-2.7.tar.gz
Before we start we need to resolve dependencies and other necessary things. Let’s begin with compilator and make program, then libraries:
pacman -Syu gcc make
pacman -S libjpeg libtiff zlib gzip
Now go to directory where you unpacked links. Type:
sudo make install
Now start browser with:
links -g http://www.google.com
Conclusion: for me Epiphany is slower than Dillo which has equal speed to Links which I found more convenient. I also seems to me that Links is more responsive even though Dillo takes less ram when not in use.
Links in graphic mode:
There is how it looks in ps -aux:
solusip+ 331 3.1 13.2 38940 24808 pts/1 S+ 07:57 0:11 dillo solusip+ 220 0.7 13.3 36092 25044 ? Ss 07:50 0:06 links solusip+ 240 9.5 28.2 298048 53008 ? Ssl 07:56 0:41 epiphany
There are couple thing you can do with your Arch to make it more adjusted to your preferences. This time I’ll show you how to configure sudo and install most popular window managers. Remember that you can get such configuration on every computer, not only on RPi.
Let’s start with sudo. Login as root and type
pacman -Syu sudo
After installing package type visudo. There will be ran vim version made especially for editing sudoers file. Right after first page you’ll find such line:
root ALL=(ALL) ALL
Go to line under it and press ‘i’ key on your keyboard to switch to insert mode. Then type:
your_user_name ALL=(ALL) ALL
Then press Escape, and type:
Press enter. That’s all. Relog to your account and check if sudo is working.
Now we’re ready to install a window manager. There is difference between it and desktop environment. I wanted to work with it on Raspberry Pi mainly because of its speed. Any WM is many times faster that any desktop environment. I never used them before and now I decided to start with FluxBox. So let’s install it. Log to user account and type:
sudo pacman -S fluxbox
After fluxbox is installed edit .xinitrc file in your home folder.
Save file and type startx.
You should see default fluxbox’s screen. Now it’s time to configure it. Let’s begin from installing program called feh. It’s responsible for handling images. Right click on your desktop and select xterm. Then type:
sudo pacman -S feh
I guess that we need a file manager. There are many options, I’ve chosen pcmanfm:
sudo pacman -S pcmanfm
Now let’s deal with fluxbox’s menu. I used program called menumaker to generate menu containing all installed applications.
sudo pacman -S menumaker
mmaker -f FluxBox
Now you’ve got all applications in menu. You can still edit entries order. To do that edit with your favourite edit that file: ~/.fluxbox/menu. For example:
We’ve got most basic programs now. Let’s make FluxBox prettier. There is nice website you can get fluxbox’s themes: http://customize.org/fluxbox. It would be great to do everything on Raspberry Pi. Install web browser and go that site (I installed Epiphany).
When you’ll download a style unpack it to ~/.fluxbox/styles and then choose it from menu. Now it looks really better. But we still have no icons in files manager. We can install for example these:
pacman -S tangerine-icon-theme
sudo echo “gtk-icon-theme-name = “Tangerine” >> /etc/gtk-2.0/gtkrc
Well it’s time to add a wallpaper. First get any. Then exit FluxBox. We need to edit .xinitrc again.
Put before exec startfluxbox that:
This is how my FluxBox looks after all these operations.
After 3 months of using Raspberry Pi my SD Card has broken. I bought new one and decided to install Arch this time. There is disc image with preconfigured system: http://www.raspberrypi.org/downloads. We could of course install it on our own, but I have no special needs, so this package is ideal for me. Let’s download it and write it on SD Card. To do that we need to determine localization of new card. You can use ls /dev/sd* and check what’s new or simply use GParted. In my case it’s /dev/sdb. To write img to disc use program called dd. I did it in that way:
sudo dd if=~/archlinux-hf-2012-09-18.img of=/dev/sdb
If your card is bigger that 2GB you should also resize / partition. You can do it easily with GParted. Just resize it to disk limit. Now we are ready to boot our RPi. Plug the ethernet cable and boot device. I’m doing everything, till the moment of xorg installation, via SSH, without using its video ports. Check device’s IP and connect. It my case it was email@example.com (simply type ssh firstname.lastname@example.org – you need to have openssh installed). First part of that address is the account we want to connect with. That is actually the only account in that system now. Its password is root, so right after connecting, type passwd and type doubly the new one.
After doing that we’ll need to update our system. To do that type:
Now we are ready to install xorg. Type
pacman -S xorg
When it’ll ask about selection, don’t give anything on input, just press enter. After installing xorg, install 3 things more: xorg-xinit (to be able to use startx), xorg-twm and xterm (to test if xorg is running properly). Do it with:
pacman -S xorg-xinit xorg-twm xterm
Now you should connect your Raspberry Pi to an video output. When you’ll be ready use that command (not with ssh anymore):
You should see something like this:
To close it, type exit on left terminal or, in case you don’t have your mouse connected, type pkill x on this active by default.
Now it’s time to create a new user. It’s wise not to use root account when using x. To do that use that command (XYZ will be the name of your user):
useradd -m -g users -G wheel,storage,power -s /bin/bash XYZ
Now set password for new user:
No it’s time to install lxde. It’s probably the lightest environment. You can choose alternatively xfce (which I prefer) but it’ll work a bit slower. If you decided to use lxde, type:
pacman -S lxde
When installation is completed, log out (by typing logout) and log on your newly created user.
ls -la | grep .xinitrc
If there’s such file, you need to remove it by typing:
Now we’re going to create a new one. Type:
cat >> .xinitrc
When you’re done, press Ctrl + D. Make sure that your file contains only that line. Now it’s a big moment. Type
and wait for LXDE to start.
That is the most basic way of doing it. Your LXDE screen should look like this right after installation:
Sometimes we need to show somebody output of our linux terminal. Rewriting it isn’t really best idea. We could for example use cat to stream output into file and then upload it on ftp server but that’s not the fastest way. There is great website which is a helping hand in such situation – Sprunge.us. We can forward our stream using curl to service that is running there. For example we want show someone all groups that contains root account. To achieve that in output we would normally type:
cat /etc/group | grep root
But we want to stream it out to sprunge. There is nothing easier. On the end of the line we need to type (after |):
curl -F sprunge=@- sprunge.us
So the whole line will look like this:
cat /etc/group | grep root | curl -F sprunge=@- sprunge.us
Two seconds after typing that you’ll get an url address in such format: http://sprunge.us/XXXX
After almost four moths I’m back. I still haven’t sent my ballon even though I had everything to do that. Now I need to wait for spring and its better weather. Some time ago I decided to learn how to use Django and write small blog app to host on it my blog. Unfortunately I discouraged right after starting work. Today I returned to this idea and started working again. Soon I’ll probably move that blog to my own server.
I decided to rebuild PiPong a bit and after doing that I noticed that now it works really slow on Raspberry Pi. I thought that translating python to c++ and compiling it then would be a solution. Unfortunately I still can’t to that due to Shedskin limitations – I’ll work on that. There is a problem with compiling Pygame.
During my research I found another useful program for developers who want to easily share their programs with Windows users (but not useful for increasing performance so not useful for PiPong).
If you are curious how does it works you can compile my PiPong from code that is available on Sourceforge. Just remember to put to includes pygame files from Python/include.
Before yesterday I’ve never used Python. I was actually forced to do it because of the fact that it is now official language of Raspberry Pi. After spending one day with it I have to say that it’s amazing and I would recommend it for anyone who want to start programming (not advanced programmer here actually). Yesterday I modified already written Pong clone to use GPIO interface and move paddle when I push a button. Then I thought that it is rather senseless because keyboard can do it better. And then I come up with an idea that it would have sense if there were two players using custom controllers. I decided to write my own Pong clone which I called PiPong! At the end of that post you’ll find a source code. To run it you’ll need to images – for paddle and for ball. You can download package there: http://sourceforge.net/projects/pipong/files/. You can test it also on your computer. To do that, run keypong.py instead of pipong.py, which is made for Raspberry Pi. You’ll need also Pygame which can be downloaded there: http://www.pygame.org/download.shtml If you’re using a 64-bit version of Windows with Python 2.7 or 3.x, there is a binary for you: http://www.lfd.uci.edu/~gohlke/pythonlibs/#pygame
This is how it looks:
# www.sudoxanthippe.wordpress.com # PiPong! import pygame, random from pygame.locals import * import RPi.GPIO as GPIO pygame.init() def menu(): pygame.init() display = True # Setting resolution screen = pygame.display.set_mode((800,600), 0, 24) # Hiding mouse pygame.mouse.set_visible(False) # Setting window's caption pygame.display.set_caption("PiPong!") # Displaying starting label label = pygame.font.SysFont("Tahoma", 25).render("Press ENTER to start!", 1, (185,0,0)) # Checking size of the Surface background = pygame.Surface(screen.get_size()) # Returning converted size background = background.convert() # Filling background with colour background.fill((45,45,45)) while display: for event in pygame.event.get(): # Checking if RETURN key was pressed if pygame.key.get_pressed()[pygame.locals.K_RETURN]: # Go further display = False # Dealing with the colours of the menu color = (200, 200, 200) rectangle = pygame.Surface((265, 50)) rectangle = rectangle.convert() rectangle.fill(color) # Refreshing menu elements screen.blit(background, (0,0)) screen.blit(rectangle, (264, 280)) screen.blit(label, (280, 290)) # Update the full display Surface to the screen pygame.display.flip() def game(): pygame.init() display = True # Setting resolution screen = pygame.display.set_mode((800,600)) # Hiding mouse pygame.mouse.set_visible(False) # Setting window's caption pygame.display.set_caption("PiPong!") # Checking size of the Surface background = pygame.Surface(screen.get_size()) # Returning converted size background = background.convert() # Filling background with colour background.fill((45,45,45)) # Loading images sprite_pad = pygame.image.load("pad.png") sprite_pad_mirror = pygame.transform.flip(sprite_pad, True, False) sprite_ball = pygame.image.load("ball.png") # Converting images to sprites rect_pad1 = sprite_pad.get_rect() rect_pad2 = sprite_pad_mirror.get_rect() rect_ball = sprite_ball.get_rect() # Ball movement speed hspeed = 0 vspeed = 0 while hspeed == 0: hspeed = random.choice([-4, 4]) while vspeed == 0: vspeed = random.choice([-4, 4]) slower = 1 score1 = 0 score2 = 0 pad_y = 300 pad_y_2 = 300 while display: # Ball movement slower -= 1 if slower == 0: slower = 5 # Pads movement for keyboard if pygame.key.get_pressed()[pygame.locals.K_s]: if (pad_y <= 500): pad_y = pad_y + 4 if pygame.key.get_pressed()[pygame.locals.K_w]: if (pad_y >= 10): pad_y = pad_y - 4 if pygame.key.get_pressed()[pygame.locals.K_DOWN]: if (pad_y_2 <= 500): pad_y_2 = pad_y_2 + 4 if pygame.key.get_pressed()[pygame.locals.K_UP]: if (pad_y_2 >= 10): pad_y_2 = pad_y_2 - 4 # Pads movement for GPIO if GPIO.input(22): if (pad_y <= 500): pad_y = pad_y + 4 if GPIO.input(24): if (pad_y >= 10): pad_y = pad_y - 4 if GPIO.input(21): if (pad_y_2 <= 500): pad_y_2 = pad_y_2 + 4 if GPIO.input(19): if (pad_y_2 >= 10): pad_y_2 = pad_y_2 - 4 # Setting sprites position rect_pad1.left = 25 rect_pad1.top = pad_y rect_pad2.left = 750 rect_pad2.top = pad_y_2 # Score refreshment score1_str = str(score1) score2_str = str(score2) score = pygame.font.SysFont("Tahoma", 18).render(score1_str + ":" + score2_str, 1, (155,122,222)) # Ball movement if hspeed < 0: if (rect_ball.left + hspeed > 5): rect_ball.left += hspeed GPIO.output(23, False) else: rect_ball.left = 400 rect_ball.top = 300 score1 = score1 + 1 GPIO.output(23, True) else: if (rect_ball.left + hspeed < 750): rect_ball.left += hspeed GPIO.output(23, False) else: rect_ball.left = 400 rect_ball.top = 300 score2 = score2 + 1 GPIO.output(23, True) if vspeed < 0: if (rect_ball.top + vspeed > 5): rect_ball.top += vspeed else: vspeed = -vspeed else: if (rect_ball.top + vspeed < 550): rect_ball.top += vspeed else: vspeed = -vspeed # Collision detection hit = False # Pad1 if ((rect_ball.left >= rect_pad1.left) and \ (rect_ball.left <= rect_pad1.left + rect_pad1.width) and \ (rect_ball.top >= rect_pad1.top) and \ (rect_ball.top <= rect_pad1.top + rect_pad1.height)): hit = True # Pad2 if (rect_ball.left >= rect_pad2.left-27) and \ (rect_ball.top >= rect_pad2.top) and \ (rect_ball.top <= rect_pad2.top + rect_pad2.height): hit = True # When collision is detected if (hit == True): if (rect_ball.left > 400): rect_ball.left = rect_ball.left - 5 else: rect_ball.left = rect_ball.left + 5 hspeed = -hspeed if pygame.key.get_pressed()[pygame.locals.K_ESCAPE]: display = False # Killing process for event in pygame.event.get(): if event.type == pygame.QUIT: display = False if pygame.key.get_pressed()[pygame.locals.K_RETURN]: # Go further menu() # Dealing with the colours screen.blit(background, (0,0)) screen.blit(sprite_pad, rect_pad1) screen.blit(sprite_ball, rect_ball) screen.blit(sprite_pad_mirror, rect_pad2) screen.blit(score, (375, 555)) # Update the full display Surface to the screen pygame.display.flip() def main(): #GPIO initialize GPIO.setmode(GPIO.BOARD) GPIO.setup(22, GPIO.IN) GPIO.setup(24, GPIO.IN) GPIO.setup(21, GPIO.IN) GPIO.setup(19, GPIO.IN) GPIO.setup(23, GPIO.OUT) menu() game() main()
GPIO is very cool feature. When I managed to light a diode using it, I decided to check how input works. I made such configuration with switch, diode and resistors:
We’ve got now four wires connected to our RPi – one is ground (GND), one is power (VCC 3.3V), one is output (PIN23) and one is input(PIN24). The only new thing, when we compare this to configuration from last post, is that now we have a switch connected to the input. Don’t forget to connect it from PIN24 side to GND with 10k resistor. This is how you should connect it to RPi:
Now it’s time to write a python program that will handle it.
Type in console:
cat > button.py
You will create a new file and start to edit its contents so type then:
import RPi.GPIO as GPIO GPIO.setmode(GPIO.BOARD) GPIO.setup(23, GPIO.OUT) GPIO.setup(24, GPIO.IN) test = 0 while True: if GPIO.input(24): GPIO.output(23, True) if test == 0: print 'You pushed the button!' test = 1 else: GPIO.output(23, False) test = 0
Then press ctrl + d. You can do that of course with any text editor you want (nano for example). Just make sure that file have such content.
Try to run it:
Now if you press the button the led diode should light up and you should see on your screen a message.
While I’m waiting for the very last parts for my balloon project I decided to test GPIO interface on RPi. My objective was to light LED diode from a python console. I’ll show you how to that step by step.
There is webpage which really helped me, you can find schematics of GPIO pins there: LINK. There is my RPi with one of these schematics:
Carefully connect one wire to 3v3 output and one to GND. There is simple schematic for that:
Then you need to connect it to LED diode and 100Ω resistor if you are using red diode. Remember that longer leg is cathode (+) and shorter is anode (-). It should light up.
If you are using other type of LED diode you need to check it’s voltage and then do some calculations to select suitable resistor for your configuration. You can use special calculator to do that or count that in old-fashioned way by using that formula:
R = (Vs – Vl) / I
r – resistance that you need
Vs – supply voltage (3.3V for us)
Vl – diode voltage (about 2V)
I – LED current (0.02A)
So let’s calculate this:
R = (3.3V – 2V) / 0.02A = 65 Ω
I used 100Ω for that so my diode is a bit subdued. It’s OK to use value that is higher than outcome of calculations.
If everything is working as described you can move to the next step.
Now we’re going to move one of the wires (this that is providing power do not move the grounding one) to pin 23 (GPIO11), there is schematic for that:
After you do that, your diode shouldn’t be lighting any more. Now we need to prepare Python.
At first we need to install python-dev package so type as root:
apt-get install python2.7-dev
Then download class which is able to control RPi’s GPIO. You can find it there: http://pypi.python.org/pypi/RPi.GPIO/0.3.1a#downloads. Unzip package:
tar – xvf FPi.GPIO-0.3.1.tar
Then get into new catalogue:
and type as root:
python setup.py install
GPIO class will be installed and you will be able to use it inside Python Shell. Let’s test if it is working!
Run Python 2 shell by simply typing:
Be sure that you are using Python 2 not 3! It should be set do P2 on default. You can use for that also dedicated program when x server is started (you’ll find it under Programming section in LXDE menu).
After starting Python Shell your command prompt will change to:
Type there following commands:
import RPi.GPIO as GPIO
Now observe your carefully diode and hold back the excitement! Type that command to light it up:
GPIO.output (23, True)
Congratulations! You just used your RPi to manage a low level peripheral! You are only one step from building a really advanced devices!