]]> http://mutsuda.com/2013/05/12/raspberry-pi-for-secret-agents/feed/ 0 http://mutsuda.com/2013/04/07/partitura-polseres-vermelles-per-a-piano/?utm_source=rss&utm_medium=rss&utm_campaign=partitura-polseres-vermelles-per-a-piano http://mutsuda.com/2013/04/07/partitura-polseres-vermelles-per-a-piano/#comments Sat, 06 Apr 2013 23:21:45 +0000 Mutsuda http://mutsuda.com/?p=2430 Continue reading →]]> Polseres Vermelles (Pulseras Rojas, The Red Band Society) s’ha convertit en la sèrie del moment no només a Catalunya, també arreu del món. La banda sonora està composta en la major part per temes de grups catalans, però també hi ha algunes peces d’orquestra per Arnau Batallé. Per petició popular he fet la partitura d’una peça que en algunes ocasions sona amb piano sol, en d’altres acompanyat dels violins, però que per si sola ja té bastant de cos.

Descarrega la partitura de Polseres Vermelles (comenteu si us agrada )

The thing is you can’t control them, because you are not always there to check if they are playing or not, and they can lie you about how long they have been playing. In most cases they don’t even know the number.

Average Minecraft Player

Fortunately Minecraft provides a set of statistic data that can be really useful to get an idea of how addicted someone is to the game. One of the most interesting pieces of data is the Minutes Played statistic, which is the actual time that the player has been playing  (pause time or menu navigating time does not count). But this data is absolute, and will always show the total amount of minutes played, which can be really difficult to read or to compare to the day before’s data.

It would be really useful to have some sort of tracking device that could give us the total amount of minutes or hours played every day.

I came up with a really simple but effective solution, using python and crontab that helped me track my brother’s Minecraft playing behaviour.

Simple schema

Minecraft stores time data in ticks, every tick is equivalent to 0,052 seconds, so I’m going to talk about ticks rather than time. The architecture is pretty straightforward, the script will parse the latest ticks obtained in the last execution (step 1), and will compare it to the Minecraft statistics file to get the difference (step 2). If no one played, the difference should be 0 ticks, but if someone did, the difference will be positive. Once we get the value, we store it again in the log file (step 3).

import re
import os.path
import datetime
import os
import time


# Path to the minecraft statistics file
mine_path = "FULL_PATH_TO_/stats_user_unsent.dat"

# Path to the own log
log_path = "/Users/mutsuda/Code/log_stats.html"

# One Minecraft tick is equivalent to 0.052 seconds
eq = 0.052

# The regular expression that will match the gameplay Ticks
ticks_regex = re.compile('{"1100":.*}');

# Return the current number of ticks in a Minecraf stats file
def get_ticks(f):
	for line in f:
		time = ticks_regex.findall(line)
		if time:
			return time[0].split(':')[1].replace("}","")

# Gets the latest data from the log file
def get_latest_ticks(f):
	last = os.popen("tail -n 1 %s" % log_path).read()
	return last.split('|')[1]

# Operates the current ticks with the old ones
def get_result(aT,lT):
	delta_ticks = int(aT) - int(lT)
	delta_time = datetime.timedelta(seconds=delta_ticks*eq)
	return ("[" + str(datetime.datetime.now())+ "]" +  
		"|" + str(aT)+ "|" + str(delta_time))

# Writes the resulting line back to the log file
def write_result(f,result):
	f.write(result+"\n")

def main():
	latest_ticks = 0

	# Read latest ticks
	if os.path.exists(log_path):

		# If the file already exists, we obtain the latest ticks
		latest_ticks = get_latest_ticks(open(log_path,'r'))
	
	# We get the ticks we have now in the minecraft stats file
	actual_ticks = get_ticks(open(mine_path, 'r'))

	# We obtain the line we the delta in ticks and time
	result = get_result(actual_ticks,latest_ticks);

	# We now write the result into our statistics file
	write_result(open(log_path,"a"),result)


if __name__ == "__main__":
    main()

Finally, what we want to do is to automatically run the script once a day, so we just have to configure crontab to do it for us.

We can easily edit crontab with the “crontab -e” command. We will add the line:

0 1 * * * python /PATH_TO_YOUR_SCRIPT/mine_time.py

This will set crontab to run your script every one in the morning.

As you can see it’s pretty simple to set up. In this case the script is supposed to read a local file, but you could easily use scp to do all this tracking remotely, for example in a hidden raspberry pi (why the hell would you like to hide it? well it’s just cooler). The script is just ment to check one user, but if you have more than one son you might want to replicate the code for each son, or rewrite it in to make it more generic.

The result:

So on April 2nd he played 6 hours and 44 minutes, and he said he thought he had been playing for 1 hour and 20 minutes!

#LOL

La cançó és una obra de Jake Shimabukuro, un músic Hawaià i virtuós de l’ukelele de qui em vaig comprar un llibre de partitures recentment. El meu objectiu final és poder-la tocar tal i com la va concebre, per a 3 ukeleles, però em queda un llarg camí a recórrer abans no hi arribi!

Fins la propera!

]]> http://mutsuda.com/2013/03/31/pianoforte-2010-jake-shimabukuro/feed/ 0 http://mutsuda.com/2013/01/16/minecraft-server-recipies/?utm_source=rss&utm_medium=rss&utm_campaign=minecraft-server-recipies http://mutsuda.com/2013/01/16/minecraft-server-recipies/#comments Wed, 16 Jan 2013 20:41:51 +0000 Mutsuda http://mutsuda.com/?p=2321 Continue reading →]]> These are some pieces of code I use to make my life easier when managing the Minecraft server I run.

The first of them is updating the server, because as everyone knows, every now and then the server needs to be updated in order to accept players with updated versions of their clients.

wget -O $HOME/server/minecraft_server.jar https://s3.amazonaws.com/MinecraftDownload/launcher/minecraft_server.jar

This line simply downloads the file from the Minecraft webpage server to the directory I have mine, overwriting it.

My server is open to almost everyone, and sometimes there is people that destroy things I build, maybe even without willing. For that purpose I have a mini script I run every now and then (although it could be added to a cron job for it to be executed periodically) that simply backups the current world status to a backup directory I called “world_backups”.

World backup mini script:

!/bin/sh
d=$(date +%Y%m%d%H%M%S)
mkdir $HOME/sever/world_backups/"world_at_"$d
cp -r $HOME/server/world/* $HOME/server/world_backups/"world_at_"$d
echo "Done!"

It uses the current date as an ID to differentiate one world from the other. It might take a while, but once it’s done, you will get prompted.

And finally one of the most useful scripts, the one that starts the server. It checks if it is already running, and if it is not, it starts it using the “screen” command.

Server start mini script:

#!/bin/sh
running=$(netstat -tulnap | grep 25565)
if [ -z "$running" ]
then
 echo "Minecraft server not running, starting it..."
 cd $HOME/server
 screen java -Xmx512M -Xincgc -jar minecraft_server.jar
 fi
else
 echo "Minecraft server already running!"
 screen -x
fi

I use the “screen” command because the server does not have a display so I access it through an SSH console. You don’t want your server to shut down whenever you close your connection to the server… If the server is already running, the command “screen -x” is executed so you get access to the Minecraft console again.

And this is everything for now!

Setting up a Linux Minecraft server for anyone to play in it is not difficult, but involves 3 steps.

1. Make your network reachable from anywhere
2. Make your router point your server machine
3. Install the Minecraft server

Make your network reachable from anywhere at anytime

In order to make you network reachable from anywhere you will either need to have a static IP address, or to use a service like no-ip to create an alias for your public IP that keeps updating it whenever it changes.

Go to this URL in your browser to discover your own public IP address:

http://www.whatismyip.com/

If you are lucky enough to have a static IP address, your are done with step 1. Let’s assume that you DON’T have a static IP address, as most of you won’t.

Go to no-ip and register as a new user choosing your domain name of choice.

The next step is downloading the DNS update client, which will keep your public IP up to date. Here is a detailed explanation (and video) on how to do it in Ubuntu Linux.

Congratulations! Now your network is accessible from everywhere at:

whatyouchose.no-ip.org

Make your router point your server machine

Once you’ve set up the address that will be able to access your router from the outside, you will have to change your router configuration in order to point it to the machine that is running the Minecraft server.

Enter your router configuration by going to this address in your browser:

http://192.168.1.1

You will likely be asked for a user and password. If nobody changed it, it could be something like “admin” “admin” or “admin” “1234″. Keep trying, ask someone who knows, or check the bottom of your router, because it might be written there.

Once you are inside, you have to search for the “Port Forwarding” menu. It’s sometimes under “Application and Gaming” but it’s slightly different in every router, so you might want to check for further instructions here.

Once you find that menu, add a line to make the router point your server whenever it gets a request from a Minecraft client. Minecraft server runs by default in the port 25565.

In my case, the server’s IP is 192.168.1.41 but you might want to check yours by running the following command in your server’s terminal:

ifconfig

You will find your server’s IP address in the output

eth1 Link encap:Ethernet HWaddr 00:c0:26:a0:53:bd
 inet addr:192.168.1.41 Bcast:192.168.1.255 Mask:255.255.255.0
 inet6 addr: fe80::2c0:26ff:fea0:53bd/64 Scope:Link
 UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
 RX packets:10297691 errors:0 dropped:0 overruns:0 frame:0
 TX packets:5870460 errors:0 dropped:0 overruns:0 carrier:0
 collisions:0 txqueuelen:1000
 RX bytes:1029027266 (1.0 GB) TX bytes:2505625407 (2.5 GB)
 Interrupt:22 Base address:0xdd00

Install the Minecraft Server

As I said before, installing the server is the easiest part. You may want to create a directory named “Minecraft” where we will put the server.

cd $HOME
mkdir Minecraft

Then, you want to download the server to that directory.

wget -O $HOME/Minecraft/minecraft_server.jar https://s3.amazonaws.com/MinecraftDownload/launcher/minecraft_server.jar

And finally you will want to run it!

cd $HOME/Minecraft
java -Xmx512M -Xincgc -jar minecraft_server.jar

This will generate all the files a server needs to start, and will enable other users to join it as you might be used to.

Happy crafting! ^^

In this case, I’ll explain how to convert your Raspberry Pi into an audio streaming device, or audio spying device, however suits best to you. Use it under your own responsibility.

Plugging the microphone and loading the module

The Raspberry Pi has an audio output jack, but unfortunately there is no input port. We will then need a USB microphone. If you have one, keep reading, if not, go buy one (or plug a webcam with microphone).

Once the microphone is plugged in, you might have to load the audio module by typing the following command if it isn’t.

sudo modprobe snd_bcm2835

Recording and playing a test file

Now we can try to record some audio into a file by running:

arecord -D plughw:1,0 test.wav

Just press CTRL+C once you think you’ve got enough recording. Now let’s play it to see if it works! But first, plug your earphones to the audio output of your Raspberry Pi!

aplay test.wav

Did you hear anything? Great! Your Raspberry is ready to “rock”ord some audio!

If you want to record louder or adjust some parameter, you can use the alsamixer tool to play with the input/output levels of your microphone.

alsamixer

Once you have set your settings, remember to store your changes:

sudo alsactl store

Streaming the audio to another PC

What we want to do next, is to give the Pi the capability to send this audio through the network, maybe to a server we have somewhere. In order to tho that, we will pipe the audio from the microphone into an ssh communication to the destination computer. As simple as:

arecord -D plughw:1,0 -f dat | ssh -C user@remoteip aplay -f dat

Now you have everything set! Switch on your speakers in the destination PC, and hear what the Raspberry Pi is spying from hundreds of miles!

In this (two overlapped and faded) pictures you can see my Raspberry Pi set under a bed, using a Wifi dongle, set to work as a baby-cry transmitter.

This might be useful in some situations ^^

See you!

There are countless projects counting on the power, price and size of the Raspberry Pi, but I wanted to implement an easy one just to see what kind of things could be done.

My goal was to set the Raspberry Pi with a Logitech Quickcam Express camera plugged in, to upload a picture to my Dropbox folder, whenever anyone in the world visited a website hosted in the same Raspberry Pi.

Yes, I know, it’s useless, but let me enjoy, ok?

You’ll just need your Raspberry Pi, a computer with Dropbox where you can SSH, and a webcam. In the explanation of this process I’ll assume that you have the latest Raspbian “Wheezy” installed. If not, download it and install it from here.

1. Getting a picture from the camera

In my case I’m using a Logitech Quickcam Express (yes, a Dinacam) and it just worked without having to install anything. Just connect your webcam and check if /dev/video0 appears. If it does, open a terminal in your Raspberry Pi (or SSH to it) and type:

fswebcam -r 356x292 -d /dev/video0 test.jpg

This should output something like :

--- Opening /dev/video0...
Trying source module v4l2...
/dev/video0 opened.
No input was specified, using the first.
--- Capturing frame...
Captured frame in 0.00 seconds.
--- Processing captured image...
Writing JPEG image to 'test.jpg'.

Now you took your first picture!

2. Sending the picture to a remote machine with Dropbox installed

Ok, one of our goals is to get the pictures to Dropbox somehow. Unfortunately, installing Dropbox in your Pi is not an option. What we can do is to send those pictures to a computer in the network that has Dropbox installed. I’ll asssume 192.168.1.5 is the IP address of that computer and that it has SSH and SCP. Try this command:

scp test.jpg username@192.168.1.5:Dropbox/your_folder

It will ask your password and then it will put the image right where you need it. But we need to automate this process so we have to avoid having to enter the password. Next step!

3. Adding the Raspberry Pi to the SSH authorized_keys in the remote machine

We don’t want the remote machine to ask for the password each time we want to send a file. We then need to generate a key in the Pi and add it to the remote machine’s authorized keys. Running the following command in your Pi will generate the keys:

ssh-keygen -t rsa

The following step is to copy the public key to the remote machine :

 scp .ssh/id_rsa.pub user@192.168.1.5:

Then SSH into the remote machine and add the recently generated key into the authorized_keys file (last time your password will  be asked!).

cat id_rsa.pub >> .ssh/authorized_keys

4. Automating the process of taking a picture and sending it to the remote machine

Ok, now we know how to take a picture, and we know how to move it to a remote machine for Dropbox to automatically upload it to its servers, but wouldn’t it be nice to wrap everything in a single script? Let’s do it.

#!/bin/sh
filename=$(date +"%m-%d-%y|||%H%M%S")
fswebcam -r 356x292 -d /dev/video0 $filename.jpg
scp $filename.jpg user@192.168.1.5:Dropbox/yourfolder

Create a file called “smile.sh” and put those lines inside. It generates the filename using the current date in order to avoid collisions. Give the script permissions to run.

chmod +x smile.sh

Try running ./smile.sh and see what happens. No surprises, it takes a picture, names it with the current date and sends it to a remote computer that finally uploads it to Dropbox.

5. Activate the script via web!

Wow, this is the last step! Wouldn’t it be great to be able to take the picture by just visiting a URL?

For that to happen we need the Raspberry to be a server, and we also need to code one little CGI. Create a directory wherever you will run your server in.

mkdir cgi-bin

And put a file called photo_cgi.py inside

#!/usr/bin/env python
import subprocess
print "Content-type: text/html"
print "<title>Picture taking CGI</title>"
print "<p>I'm going to upload the picture!</p>"
subprocess.call(['/path/to/your/smile.sh'])

Finally, start your server by running:

python -m CGIHTTPServer

Now, assuming your Pi IP is 192.168.1.6, open a browser anywhere in your network and type:

http://192.168.1.6:8000/cgi-bin/photo_cgi.py

Open your Dropbox folder and voilà!

Of course now you can change your router’s configuration to redirect all 8000 petitions to your Raspberry Pi, allowing everyone in the world to upload pictures of YOU to YOUR Dropbox!

Useful right?

Wait until you see my next project!

See you!

Download “The Dark Knight Rises – Mind if I cut in” piano score

La peça es diu “Mind if I cut in”

Fins aviat!

D’aquí la podeu descarregar.

]]> http://mutsuda.com/2012/07/01/bach-sonata-in-g-minor-bwv1020/feed/ 2