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!
Well, to be honest, I am very disappointed with it. I filled one balloon with hydrogen I obtained from reaction which occurred after mixing some sodium hydroxide dissolved in water with aluminium foil. Little displacement (about 5 grams) is probably caused by impure hydroxide which I used. At this moment buying that ingredient would be more problematic than buying whole bottle of helium so I decided to do it. While I’m waiting for the shipment I decided to do more tests, so tomorrow I’m going to use all supplies I’ve got to fill as many balloons as it will be possible. There is one more issue I need to consider. After buying these small balloons (30cm of width) I found on the Internet place where I can buy one that has 1 meter of diameter. I think of using two of them instead of plenty of these smaller.
Motion is probably best capturing software if you need to store and stream image from webcam connected to your Raspberry Pi. It don’t consume much ram and it is fully configurable. To install it on Raspbian simply run as root that command:
apt-get install motion
Ok, we’ve got it installed. Now it requires little configuration. Edit /etc/motion/motion.conf with your favourite text editor (I use nano). Everything there is clearly described so I’ll show here only the most important options and describe some of them.
Motion should automatically detect your video device, if you’ve got more than one connected to RPI change that value. To check all of them type:
These values are based on parameters of your webcam.
If you want to stream image slower than 2 fps put there value that in equal to number of seconds you want to wait between every capture.
That is useful only for those who want to keep not only images but also video. I turned it off on my device. To use it you’ll need to have ffmpeg installed.
Location where motion will store its files. I strongly recommend to change default setting because /tmp on Raspbian is mounted on smaller partition (about 60MB). /tmp is also automatically cleaned during every booting so if you can easily lost your photos.
Set it to off to be able to connect from another computer.
You can use that to manage motion from another computer without editing motion.conf.
Save file (if you’re using nano press ctrl + x). Now type in console:
After that you should be able to connect to it with your browser. Just type its address and port, for example:
Raspbian has SSH daemon installed by default. It can be used to work on our RPI when we have no possibility to use any kind of control device. It will be also very useful for my balloon project which is actually almost completed. I’ll show you everything in the next post. This one is actually about Linux basics so if you are user of this system, you’ll find probably nothing helpful here.
Let’s start from checking IP of your device. Assume that it is connected to our local network. There are two options of checking its address. You can find it in managing page of your router or whatever you use. You can also use very useful command:
It shows configuration of your network devices. As you see I am connected through wlan, so interface I’m mostly interested in is wlan0. It shows the local address in inet addr field.
Well. I’m already connected to my RPi from Windows 7. To do the same, download PuTTY there: http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html.
After doing that simply run program and you’ll see something like that:
Type RPi’s address in Host Name field and click Open.
Then you can login into you account. By default it’s:
On your first connection you’ll need to accept RSA key.
On Linux or OS X connecting by ssh is even simpler. You need only to type in console
In my case it would be:
Then you need to accept RSA key on first connection and give password on every.