Szkoda czasu

How to secure your webpage with lighttpd mod_auth

2011-09-18T21:10:00.001+02:00

Here's the setup:
There's a web page served by lighttpd by my OpenWRT router. Unfortunately the content shouldn't be available for everyone. Here's the solution:

Install mod_auth
You can do it with:
```
opkg install lighttpd-mod-auth
```
Create password file
I first used plain authentication just to see if it's that easy as it's written in documentation. It turned out it is! Better solution is to use htdigest. You just need to create a file that looks like this:
```
user1:realm:passwordhash
user2:realm:passwordhash
user3:another realm:passwordhash
```
Realm is a name of a section of your website that you declare in configuration file. I just use one realm called "download", because I don't need anything more at the moment.
Password hash is md5 sum calculated from a following string:
```
username:realm:password
```
e. g. john:website:qwerty would result in hash: 329516de44fe7cf1216194bb02348284.
Entry in the password file would look like this:
```
john:website:329516de44fe7cf1216194bb02348284
```
Put your file somewhere where it's not accessible from outside of your server. You don't want anyone to be able to download this file and get to know all users' passwords.

Update configuration
Uncomment mod_auth in server.modules, for example:

server.modules = (
#       "mod_rewrite",
        "mod_redirect",
        "mod_alias",
        "mod_auth",
#       "mod_status",
#       "mod_setenv",
#       "mod_fastcgi",
#       "mod_proxy",
#       "mod_simple_vhost",
#       "mod_cgi",
#       "mod_ssi",
#       "mod_usertrack",
#       "mod_expire",
#       "mod_webdav"
)

Then add this somewhere down the line:

## AUTH
auth.debug = 0
auth.backend = "htdigest"
auth.backend.htdigest.userfile = "/path/to/your/file/called/for/example/htdigest.user"

When you want to secure access to your website with a password add:

auth.require = ( "" =>
                        (
                                "method" => "digest",
                                "realm" => "website",
                                "require" => "valid-user"
                        )
                       )

Restart lighttpd
You can do it with:
```
/etc/init.d/lighttpd restart
```

Now try to access your webpage. You should be greeted with a dialogbox asking for user name and password. In case it's not working increase debug level to 1 or 2 and check out /var/log/lighttpd/error.log to find out what's wrong. Maybe wrong file name, file permissions or password hash? Good luck.

Automatyczne pobieranie na napisów na OpenWRT

2011-04-06T21:51:00.002+02:00

Opis

Poniższa instrukcja opisuje w jaki sposób zaplanować automatyczne poszukiwanie napisów dla filmów i odcinków seriali na routerze z systemem OpenWRT w wersji Backfire 10.03.

Instalacja

Potrzebny będzie pakiet napiprojekt, który znajduje się tutaj: napiprojekt. Instalacja następuje za pomocą:

opkg install http://eko.one.pl/openwrt/backfire/10.03/napiprojekt_6_ar71xx.ipk

Opkg zainstaluje potrzebne zależności z wyjątkiem p7zip, który można dostać stąd: p7zip. Instalujemy go podobnie:

opkg install http://ecco.selfip.net/backfire/packages/p7zip_9.13-3_ar71xx.ipk

Skrypt

Tworzymy nowy skrypt wydając polecenie:

nano /usr/bin/napisy.sh

Dzięki umieszczeniu w katalogu /usr/bin, który znajduje się w zmiennej środowiskowej $PATH, plik będzie można uruchomić z dowolnego miejsca w systemie.Następnie w treści pliku powinno znaleźć się:

#!/bin/sh
# Przejrzyj po kolei wymienione katalogi
for katalog in /srv/filmy /srv/seriale
do
 # Znajdz wszystkie pliki avi, wypisz pelna sciezke: "1 linia = 1 plik", wczytuj po jednej linii do zmiennej
 # Uzycie read zabezpiecza przed sytuacją w której w nazwie pliku występują spacje
 find $katalog -name "*.avi" | while read plik_z_filmem
 do
  # Zamien rozszerzenie avi na txt, zeby utworzyc nazwe pliku z napisami do danego filmu
  # Otaczamy nazwe zmiennej cudzyslowem na wypadek gdyby nazwa pliku zawierala spacje
  plik_z_napisami=$(dirname "$plik_z_filmem")/$(basename "$plik_z_filmem" .avi).txt
  # Jesli nie istnieje plik z napisami
  if [ ! -e "$plik_z_napisami" ]
  then
   # Szukaj napisow dla danego pliku
   napiprojekt "$plik_z_filmem"
  fi
 done
done

Plikowi należy nadać pozwolenie na wykonywanie:

chmod +x /usr/bin/napisy.sh

Cron

Dzięki temu, że skrypt pomija filmy i odcinki dla których już ściągnął napisy, można spokojnie zaplanować jego cogodzinne wykonywanie. W tym celu należy dodać następującą linijkę do pliku /etc/crontabs/root:

* */1 * * * napisy.sh

Przystępne wyjaśnienie i wygodny "kalkulator" dla crona można znaleźć na http://eko.one.pl/?p=openwrt-cron

Kalendarz Pyrkon 2011

2011-03-21T20:55:00.025+01:00

Calendar

Code

This code helped me to automate most of the work. Last year I used gdata directly, but this year I got so frustrated that I decided I need something simpler. The tradeoff is that the events are not described in details as they used to be. This year I'm not making a mistake of not keeping the code, so here it is.There are basically three steps:

Scrape the website to gather information
Build a shell command to call googlecl - google command line interface that provides some ability to use Google services from command line.
Run the command in the terminal. Keep retrying if it failed for any reason.

There were some issues:

Doubled entries that migrated from calendar "Naukowa 2" to "Naukowa", but showed up in their proper place too.
Sometimes starting times where off by an hour or two. For example by 1 hour on Friday, 1 hour on Saturday, 2 hours on Sunday. WTF? I noticed it happened on calendars that have numbers in their names, but most of them do, so I might be just imagining it.
Some problems with encoding. I could never understand when I need to decode/encode a string.

#!/usr/bin/python
# -*- coding:utf8 -*-

from BeautifulSoup import BeautifulSoup
import urllib2
import re
import subprocess

# Download the page
# You may want to save the page in the browser and use a local copy
# for example: 'file:///home/daniel/Pobrane/pyrkon.html'
page = urllib2.urlopen('http://www.pyrkon.pl/2011/index.php?go2=program')
soup = BeautifulSoup(page)

# Find div with the content
content = soup.find('div', id='content')
# Get all his children which are divs too
divs = content.findAll('div')

# Set starting index in case you wanted to start in the middle after some interruption
start_from = 0
i = 0
l = len(divs) - start_from

for div in divs[start_from:]:
 # Name and lecturer are easy
 tytul = div.contents[1].b.string
 prowadzacy = div.contents[1].i.string
 # I can never understand when I need to decode/encode from/to utf-8.
 # This was done by trial and error.
 
 # Madafaking new lines are contents too, so
 #  div.contents[2] == u'\n'
 
 # Place
 miejsce = re.search('^<b>miejsce: </b>(?P<miejsce>.+?)<br />', div.contents[3].renderContents(), re.M).group('miejsce')
 miejsce = miejsce.decode('utf-8')

 # Show some progress information
 i += 1
 print '[%d/%d] %s: %s' % (i, l, miejsce, tytul)

 # Event start time
 czas = re.search('^<b>termin: </b> (?P<dzien>pią|sob|nd)(\s*)(?P<godzina>\d{2}):(?P<minuta>\d{2})', div.contents[3].renderContents(), re.M)
 dzien, godzina, minuta = czas.group('dzien', 'godzina', 'minuta')
 godzina = int(godzina)
 minuta = int(minuta)
 
 # Conversion from name of the day to number of the day
 if dzien == 'pią':
  dzien = 25
 elif dzien == 'sob':
  dzien = 26
 elif dzien == 'nd':
  dzien = 27
 else:
  raise ValueError('Błędny dzień')
 
 # How long it lasts
 dlugosc = re.search('^<b>czas trwania: </b>(?P<godzin>\d+):(?P<minut>\d{2}) h<br />', div.contents[3].renderContents(), re.M)
 godzin, minut = dlugosc.group('godzin', 'minut')
 godzin = int(godzin)
 minut = int(minut)
 
 # Build shell command for googlecl - google command line interface (available at code.google.com)
 # uses "Quick Add" syntax
 polecenie = '''google calendar add --cal='%s' '%s - %s on %d/03/2011 %d:%02d for %d minutes in %s' ''' % (miejsce, tytul, prowadzacy, dzien, godzina, minuta, godzin * 60 + minut, miejsce)

 # Keep calling shell command until it succeeds
 # Sometimes it throws gdata.service.RequestError with status 302 and reason 'Redirect received, but redirects_remaining <= 0'
 return_code = 1
 while return_code != 0:
  print polecenie
  return_code = subprocess.call(polecenie, shell=True)

"97 things every programmer should know" is going to be translated to Polish

2011-02-21T13:43:00.002+01:00

I volunteered to help translating "97 things programmers should know". Here's our progress:You can find it at 97rzeczy.devblogi.pl

OpenWRT + Lighttpd + Fastcgi + Django

2010-12-19T23:29:00.006+01:00

Introduction

Here's something I was fighting with for about 3 days. At first I wanted to use virtualenv too, but it all resulted in a headache. I'm a novice in these matters, so forgive me.

Recently I bought a router TP-Link WR-1043ND. Not the best choice now, I'm aware: TP-Link MR3420 has higher quality to price ratio. Anyway, my router got upgraded to OpenWRT, version Backfire 10.3-RC4, thanks to great work of Cezary Jackiewicz aka Obsy.

Installation

Opkg packages

First packages that we can install with OpenWRT package manager:

lighttpd, lighttpd-mod-alias, lighttpd-mod-rewrite, lighttpd-mod-fcgi - packages needed for http server called lighty
pysqlite, libsqlite3 - the database
python wasn't installed at first, so we'll need this too

opkg install lighttpd lighttpd-mod-alias lighttpd-mod-rewrite lighttpd-mod-fcgi
opkg python libsqlite3 pysqlite

Python packages

These will be installed from Python Package Index (PyPI).We will need:

setuptools - Go to pypi.python.org, search for setuptools, follow the instructions.
pip - We should be able to call: easy_install pip to obtain it.
django - With pip in place getting django is as easy as pip install django. Pip, contrary to easy_install, has a nice uninstall option.
flup - For FastCGI related stuff

There we go. It's all installed.

Configuration

3 ways of doing this

First of all, let me briefly explain how FastCGI works. Actually this might not be a good idea to believe me, because, as I said, I'm a layman in this matters. There are 3 entities in this process: the browser, the server (Lighttpd), the FastCGI process (Django).
First step is forwarding the http request for a webpage to FastCGI process:

Browser => Lighttpd => Django FCGI

Request is processed and Django returns html source code of a webpage. Shove it back to your browser and render it.

Browser <= Lighttpd <= Django FCGI

By bin-path
By host and port
By socket

My app's directory: /www/apps/homepage. It doesn't have to be anything fancy. It's ok to use brand new project created with django-admin.py startproject homepage.

Bin-path

This method is my favourite so far. We tell lighttpd where to find executable file .fcgi and it starts FCGI processes by itself. All we need to take care of now is that the server is started after reboot. Here are the details:

Contents of .fcgi file. It sits at the django project's directory.

#!/usr/bin/env python
import sys, os

# Add a custom Python path.
sys.path.insert(0, "/www/apps")

# Set the DJANGO_SETTINGS_MODULE environment variable.
os.environ['DJANGO_SETTINGS_MODULE'] = "homepage.settings"

from django.core.servers.fastcgi import runfastcgi
# maxspare=2 is minimum from what i saw
runfastcgi(method="threaded", daemonize="false", maxspare=2)

Lighttpd config file from /etc/lighttpd/lighttpd.conf. It is edited version of default config file. I just omitted most of commented out lines.

# lighttpd configuration file
# 
## modules to load
# all other module should only be loaded if really neccesary
# - saves some time
# - saves memory
server.modules = ( 
 "mod_rewrite", 
# "mod_redirect", 
 "mod_alias", 
# "mod_auth", 
# "mod_status", 
# "mod_setenv",
 "mod_fastcgi",
# "mod_proxy",
# "mod_simple_vhost",
# "mod_cgi",
# "mod_ssi",
# "mod_usertrack",
# "mod_expire",
# "mod_webdav"
)

# force use of the "write" backend (closes: #2401)
server.network-backend = "write"

## a static document-root, for virtual-hosting take look at the 
## server.virtual-* options
server.document-root = "/www/public"

## where to send error-messages to
server.errorlog = "/var/log/lighttpd/error.log"

## files to check for if .../ is requested
index-file.names = ( "index.html", "default.html", "index.htm", "default.htm" )

## mimetype mapping
mimetype.assign = (  
 ".pdf"   => "application/pdf",
 ".class" => "application/octet-stream",
 ".pac"   => "application/x-ns-proxy-autoconfig",
 ".swf"   => "application/x-shockwave-flash",
 ".wav"   => "audio/x-wav",
 ".gif"   => "image/gif",
 ".jpg"   => "image/jpeg",
 ".jpeg"  => "image/jpeg",
 ".png"   => "image/png",
 ".css"   => "text/css",
 ".html"  => "text/html",
 ".htm"   => "text/html",
 ".js"    => "text/javascript",
 ".txt"   => "text/plain",
 ".dtd"   => "text/xml",
 ".xml"   => "text/xml"
 )

$HTTP["url"] =~ "\.pdf$" {
 server.range-requests = "disable"
}

##
# which extensions should not be handle via static-file transfer
#
# .php, .pl, .fcgi are most often handled by mod_fastcgi or mod_cgi
static-file.exclude-extensions = ( ".php", ".pl", ".fcgi" )

## to help the rc.scripts
server.pid-file = "/var/run/lighttpd.pid"

#### fastcgi module
## read fastcgi.txt for more info
# this line may help with finding what's wrong, check out errorlog file
# fastcgi.debug=1
fastcgi.server = (
 "/homepage.fcgi" => (
  "main" => (
   "host" => "127.0.0.1",
   "port" => 3033,
   "check-local" => "disable",
   "max-procs" => 1,
   "bin-path" => "/www/apps/homepage/homepage.fcgi"
  )
 )
)

alias.url = (
                "/media" => "/www/apps/homepage/media",
        )

url.rewrite-once = (
                "^(/media.*)$" => "$1",
                "^/favicon\.ico$" => "/media/favicon.ico",
                "^(/.*)$" => "/homepage.fcgi$1",
        )

Host:port

You don't need .fcgi file in this method. Remove line with "bin-path" in fastcgi.server section of lighttpd config. Now you need to make sure that you run this at every boot (maybe you can use start-stop-daemon tool for this):

/www/apps/homepage/manage.py runfcgi method=threaded host="127.0.0.1" port=3033

This will start FastCGI threads. Lighttpd will expect them to be there when he needs a page. Otherwise you'll get 503 or 500. This method is said to be easier because there is no need to set permissions on TCP socket.

Socket

In this method FCGI process and HTTP Server communicate through a socket (aka named pipe). Proper permissions must be in place. FCGI file is also not needed here. You must make sure that you run similar command as in the second method:

/www/apps/homepage/manage.py runfcgi method=threaded socket=/www/apps/homepage/homepage.socket

Lines in fastcgi.server with port and host get removed. Instead add

"socket" => "/www/apps/homepage/homepage.socket"

Conclusion

I use a lot of bad practices here:

do everything as root
not using virtualenv
keeping my app in /www (but I changed my document-root, so maybe I'm ok?)

This is an example of work done by someone who came from "no idea" to "it started working" and all this happens on a router that won't be under a lot of load or work in a cloud of virtual machines. Certainly it's not state of the art, but gets the job done.

There's quite a lot of this kind of tutorials, but to someone without proper knowledge all these terms and blindly followed instructions are no good if something doesn't work as expected. I hope someone will find the wording I used useful. I hope will when I'll need to do everything all over again.

Kernel log spammed with rt2500 errors

2010-08-12T21:33:00.000+02:00

My wifi card kept spamming kernel log with messages like this: "phy0 -> rt2500pci_set_device_state: Error - Device failed to enter state 1 (-16)". The solution is easily found among launchpad bug reports. Power management needs to be turned off for the card. It's easy to do:

iwconfig wlan0 power off

To make it permanent edit /etc/rc.local adding this line before exit 0. Reboot and you're done! Confirm that with calling iwconfig:

lo        no wireless extensions.

eth0      no wireless extensions.

wlan0     IEEE 802.11bg  ESSID:"TP69"  
          Mode:Managed  Frequency:2.422 GHz  Access Point: 00:23:CD:15:F2:A0   
          Bit Rate=48 Mb/s   Tx-Power=20 dBm   
          Retry  long limit:7   RTS thr:off   Fragment thr:off
          Power Management:off
          Link Quality=60/70  Signal level=-50 dBm  
          Rx invalid nwid:0  Rx invalid crypt:0  Rx invalid frag:0
          Tx excessive retries:0  Invalid misc:0   Missed beacon:0

First success with RTAI

2010-06-01T19:40:00.001+02:00

Recently I've been trying to grok Real Time Application Interface (more on www.rtai.org). It certainly wasn't a walk in the park, but still far far easier than RTLinux. This time at least I had a clue what was going on. Following this tutorial worked for me: http://qrtailab.sourceforge.net/rtai_installation.html.

Finally when everything is set up you can do: sudo start_rtai on command line. This starts RTAI.

Now for some programming. Here's a snippet:

/* led1.c, an LXRT LED blinker */

#include <rtai_lxrt.h>
#include <pthread.h>
#include <sys/mman.h>
#include <sys/io.h>

// delay in nanoseconds
#define TICKS 500000000 

main()
{
        RT_TASK *task;
        int priority = 0, i;
        int stack_size = 4096;
        int msg_size = 0; // use default

        // get enough privilege to 
        // access the I/O ports.

        iopl(3);

        task = rt_task_init(nam2num("main"), priority, stack_size, msg_size);
        if(task == 0)
        {
         printf("Task could not be initialized. Are you root?");
         exit(1);
        }
        rt_set_oneshot_mode();
        start_rt_timer(0);
        mlockall(MCL_CURRENT|MCL_FUTURE);
        rt_make_hard_real_time();

        for(i = 0; i < 10; i++) {
                outb(0xff, 0x378);
                rt_sleep(nano2count(TICKS));
                outb(0x0, 0x378);
                rt_sleep(nano2count(TICKS));
        }
        // back to non-rt land!
        rt_make_soft_real_time();
        stop_rt_timer();
        rt_task_delete(task);
        return 0;
}

It's a program that comes from this article with added troubleshooting comment.

To compile this program it's necessary to run:

CFLAGS=$(rtai-config --lxrt-cflags
LDFLAGS=$(rtai-config --lxrt-ldflags
gcc $(CFLAGS) $(LDFLAGS) main.c -o blinker

Where main.c is the name of the source file and blinker is the name of output executable.
To run it you should write sudo ./blinker. Sudo is needed because of the direct hardware access. You should see that the leds hooked up to lpt port are blinking.

LPT port access with C

2010-05-17T13:35:00.000+02:00

I found this useful snippet on another blog.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/io.h>
#include <sys/types.h>
#include <fcntl.h>

#define BASEPORT 0x378 /* lp1 */

int main()
{
  unsigned char c = 0;
  int n, tem;

   printf("Hit enter to stop\n");

  if (ioperm(BASEPORT, 3, 1)) 
  {
   perror("ioperm");
   exit(1);
  }

  tem = fcntl(0, F_GETFL, 0);
  fcntl (0, F_SETFL, (tem | O_NDELAY));
  
  while (1) {
    n = read(0, &c, 1);
    if (n > 0) break;

     outb(c, BASEPORT);
     usleep(c * 1000);
     c++;
  }

  fcntl(0, F_SETFL, tem);
  outb(0, BASEPORT);

  if (ioperm(BASEPORT, 3, 0)) 
  {
   perror("ioperm");
   exit(1);
  }
  exit(0);
}

Multikalendarz Pyrkon 2010

2010-03-22T23:01:00.002+01:00

Kalendarz Pyrkon 2010

2010-03-22T22:13:00.000+01:00

Don't code while designing

2010-03-12T12:22:00.000+01:00

There's plenty of comments all over the Internet about "coding now, designing later" made by seasoned developer's. Right now I'm working with my colleagues on a project that needs to be written from scratch. Fighting the need to write something first I decided I won't do any implementation in advance.
My working environment is MS Visual Studio 2008. Recently I found there a feature which turned out very useful in my current situation: Class Diagram. I'm going to implement basic MVC framework as I understand it based on various tutorials I've read. It may not be 100% correct. Sorry.

Create new project in a new solution.
Right click on project's name in Solution Explorer and choose View Class Diagram.
Rename file Class1.cs to Model.cs and change Class1 name to Model.
Add 2 more classes dragging them from Toolbox and giving names: View and Controller.
To add a method to a class right click on class box and choose Add->Method or go to Class Details window and add the new method there. If you don't see Class Details window, right click on a class and choose Class Details.
View should have methods: AttachDataSource and Update.
Controller should have methods: AttachModel, RequestAttachingView, RequestChangeState.
Model should have methods: AttachView, ChangeState, ServeData, UpdateViews
You don't want your classes to directly depend from each other, but use interfaces instead. To extract interface right click on class box, choose Refactor->Extract Interface... and choose methodes and properties that will form an interface.
Extract IView interface from View with methods: AttachDataSource, Update.
Extract IViewDataSource from Model with method ServeData.
Extract IControllable from Model with methods: AttachView, ChangeState.
Now add field viewDataSource to View of type IViewDataSource.
Add field view to Model of type IView.
Add field controlledModel to Controller of type IControllable.
For some more readability you can right click on a field and choose Show as Association.

Your current state should be something like this:

Notice you didn't write anything in code yet. Next step will be implementation.

Python i wykrycie beatu

2010-03-05T17:45:00.005+01:00

W zasadzie nie wiem jak przetłumaczyć "beat" - uderzenie, rytm? Napisałem skrypt szukający beatów w pliku dźwiękowym. Jako materiał do analizy posłużyło pierwszy 10 sekund piosenki. Beat zdefiniowany jest jako skok chwilowej energii sygnału, co odbierane jest przez ucho jako głośniejszy dźwięk.
Więcej informacji tutaj: http://www.gamedev.net/reference/programming/features/beatdetection/

__author__ = "daniel"
__date__ = "$2010-03-04 00:21:00$"

from scipy.io import wavfile
import matplotlib.pyplot as pyplot
import numpy

if __name__ == "__main__":
# wczytanie pliku
fs, dane = wavfile.read("/home/daniel/Muzyka/steady10s.wav")
# laczenie dwoch kanalow w jeden
print dane.shape
dane = dane[:, 0] / 2.0 + dane[:, 1] / 2.0
# normalizacja
dane = dane / max(dane)
# obliczanie energii przenoszonej przez sygnal
dane = dane**2


# o tyle probek bedziemy skakac w czasie analizy
k = fs / 10
# dlugosc okna analizy
N = 2 ** 10
i = 0
# ilosc probek w pliku
length, = dane.shape
# const, ile razy wieksza musi byc wartosc energii sygnalu zeby uznany byl za beat
C = 2
srednia = []
# w ktorych momentach wykryto beat
beats = []
while i*k+N <= length:
srednia.append(abs(dane[i*k:i*k+N-1].mean()))
# sprawdzamy ostatnie 42 usrednienia, czyli ~1s
if (sum(srednia[-42:])/42 * C < srednia[-1]):
#print "Beat @", i*k+N/2, "i:", i
beats.append(i)
i+=1

srednia = numpy.array(srednia)
# skalowanie ybeats do 2-krotności średniej energii w danym punkcie (dla przejrzystosci)
ybeats = numpy.ones(shape=len(beats))
for i, b in enumerate(beats):
ybeats[i] *= srednia[b] * 2

# rysowanie wykresów (mocno podobne do matlaba)
pyplot.plot(srednia)
pyplot.hold(True)
pyplot.stem(beats, ybeats, 'k')
pyplot.title("Beats")
pyplot.savefig("/home/daniel/Obrazy/steady10sbeats.png")
pyplot.show()

A oto wynik:Szczęśliwym trafem Steady as she goes ma bardzo wyraźny rytm na początku, więc łatwo go wykryć. Kolejnym krokiem będzie analiza trudniejszego materiału.

Python i analiza dźwięku

2010-03-05T15:22:00.004+01:00

Skrypt analizujący głośność dźwięku zapisanego w pliku wav napisany w Pythonie. Obliczana jest wartość średnia w oknie o długości N. Kolejne okna to k:k+N-1, 2*k:2*k+N-1, ... , gdy k < N to okna się nakładają. Na końcu z pomocą biblioteki matplotlib rysowany jest wykres głośności.

__author__ = "daniel"

__date__ = "$2010-03-04 00:21:00$"



from scipy.io import wavfile

import matplotlib.pyplot as pyplot



if __name__ == "__main__":

# wczytanie pliku 

fs, dane = wavfile.read("/home/daniel/Muzyka/labedzie.wav")

# laczenie dwoch kanalow w jeden

dane = dane[:, 0] / 2.0 + dane[:, 1] / 2.0

# normalizacja

dane = dane / max(dane)



# o tyle probek bedziemy skakac w czasie analizy

k = fs / 10

# dlugosc okna analizy

N = 2 ** 13

i = 0

# ilosc probek w pliku

length, = dane.shape

srednia = []



while i * k + N < length:
        srednia.append(abs(dane[i*k:i*k+N-1].mean()))
        i+=1

    pyplot.plot(srednia)
    pyplot.title("Wykres glosnosci")
    pyplot.show()

Kompilacja kernela 2.6.9 na RedHat 8.0

2010-03-01T15:44:00.001+01:00

RedHat 8.0 zainstalowałem z 5 płyt CD z których w czasie instalacji potrzebne są chyba tylko 2 pierwsze.
W trakcie instalacji pozaznaczałem, że chcę mieć zainstalowane narzędzia programistyczne (m. in. kernel development).

Po ściągnięciu i rozpakowaniu kernela podawałem kolejno komendy:

make mrproper
make menuconfig (tu trzeba pamiętać, żeby obsługa ext3fs była wbudowana w kernel, a nie jako moduł, ponieważ partycja boot jest w ext3)
make dep
make clean
make bzImage
make modules
make modules_install (jako root, i nie "make module_install"!!!)

/sbin/mkinitrd /boot/initrd-2.6.9 2.6.9

cp arch/i386/boot/bzImage /boot/vmlinuz-2.6.9
cp System.map /boot/System.map-2.6.9
ln -s /boot/System.map /boot/System.map-2.6.9

W pliku /boot/grub/grub.conf należy dodać wpis:

title Red Hat Linux (2.6.9)
root (hd0,0)
kernel /vmlinuz-2.6.9 ro root=LABEL=/
initrd /initrd-2.6.9.img

Błędy:
>> depmod can't open /lib/modules/2.4.18-14/modules.dep for writing
>> Warning: you may have to install module-init-tools
Rozwiązanie jest takie jak w warning - zainstalować module-init-tools. Przeprowadzi przez to ten poradnik: http://www.linuxquestions.org/linux/answers/Applications_GUI_Multimedia/How_to_Compile_2_6_kernel_for_RedHat_9_8 w krokach 2:4.

Grub: nie można znaleźć pliku, error 15. Czy na pewno przekopiowany jest bzImage i System.map ? Ścieżka powinna zaczynać się od /, a nie od /boot/ - patrz NOTICE w grub.conf.
Błąd "pivotroot: pivot_root(/sysroot,/sysroot/initrd) failed" oznacza, że obsługa ext3fs nie jest wbudowana w kernel. Trzeba ją dodać z pomocą "y" w kroku z make menuconfig.

Teraz pozostaje tylko restart i użycie nowego kernela. Mi podczas wstawania systemu wyskoczyła tylko niepokojąca mnie informacja o jakichś problemach z eth0, ale do projektu nie będzie mi to potrzebne najprawdopodobniej, więc na razie się nie martwię.

Wyszukiwanie tekstu w plikach za pomocą konsoli

2010-01-23T01:13:00.002+01:00

Stanąwszy dzisiaj w obliczu potrzeby wyszukania pewnego tekstu w plikach tekstowych, które znajdują się w biężącym katalogu lub w którymś z jego podkatalogów poszperałem trochę w pomocy i wynalazłem taką kombinację:
cat $(find . -name "*.txt" -print) | grep -H -i tekst
Od początku:
find . -name "*.txt" -print - wyszukuje wszystkie pliki w katalogu bieżacym (.) lub głębiej o nazwie pasującej do *.txt i wyświetla na ekranie (-print)
$(find . -name "*.txt" -print) - otoczenie nawiasami ochronnymi aby wynik find "wkleił" się jako argument polecenia cat. Taki sam efekt można uzyskać przy pomocy otoczenia ` ` (znak nad tabem).
cat $(find . -name "*.txt" -print) - wypisuje zawartość plików podanych przez find
cat $(find . -name "*.txt" -print) | grep -H -i tekst - wyjście cat jest podawane do grepa, który wyszukuje w nim tekstu "tekst" będąc niewrażliwym na wielkość liter (-i) oraz dodając nazwę pliku dla każdej linii w której znajduje się trafienie (-H).

Głośniki w laptopie i słuchawki/głośniki

2010-01-17T19:36:00.000+01:00

Okazuje się, że Karmic Koala również ma problem z przełączaniem się pomiędzy głośnikami laptopa i słuchawkami czy głośnikami. Po włożeniu wtyczki grają oba zestawy. Oto co dostaję po wykonaniu lspci | grep -i audio:

00:1b.0 Audio device: Intel Corporation 82801H (ICH8 Family) HD Audio Controller (rev 03)

Natomiast mikser alsa pokazał mi, że mam jakąś kartę Realtek. Rozwiązaniem okazało się dodanie w pliku /etc/modprobe.d/alsa-base.conf linijki: options snd-hda-intel model=auto. Po restarcie komputera wszystko działa już jak należy.

Kompilacja kernela RTLinux

2010-01-01T21:43:00.009+01:00

Jakiś czas żyłem w przekonaniu, że dostępna w repozytorium paczka linux-image-rt zawiera to samo jądro które jest podstawą RTLinuxa strona domowa RTLinux. Zatem aby skompilować jądro z patchem RTLinuxa będę musiał włożyć w to więcej wysiłku.
Zacząłem od ściągnięcia patcha RTLinux ze strony domowej, a następnie kodu źródłowego kernela z www.kernel.org. Dopiero po jakimś czasie zorientowałem się, że nie mogę używać kodu ostatniego kernela, bo nie ma dostępnego dla niego patcha. Musiałem więc ściągnąć kernel w wersji 2.6.9. Dalsze postępowanie wyglądało następująco:
Skopiowałem plik rtlinux-3.2-wr.tar.bz2 do katalogu /usr/src.
Rozpakowałem go poleceniem tar xjf rtlinux-3.2-wr.tar.bz2
Wszedłem do katalogu rtlinux-3.2-wr
Skopiowałem tu plik linux-2.6.9.tar.bz2 i rozpakowałem.
Utworzyłem dowiązanie symboliczne: ln -fs linux-2.6.9 linux
Wszedłem przez link linux do katalogu z rozpakowanymi źródłami kernela.
Teraz należy zaaplikować patch, który znajduje się tutaj. Inaczej otrzymamy błędy kompilacji w postaci:

{standard input}: Assembler messages:
{standard input}:607: Error: suffix or operands invalid for `mov'
{standard input}:630: Error: suffix or operands invalid for `mov'
{standard input}:1144: Error: suffix or operands invalid for `mov'
{standard input}:1145: Error: suffix or operands invalid for `mov'
{standard input}:1146: Error: suffix or operands invalid for `mov'
{standard input}:1147: Error: suffix or operands invalid for `mov'
make[1]: *** [arch/x86_64/kernel/process.o] Error 1
make: *** [arch/x86_64/kernel] Error 2

Rozwiązanie przyszło stąd. Zatem należy wykonać: patch -p1 < /sciezka/do/patcha/linux-2.6-seg-5.patch
Następnie zaaplikować patch RTLinuksa: patch -p1 < ../patches/kernel_patch-2.6.9-rtl3.2-rc1
Po tym wszystkim należe skonfigurować opcje kernela za pomocą jednego z poleceń: make menuconfig, make xconfig, make gconfig. Pojawi się menu w którym można wybrać czy dana opcja ma być wkompilowana w jądro czy doinstalowywana jako moduł lub całkowicie usunięta.
Teraz postępując dalej wg tej instrukcji: http://blog.0x1fff.com/2009/04/debian-gnulinux-kompilacja-jadra.html
Dostałem błąd o ponownie definiowanych makrach fake_stake_cośtam i unfake_stake_itd. Jak dowiedziałem się na jakimś forum należy otworzyć plik w którym makra są ponownie definiowane i po prostu je usunąć. Niestety zgubił mi się już link, gdzie to przeczytałem.

W tej chwili otrzymuję błędy o niepełnym typie tablicy.

In file included from fs/compat_ioctl.c:69,
from arch/x86_64/ia32/ia32_ioctl.c:14:
include/linux/i2c.h:58: error: array type has incomplete element type
include/linux/i2c.h:205: error: array type has incomplete element type
make[2]: *** [arch/x86_64/ia32/ia32_ioctl.o] Błąd 1
make[1]: *** [arch/x86_64/ia32] Błąd 2
make[1]: Opuszczenie katalogu `/usr/src/rtlinux-3.2-wr/linux-2.6.9'
make: *** [debian/stamp/build/kernel] Błąd 2

Powodowane jest to tym, że w czasach kernela 2.6.9 używało się starszych narzędzi kompilacji, które najwyraźniej były bardziej pobłażliwe niż obecne.
Zamieniłem linię 58 w incude/linux/i2c.h:
extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],int num);
na
extern int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msg,int num);
oraz
int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg msgs[],
int num);
na
int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,
int num);
W pliku /include/linux/fb.h linia 751:
extern const struct fb_videomode vesa_modes[];
na
extern const struct fb_videomode *vesa_modes;

Teraz zatrzymałem się z błędem:

/usr/bin/ld: arch/x86_64/ia32/vsyscall-sysenter.so: Not enough room for program headers, try linking with -N
/usr/bin/ld: final link failed: Bad value
collect2: ld returned 1 exit status
make[2]: *** [arch/x86_64/ia32/vsyscall-sysenter.so] Błąd 1
make[1]: *** [arch/x86_64/ia32] Błąd 2
make[1]: Opuszczenie katalogu `/usr/src/rtlinux-3.2-wr/linux-2.6.9'
make: *** [debian/stamp/build/kernel] Błąd 2

Tysiąc insertów na sekundę

2009-11-27T22:06:00.008+01:00

Dokładniej 50,000 na typowym komputerze - tak przynajmniej twierdzą twórcy sqlite3 w FAQ. Miałem okazję przekonać się o tym na własnej skórze. W programie o którym wcześniej pisałem chciałbym zapisywać dane o cząsteczkach w danej iteracji algorytmu. Oto kod przed optymalizacją:

void SaveResultsToDatabase(sqlite3* db, Particle* host_agents, const int N, const int generation) {
    char stmt[90];
    char* errorMsg = NULL;
    int returnCode;

    int i = 0;
    for (i = 0; i < N; ++i) {
        sprintf(stmt, "insert into pso values (%d, %d, %f, %f); ",
                generation,
                i,
                host_agents[i].current.x,
                host_agents[i].current.y);
        returnCode = sqlite3_exec(db, stmt, NULL, NULL, &errorMsg);
        if (returnCode != SQLITE_OK) {
            if (errorMsg != NULL) {
                printf("%s", errorMsg);
                sqlite3_free(errorMsg);
            } else {
                printf("Return code: %d\n", returnCode);
            }
        }
    }
}

W tym przypadku czas wykonania to około minuty dla 1000 wpisów. Każdy insert jest wykonywany, baza czeka aż dane będą bezpieczne i dopiero wykonuje następny wpis. Jednak tak jak to jest opisane w FAQ można tego uniknąć tworząc jedną wielką transakcję zamkniętą w klamry BEGIN TRANSACTION; i COMMIT:

 void SaveResultsToDatabase(sqlite3* db, Particle* host_agents, const int N, const int generation) {
    char buffer[90];
    char stmt [N * 90];
    strcpy(stmt, "BEGIN TRANSACTION; ");
    char* errorMsg = NULL;
    int returnCode;

    int i = 0;
    for (i = 0; i < N; ++i) {
        sprintf(buffer, "insert into pso values (%d, %d, %f, %f); ",
                generation,
                i,
                host_agents[i].current.x,
                host_agents[i].current.y);
        strcat(stmt, buffer);
    }
    strcat(stmt, "COMMIT");
    returnCode = sqlite3_exec(db, stmt, NULL, NULL, &errorMsg);
    if (returnCode != SQLITE_OK) {
        if (errorMsg != NULL) {
            printf("%s", errorMsg);
            sqlite3_free(errorMsg);
        } else {
            printf("Return code: %d\n", returnCode);
        }
    }
}

W tym przypadku czas wykonania jest poniżej sekundy. Niezła optymalizacja.
BREAKING NEWS. Właśnie spróbowałem zapisać 100000 wpisów i okazało się, że trwa to około 1,5 minuty. Nie wiedziałem dlaczego aż tyle. Z początku myślałem, że chodzi o manipulowanie char*, ciągłe przydzielanie pamięci itp, ale potem przypomniało mi się, że ktoś pisał o tym, żeby znaleźć "optimal insert size for your database". Czas zatem na kolejną zmianę kodu:

void SaveResultsToDatabase(sqlite3* db, Particle* host_agents, const int N, const int generation) {
    printf("Saving to database\n");
    const int partSize = 5000;
    char buffer[90];
    char stmt [partSize * 90];
    int i = 0;
    while (i < N) {
        strcpy(stmt, "BEGIN TRANSACTION; ");
        char* errorMsg = NULL;
        int returnCode;

        do {
            sprintf(buffer, "insert into pso values (%d, %d, %f, %f); ",
                    generation,
                    i,
                    host_agents[i].current.x,
                    host_agents[i].current.y);
            strcat(stmt, buffer);
            ++i;
        } while ((i % partSize != 0) && i < N);
        strcat(stmt, "COMMIT");
        returnCode = sqlite3_exec(db, stmt, NULL, NULL, &errorMsg);
        if (returnCode != SQLITE_OK) {
            if (errorMsg != NULL) {
                fprintf(stderr, "%s\n", errorMsg);
                sqlite3_free(errorMsg);
            } else {
                fprintf(stderr, "sqlite3 return code: %d\n", returnCode);
            }
        }
    }
}

W obecnej postaci wykonanie kodu trwa 23 sekundy dla 3 iteracji po 100000 cząsteczek, włączając w to przesyłanie danych, obliczenia na karcie graficznej i wyświetlanie komunikatów w terminalu (to chyba najbardziej spowalnia program). Przypuszczam, że jeszcze będę eksperymentować z wielkością wrzutów do bazy danych.

Przeszukiwanie listy argumentów linii poleceń w C

2009-11-27T21:08:00.003+01:00

Po długich i wyczerpujących walkach z nvcc (kod skompilowany nvcc nie bardzo się komponuje z g++, nie wiem czemu, innym DZIAŁA - SOA#1) postanowiłem, że algorytm optymalizacji rojem będzie miał postać programu w C, który zapisze wynik działania algorytmu w bazie sqlite3, a ja sobie w innej aplikacji skompilowanej już normalnym kompilatorem będę te dane obrabiał. W międzyczasie okazało się, że fajnie byłoby ustalać liczbę cząsteczek roju i postanowiłem do tego wykorzystać argumenty linii poleceń. Wtedy pojawił się problem jak z argc i argv wyciągnąć to o co mi chodzi. Czynność ta jest wykorzystywana na porządku dziennym w programach, więc istnieje w tym celu odpowiednia procedura, a nazywa się ona getopt() i znajduje się w pliku nagłówkowym unistd.h. W obecnej chwili używam dwóch opcji: -n oraz -o. Obie wymagają argumentu. Oto kod:

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
int main(int argc, char** argv) {
    //initialize variables
    int N = 10; // Ilosc agentow
    int c = 0;
    char* dbfilename = NULL;
   
    while((c = getopt(argc, argv, "n:o:")) != -1)
    {
        switch(c)
        {
            case 'n':
                N = atoi(optarg);
                printf("Number of particles: %d\n", N);
                if (N <= 0)
                {
                    fprintf(stderr, "Invalid number of particles, setting to default = 10\n");
                    N = 10;
                }
                break;
            case 'o':
                dbfilename = optarg;
                printf("Output to file: %s\n", dbfilename);
                break;
            case '?':
                switch(optopt)
                {
                    case 'n':
                    fprintf(stderr, "Option -n sets number of particles and requires integer argument.\n");
                    break;
                    case 'o':
                        fprintf(stderr, "Option -o sets name of output file and requires a string argument.\n");
                        break;
                    default:
                        fprintf(stderr, "Unknown option: %c\n", optopt);
                };
                break;
            default:
                printf("Abort: %d = %c\n", c, c);
                abort();
        }
    }

Przede wszystkim po "przegryzieniu się" przez wszystkie argumenty getopt() zwraca -1, dlatego taki warunek jest w while. W przeciwnym przypadku dostaniemy wartość znaku, który reprezentuje opcję. Opcje jakie przewidujemy w programie podajemy jako trzeci argument. Aby zaznaczyć, że opcja ma wymagany argument należy dodać po niej ":". Aby zaznaczyć, że opcja ma opcjonalny argument dodajemy "::". W switch podejmujemy odpowiednią akcję w zależności od opcji.
Dla -n będzie to zamiana alphanumeric to integer, czyli zamiana łańcucha znaków na liczbę całkowitą, a następnie sprawdzenie czy wartość ta jest większa od 0. Argument dla opcji jest przechowywany w optarg jako łańcuch znaków.
Opcja -o odpowiada za nazwę pliku wynikowego. Jak widać można przypisać wskaźnik optarg do wskaźnika typu char*, czyli nie jest on typu const char* (tak jakby to było w przypadku np printf("Tekst typu const char*"). Dokładniej optarg wskazuje na jeden z elementów argv, więc można go modyfikować. W przypadku błędów podawana jest wartość '?' co może oznaczać brak argumentu dla opcji lub nieznaną opcję.
Opcja default z tego co zrozumiałem nie ma prawa się wydarzyć, ale dodałem tam trochę kodu, żeby dowiedzieć się co się dzieje w razie czego. W końcu dobry programista patrzy w obie strony przed przejściem przez jednokierunkową ulicę.

CUDA 2.3 na Ubuntu 9.10 cz. 2

2009-11-06T17:39:00.003+01:00

Teraz należałoby sprawdzić czy wszystko jest poprawnie zainstalowane kompilując przykładowe projekty.
Skracając cały proces pokonywania błędów jakie wystąpiły w czasie tego polecenia:
1) CUDA nie działa z kompilatorami w wersji 4.4. Niestety odinstalowanie gcc-4.4 nie wchodziło w grę, gdyż musiałbym również odinstalować świeżo zainstalowane sterowniki. Zainstalowałem więc gcc i g++ w wersji 4.3.

sudo apt-get install gcc-4.3 g++-4.3

Potem próbowałem zmienić makefile, aby zamiast

CXX := g++
CC := gcc
LINK := g++ -fPIC

mieć

CXX := g++-4.3
CC := gcc-4.3
LINK := g++-4.3 -fPIC

Niestety to nic nie dało. Jeden z użytkowników z forum NVIDIA doszedł do wniosku, że zmienne te nadpisywane są w którymś z innych makefile'ów. Cofnąłem zmiany i zamiast tego zmieniłem dowiązanie /usr/bin/gcc z gcc-4.4 na gcc-4.3.

sudo rm /usr/bin/gcc
sudo ln -s -v gcc-4.3 /usr/bin/gcc

Analogiczną operację przeprowadziłem też dla g++. Sprawdziłem czy pod linkiem gcc jest kompilator o właściwej wersji:

gcc --version
gcc (Ubuntu 4.3.4-5ubuntu1) 4.3.4
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

2) Potrzebne też będą paczki libxmu-dev libxi-dev freeglut3 freeglut3-dev.

3) Teraz można już budować projekty.

cd ~/Projects/NVIDIA_GPU_Computing_SDK/C
make

Jeśli wszystko dobrze zapamiętałem to nie powinno być żadnych błędów kompilacji i będzie można uruchomić podstawowe programy testujące na obecność urządzenia cuda capable.

daniel@daniel-laptop:~/Projects/NVIDIA_GPU_Computing_SDK/C/bin/linux/release$ ./deviceQuery
CUDA Device Query (Runtime API) version (CUDART static linking)
There is 1 device supporting CUDA

Device 0: "GeForce 8400M GS"
CUDA Driver Version: 2.30
CUDA Runtime Version: 2.30
CUDA Capability Major revision number: 1
CUDA Capability Minor revision number: 1
Total amount of global memory: 267714560 bytes
Number of multiprocessors: 2
Number of cores: 16
Total amount of constant memory: 65536 bytes
Total amount of shared memory per block: 16384 bytes
Total number of registers available per block: 8192
Warp size: 32
Maximum number of threads per block: 512
Maximum sizes of each dimension of a block: 512 x 512 x 64
Maximum sizes of each dimension of a grid: 65535 x 65535 x 1
Maximum memory pitch: 262144 bytes
Texture alignment: 256 bytes
Clock rate: 0.80 GHz
Concurrent copy and execution: Yes
Run time limit on kernels: Yes
Integrated: No
Support host page-locked memory mapping: No
Compute mode: Default (multiple host threads can use this device simultaneously)

Test PASSED

oraz

Running on......
device 0:GeForce 8400M GS
Quick Mode
Host to Device Bandwidth for Pageable memory
.
Transfer Size (Bytes) Bandwidth(MB/s)
33554432 1473.1

Quick Mode
Device to Host Bandwidth for Pageable memory
.
Transfer Size (Bytes) Bandwidth(MB/s)
33554432 898.1

Quick Mode
Device to Device Bandwidth
.
Transfer Size (Bytes) Bandwidth(MB/s)
33554432 4197.4

&&&& Test PASSED

CUDA 2.3 na Ubuntu 9.10 cz. 1

2009-11-06T14:15:00.006+01:00

Kolejne podejście do używania CUDA na Ubuntu. Po kłopotach jakie miałem ze sterownikami NVIDIA na Ubuntu 8.04 postanowiłem przenieść się na najnowsze wydanie 9.10 (flash nie reaguje na kliknięcia, komputer nie wykrywa, że podłączyłem słuchawki - nie ukrywam, że to niemiłe rozczarowanie). Przy okazji zrobiłem upgrade z XP na Windows7.
Najnowsze sterowniki (w wersji 190) zainstalowałem z pomocą tego poradnika z Ubuntu Geek. W skrócie:

sudo add-apt-repository ppa:nvidia-vdpau/ppa
sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys CEC06767
sudo apt-get update
sudo apt-get install nvidia-190-modaliases nvidia-glx-190 nvidia-settings-190

Należy je jeszcze aktywować w System -> Administracja -> Sterowniki.

Teraz potrzebne będą Cuda Toolkit 2.3 - nie ma wersji dla Ubuntu 9.10, więc wybrałem wersję dla 9.04. Instalacja według instrukcji przebiega bezproblemowo. Potem zainstalowałem CUDA SDK również w wersji 2.3 dla Ubuntu 9.10.

Kolejnym krokiem było dodanie ścieżek cuda toolkit do zmiennych środowiskowych. W pliku ~/.bashrc dodałem:

if [ -d "/usr/local/cuda" ] ; then
PATH="/usr/local/cuda:$PATH"
fi

if [ -d "/usr/local/cuda/lib64" ] ; then
LD_LIBRARY_PATH="/usr/local/cuda/lib64:$LD_LIBRARY_PATH"
fi

if [ -d "/usr/local/cuda/bin" ] ; then
PATH="/usr/local/cuda/bin:$PATH"
fi

Pierwszy if sprawdza czy istnieje /usr/local/cuda, a jeśli tak to dodaje tę ścieżkę do zmiennej systemowej PATH. Kolejny if dodaje ścieżkę do bibliotek odpowiednich dla 64-bitowego systemu. Następnie dodawany jest katalog z plikami wykonawczymi aby móc korzystać z polecenia nvcc bez wpisywania całej ścieżki.
Nie jestem pewien czy w umieściłem ten skrypt w dobrym pliku - jeśli dobrze pamiętam to jest on wywoływany przy każdym włączeniu konsoli. Dobrze by było by dodawało się ono tylko raz przy starcie systemu i tak już zostawało. Po kilku uruchomieniach PATH wygląda tak:

daniel@daniel-laptop:~$ printenv PATH
/usr/local/cuda/bin:/usr/local/cuda:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games

Do tej pory wszystko przebiegało gładko i prawdziwe problemy dopiero się zaczną.

CUDA ruszyła

2009-10-27T16:10:00.006+01:00

Pierwszy projekt z wykorzystaniem CUDA mam już za sobą. Sam kod nie był trudny do napisania. Najgorsze było skłonienie Visual Studio do podpowiadania kodu (co do tej pory mi się nie udało - podpowiada kod tylko dla zmiennych i funkcji nieCUDA). Kolejna sprawa, która mnie irytowała to ścieżki dla plików nagłówkowych i bibliotek. Na początku zakładałem projekt w Moje Dokumenty\Visual Studio 2008\Projects i usiłowałem w ustawieniach projektu dodać ścieżki do CUDA SDK. Kompilator wywalał błędy, że nie może znaleźć pliku cuda.h podczas gdy wydawało mi się, że wszystko jest w porządku. Ostatecznie wyszło na to, że następujące ustawienia są prawidłowe (dla konfiguracji Debug):
- Linker -> General -> Additional Library Directories: "C:\CUDA\lib";"C:\Documents and Settings\Yelonek\Ustawienia lokalne\dane aplikacji\NVIDIA Corporation\NVIDIA CUDA SDK\common\lib" (tutaj taka dziwna ścieżka, bo wybrałem "instaluj tylko dla mnie" podczas instalacji pakietu i nie chciało mi się tego odkręcać)
- Linker -> Input -> Additional Dependencies: cudart.lib cutil32d.lib
Następny problem jaki się pojawił to to, że VS nie koloruje składni w plikach cu. Można to obejść w następujący sposób:
W katalogu NVIDIA CUDA SDK\doc\syntax_highlighting znajduje się plik usertype.dat, który należy umieścić w katalogu Microsoft Visual Studio 8\Common7\IDE. Następnie w samym VS należy w Tools... -> Options otworzyć Text Editor w liście po lewej i wybrać File Extension. Wpisujemy cu w polu Extension, ustawiamy edytor na MS Visual C++ i klikamy Add. Po zatwierdzeniu zmian i restarcie programu można się już cieszyć pokolorowaną składnią przy przeglądaniu plików cu.
Istnieje jeszcze jeden sposób na trochę wygodniejsze pisanie programów. Patent ten można znaleźć na innych stronach i blogach, ale też go tu opiszę. Polega on na tym, że program piszemy w pliku C, a podczas budowania projektu plik c kopiuje się do pliku cu, a dopiero plik cu jest budowany za pomocą nvcc. Dokonać tego można definiując własne zasady budowania plików. Po kliknięciu ppm na projekt w Solution Explorerze wybieramy Custom Build Steps... Tworzymy nowy plik zasad (New Rule File), podajemy nazwę jaka będzie wyświetlana w VS, nazwę pliku oraz ściężkę w jakiej chcemy go zapisać. Dodajemy nową zasadę (Add Build Rule). Pierwsza zasada to kopiowanie pliku c do cu.

Command line:copy $(InputFileName) $(InputName).cu
Display Name: Zamiana pliku c na cu
Execution Description: $(InputFileName) ------> $(InputName).cu
File Extensions: *.c
Name: Zamiana pliku c na cu
Outputs: $(InputName).cu
Show Only Rule Properties: True
Supports File Batching: False

Druga zasada to kompilacja plików cu za pomocą nvcc:

Additional dependencies: $(CUDA_INC_PATH)";"../../common/inc"
Command Line: "$(CUDA_BIN_PATH)\nvcc.exe" -ccbin "$(VCInstallDir)bin" -c -D_DEBUG -DWIN32 -D_CONSOLE -D_MBCS -Xcompiler /EHsc,/W3,/nologo,/Wp64,/Od,/Zi,/RTC1,/MTd -I"$(CUDA_INC_PATH)" -I../../common/inc -o $(ConfigurationName)\$(InputName).obj $(InputFileName)
Display Name: Kompilacja NVIDIA C for CUDA
Execution Description: Wywoływanie NVCC
File Extension: *.cu
Name: Kompilacja plików CUDA
Outputs: $(ConfigurationName)\$(InputName).obj
Show Only Rule Properties: True
Supports File Batching: False

Teraz tworzymy plik main.c w którym piszemy kod aplikacji. Kopiujemy go (tylko za pierwszym razem) i nazywamy main.cu, a następnie dodajemy do projektu. We właściwościach pliku main.c zamieniamy Tool z C/C++ Compiler na "Zamiana c na cu", a we właściwościach plik main.cu wybieramy "Kompilacja NVIDIA C for CUDA". Od tej pory można już budować projekt za pomocą F6 bez żadnych problemów.
Należy przy tym pamiętać, aby zmian dokonywać w pliku C, a nie CU!!! Gdyby kompilacja projektu się nie udała, to dostaniemy błędy tak jak zawsze, ale dwukrotne kliknięcie przeniesie nas do pliku CU, a nie C!!! Jeśli o tym zapomnimy i zmienimy plik cu, a następnie ponownie zbudujemy projekt wszystko będzie działać: plik c jest niezmieniony, więc VS go ponownie nie buduje (więc plik c nie zostanie skopiowany na plik cu). Załóżmy teraz, że zamknęliśmy projekt, otwieramy go ponownie i edytujemy plik c. Co się dzieje? Plik cu został nadpisany, znika kod pracowicie przez nas napisany i ponownie pojawiają się błędy kompilatora z którymi walczyliśmy przed zamknięciem programu. Można tak stracić parę godzin pracy, więc radzę uważać.

Na koniec przykładowy kod:

#include <stdio.h>
#include <stdlib.h>
#include <cuda.h>

// Struktura danych pojedynczego agenta
struct Agent
{
 float x;
 float y;
};

// Kernel który będzie wykonywał się na karcie
__global__ void Fitness(Agent* agent, int N, float* results)
{
 int idx = blockIdx.x * blockDim.x + threadIdx.x;
 if (idx < N)
 {
  results[idx] = 2 * agent[idx].x * agent[idx].x - agent[idx].x + 3;
 }
}

// Funkcja ktora bedzie wykonywac sie na hoscie
int main(void)
{
 // Deklaracja zmiennych
 const int N = 10000;        // Ilosc agentow
 Agent *host_agents = NULL, *device_agents = NULL; // Wskaznik do tablic u hosta (_h) i na karcie (_d)
 size_t size_agents = N * sizeof(Agent);    // Obliczenie rozmiaru tablicy agentow w bajtach
 
 float *host_results = NULL, *device_results = NULL; // Wskaznik do tablic z wynikami
 size_t size_results = N * sizeof(float);   // Obliczenie rozmiarow tablicy wynikow w bajtach

 // Przydzial pamieci
 host_agents = (Agent *)malloc(size_agents);        // Przydzial pamieci dla agentow na hoscie
 cudaMalloc((void **) &device_agents, size_agents);   // Przydzial pamieci dla agentow na karcie
 host_results = (float *)malloc(size_results);  //Przydzial pamieci na wyniki na hoscie
 cudaMalloc((void **) &device_results, size_results); //Przydzial pamieci na wyniki na karcie
  
 // Wpisanie wartosci poczatkowych do tablicy
 for (int i=0; i < N; i++) 
 {
  host_agents[i].x = (float)(rand()%100);
  host_agents[i].y = (float)(rand()%100);
 }
 
 //Skopiowanie tablicy z hosta do karty
 cudaMemcpy(device_agents, host_agents, size_agents, cudaMemcpyHostToDevice);
 // Wywolanie kernela
 int block_size = 4;
 int n_blocks = N/block_size + (N%block_size == 0 ? 0:1);

 Fitness <<< n_blocks, block_size >>> (device_agents, N, device_results);

 // Odebranie wyników z karty i zapisanie ich w tablicy na hoscie
 cudaMemcpy(host_results, device_results, size_results, cudaMemcpyDeviceToHost);

 // Wypisz wyniki
 for (int i = 0; i < N; i++) 
  printf("%05d: f(%04.4f, %04.4f) = %04.4f;\n", i, host_agents[i].x, host_agents[i].y, host_results[i]);
 // Cleanup
 free(host_agents);
 free(host_results);
 cudaFree(device_agents);
 cudaFree(device_results);
 system("pause");
}

CUDA NVidia

2009-10-20T11:58:00.004+02:00

Niedawno otrzymałem zadanie wykorzystania CUDA w algorytmie optymalizacji polegającym na przeszukiwaniu przestrzeni rozwiązań za pomocą "roju". Zaletą CUDA jest wykorzystanie procesora graficznego do przeprowadzania równoległych obliczeń na wielu zmiennych (przynajmniej w tej chwili tak to rozumiem).
Pomyślałem, że mogę wykonać ten projekt na Ubuntu 8.04.
Udałem się na stronę NVIDIA, gdzie w tej chwili znajdują się sterowniki w wersji 185 oraz CUDA Toolkit 2.2.
Niestety poniosłem porażkę - nie umiałem zainstalować sterowników. Po każdej instalacji Xy wstawały w trybie niskiej jakości grafiki. Doczytałem w internecie, że envyNG instaluje sterowniki NVIDIA wraz z biblioteką libcuda. Za pomocą tego programu udało mi się zainstalować sterowniki w wersji 173. Następnie zainstalowałem CUDA Toolkit oraz CUDA SDK. Zacząłem budować przykładowe projekty. Po wykonaniu make dostałem informację, że nie można znaleźć bibliotek libglut, więc zainstalowałem ją z repozytorium - `sudo apt-get install libglut3 libglut3-dev`. Następnym problemem okazał się projekt threadMigration - tutaj po prostu zmieniłem nazwę Makefile na Makefile-renamed i tego projektu nie uda mi się odpalić. W końcu wszystkie projekty zbudowane i wchodzę do katalogu /home/daniel/NVIDIA_CUDA_SDK/bin/linux/release/. Tutaj najpierw uruchamiam ./deviceQuery z następującym rezultatem:

CUDA Device Query (Runtime API) version (CUDART static linking)
There is 1 device supporting CUDA

Device 0: "GeForce 8400M GS"
CUDA Capability Major revision number: 1
CUDA Capability Minor revision number: 1
Total amount of global memory: 267714560 bytes
Number of multiprocessors: 16
Number of cores: 128
Total amount of constant memory: 65536 bytes
Total amount of shared memory per block: 16384 bytes
Total number of registers available per block: 8192
Warp size: 32
Maximum number of threads per block: 512
Maximum sizes of each dimension of a block: 512 x 512 x 64
Maximum sizes of each dimension of a grid: 65535 x 65535 x 1
Maximum memory pitch: 262144 bytes
Texture alignment: 256 bytes
Clock rate: 0.80 GHz
Concurrent copy and execution: Yes
Run time limit on kernels: No
Integrated: Yes
Support host page-locked memory mapping: Yes
Compute mode: Default (multiple host threads can use this device simultaneously)

Test PASSED

Press ENTER to exit...

Co oznacza, że mam urządzenie "CUDA Capable". Następny test na porozumiewanie się urządzenia z systemem: ./bandwidthTest

Running on......
device 0:GeForce 8400M GS
Quick Mode
Host to Device Bandwidth for Pageable memory
.
Transfer Size (Bytes) Bandwidth(MB/s)
33554432 856.9

Quick Mode
Device to Host Bandwidth for Pageable memory
.
Transfer Size (Bytes) Bandwidth(MB/s)
33554432 895.4

Quick Mode
Device to Device Bandwidth
.
Transfer Size (Bytes) Bandwidth(MB/s)
33554432 4214.5

&&&& Test PASSED

Press ENTER to exit...

Zatem teoretycznie wszystko dobrze, ale nie mogę uruchomić żadnego przykładu. Najczęstszym błędem jest "cudaSafeCall() Runtime API error in file , line 51 : feature is not yet implemented." Wynika z tego, że CUDA 2.2 nie da rady działać na obecnych sterownikach i będę musiał walczyć z tymi ściągniętymi ze strony NVIDIA.

EDIT:
Z ostatniej chwili: udało mi się zainstalować sterowniki na XP. Pomogło wybranie sterowników dla notebooków. Pozwala to wykorzystywać CUDA w wersji 2.2.

Fstab i montowanie podkatalogów

2009-09-18T10:27:00.004+02:00

Postanowiłem dzisiaj, że dysk z XPkiem będzie się montował przy każdym starcie systemu. Docelowo chcę ujednolicić katalogi ściągania, obrazów, kodu itd., tak abym nie musiał przeszukiwać raz dysku z XP, raz dysku z Ubuntu w poszukiwaniu tego czym się akurat zajmuję. Na przykład mogę pracować nad sprawozdaniem w OO.org w Windowsie i w Ubuntu, ale nie mam dostępu do partycji ext3 z Windowsa. Dlatego podlinkuję sobie Moje Dokumenty do /home/daniel, a w tym celu potrzebuję odpowiednich wpisów w fstab.

Było z tym trochę problemu, ale nic czego nie załatwiłoby użycie wyszukiwarki.
Po kolei:
Można wpisać "sudo fdisk -l" aby dostać listę wszystkich dysków. Jako że mój dysk jest wewnętrzny i nie ma szansy, aby zmieniła się jego nazwa, to mógłbym odwołać się właśnie po niej: /dev/sda1/. Jednak inne dyski w fstab odwołują się do UUID dysku, więc ja też tak zrobię. Taka mała dygresja: mam dwa dyski zewnętrzne i pendrive'a. Mogę kazać im montować się nie w katalogu /media/disk i /media/disk1, ale na przykład w katalogu /media/czarny i /media/srebrny w zależności od tego który z nich jest podłączony.
Aby uzyskać UUID dysku należy wpisać:
sudo vol_id /dev/sda1
W moim przypadku dostałem:
ID_FS_UUID=5E543A8F543A69C3
Teraz trzeba otworzyć fstab:
gksu gedit /etc/fstab
i na końcu dodać:
#dysk z XP
UUID=5E543A8F543A69C3 /media/XP ntfs-3g defaults 0 0
Ja oddzielam kolumny tabem, ale można też spacją. Po kolei są to: identyfikator dysku, punkt montowania, system plików, opcje i kolejne jakieś 2 parametry, które przeważnie są zerami. Coś związanego z częstotliwością jakiejś czynności, ale nie wiem jakiej bo nie zagłębiałem się w temat. ;) Alternatywnym wpisem może być:
/dev/sda1 /media/XP ntfs-3g defaults 0 0
Tutaj odwołuję się do dysku po jego nazwie. Więcej informacji po czym jeszcze można się odwoływać znajduje się w internecie.
Na koniec zapisujemy zmiany i wracamy do konsoli. Teraz trzeba dać znać systemowi, żeby przemontował wszystkie dyski zgodnie z nowym plikiem fstab:
sudo mount -a
No i błąd:
mount: mount point /media/XP does not exist
Zatem trzeba naprawić to niedopatrzenie:
sudo mkdir /media/XP
Tym razem sudo mount -a nie wyrzuca żadnych komunikatów i można cieszyć się zamontowanym dyskiem.

Teraz przykładowe dowiązanie katalogu z obrazami:
/media/XP/Documents\040and\040Settings/Yelonek/Moje\040dokumenty/Moje\040obrazy /home/daniel/Obrazy none bind 0 0
Co to za \040? Otóż jeśli w nazwie występuje spacja, to zamiast niej dajemy odpowiadający jej "escape sequence". Jest to wartość 32(kod ANSI dla spacji) w systemie ósemkowym. Gdyby wstawić tam zwykłą spację, to po wywołaniu sudo mount -a dostaniemy komunikat, że "fstab is bad", bo program uzna spację za przejście do następnej kolumny.

Ponowne wywołanie sudo mount -a spowoduje, że w katalogu ~/Obrazy zobaczymy plik z Moje obrazy z dysku XP. Ale moment! Przecież w Obrazy miałem kilka innych plików na dysku Ubuntu, a teraz ich nie widać. No tak, nie widać ich, bo teraz Obrazy są dowiązane do Moje obrazy. Nie wszystko jednak stracone. Co zatem zrobić? Można skasować linijkę odpowiadającą za to dowiązanie i zresetować komputer... Ale to bardzo niewygodne. :] Dlatego należy wpisać:
sudo umount ~/Obrazy
i znowu widzimy stare pliki. Można je przenieść do katalogu Moje obrazy i ponownie dowiązać katalogi. Teraz już wszystko jest tak jak być powinno.

* PS ~ (tylda) oznacza katalog domowy użytkownika, czyli w moim przypadku /home/daniel

Sqlite - wprawka

2009-09-16T19:06:00.021+02:00

Zainteresowałem się ostatnio kolejnym tematem, a mianowicie SQL. Do tej pory słyszałem, że to potężne narzędzie do zarządzania bazami danych, ale jakoś nigdy nie wziąłem się za siebie i nie przysiadłem do tego. Ostatnio mam trochę wolnego czasu, więc zajrzałem na stronę: www.w3schools.com gdzie znajduje się wiele materiałów o SQL i to w bardzo przystępnej formie. Po przejściu podstaw miałem okazję wystosować parę zapytań do treningowej bazy danych. Okazało się to łatwiejsze niż przypuszczałem.

Jako bibliotekę obsługującą bazę danych wybrałem sobie Sqlite3. Jest dość nieskomplikowana i nie trzeba stawiać żadnych serwerów SQL czy coś takiego. Instaluje się ją poleceniem:
sudo apt-get install libsqlite3-0 libsqlite3-dev
Bardzo prawdopodobne, że libsqlite3-0 będzie już w systemie gdyż korzysta z niej na przykład Firefox.

Teraz należy stworzyć nowy projekt, dodać do linkera /usr/lib/libsqlite3.so i napisać trochę kodu:

/* 
 * File:   main.cpp
 * Author: daniel
 *
 * Created on 14 wrzesień 2009, 22:24
 */

#include <stdlib.h>
#include <sqlite3.h>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>
using std::cout;
using std::endl;

/*
 * 
 */

//pokazuje wiadomość błędu jeśli istnieje, a jeśli nie to wartość kodu
void handleReturnCode(int returnCode, char* ErrorMsg = NULL) {
    if (returnCode != SQLITE_OK) {
        if (ErrorMsg != NULL) {
            std::cout << ErrorMsg << std::endl;
            sqlite3_free(ErrorMsg);
        } else {
            std::cout << "Return code: " << returnCode << std::endl;
        }
    }
}

//struktura przechowująca dane o osobie
struct sOsoba {
    std::string imie;
    std::string nazwisko;
    int rokUrodzenia;

    sOsoba(const char* p_imie, const char* p_nazwisko, const int p_rokUrodzenia) {
        imie = p_imie;
        nazwisko = p_nazwisko;
        rokUrodzenia = p_rokUrodzenia;
    }
};

int main(int argc, char** argv) {
    sqlite3* db;
    int returnCode;

    cout << "Otwieranie bazy danych: " << endl;
    returnCode = sqlite3_open("test2.db", &db);
    if (returnCode != 0) std::cout << returnCode << std::endl;
    char* ErrorMsg;

    cout << "Usunięcie tabeli tab" << endl;
    returnCode = sqlite3_exec(db, "drop table if exists tab", NULL, NULL, &ErrorMsg);
    handleReturnCode(returnCode, ErrorMsg);

    cout << "Utworzenie tabeli tab" << endl;
    returnCode = sqlite3_exec(db,
                                 "create table tab (imie string, nazwisko string,
                                 rokUrodzenia integer);",
                               NULL, NULL, &ErrorMsg);
    handleReturnCode(returnCode, ErrorMsg);

    cout << "Utworzenie listy osob" << endl;
    std::vector<sOsoba> listaOsob;
    listaOsob.push_back(sOsoba("Donald", "Tusk", 1957));
    listaOsob.push_back(sOsoba("Lech", "Kaczyński", 1949));
    listaOsob.push_back(sOsoba("Jarosław", "Kaczyński", 1949));
    listaOsob.push_back(sOsoba("Grzegorz", "Napieralski", 1974));
    listaOsob.push_back(sOsoba("Waldemar", "Pawlak", 1959));
    listaOsob.push_back(sOsoba("Grzegorz", "Schetyna", 1963));

    //Dodawanie kolejnych nazwisk
    std::vector<sOsoba>::iterator it = listaOsob.begin();
    while (it != listaOsob.end()) {
        cout << "Dodawanie " << it->imie<< " " << it->nazwisko << endl;
        std::stringstream query;
        query << "insert into tab values (\"" 
        << it->imie 
        <<"\", \""
        << it->nazwisko 
        << "\", " 
        << it->rokUrodzenia <<");";
        returnCode = sqlite3_exec(db, query.str().c_str(), NULL, NULL, &ErrorMsg);
        handleReturnCode(returnCode, ErrorMsg);
        it++;
    }

    char** result;
    int nRows, nCols;
    //zapytanie o polityków którzy urodzili się po 1960
    sqlite3_get_table(db, 
                         "select nazwisko, rokUrodzenia
                          from tab
                          where rokUrodzenia > 1960 
                          order by rokUrodzenia asc",
                        &result, &nRows, &nCols, &ErrorMsg);
    cout << "Result: [" << nRows << ", " << nCols << "]" << endl;
    //zerowy wiersz to nagłówki tabeli, a reszta to wyniki, więc rzędów jest nRows + 1
    for (int i = 0; i <= nRows; i++) { 
        for (int j = 0; j < nCols; j++) {
            cout << result[i * nCols + j] << "\t";
            if (j > 0 && i>0) {
                //dla sprawdzenia czy da się łatwo skonwertować liczbę
                int rok = atoi(result[i * nCols + j]);
                cout << "\t skonwertowany rok: " << rok;
            }
        }
        cout << endl;
    }
    //zwalnianie pamięci przydzielonej dla tabeli
    sqlite3_free_table(result);

    cout << "Zamykanie bazy danych" << endl;
    sqlite3_close(db);
    //wywołanie polecenia systemowego eksportującego tabelę tab do pliku csv
    system("sqlite3 -csv test2.db \"select * from tab;\" > wyjscie.csv");
    cout << endl;
    //wyświetlenie zawartości pliku csv w konsoli
    system("cat wyjscie.csv");

    return (EXIT_SUCCESS);
}

OpenCV

2009-07-23T00:17:00.027+02:00

OpenCV to prawdopodobnie najbardziej znana biblioteka związana z komputerową "wizją". Chodź od dłuższego czasu nic w niej się nie dzieje, to wydaje się nie tracić na popularności. Miałem okazję zapoznać się z nią na laboratorium przedmiotu Sensoryka i Systemy Wizyjne. Na zajęciach wykorzystywaliśmy Visual C++, a teraz chciałbym móc pracować z tą biblioteką w NetBeans na Ubuntu 8.04. Okazało się, że chęć tę bardzo łatwo przekuć w czyn. Oto co należy zrobić:
Nie zamierzam instalować ostatniej wersji z CVS czy SVN. Chcę wykorzystać to co jest w repozytorium Ubuntu. Mamy tam dostępną wersję 1.0.0. Aby dowiedzieć się jakie są nazwy paczek należy wpisać:

apt-cache search opencv

. W odpowiedzi dostaniemy:

libcv-dev - development files for libcv
libcv1 - computer vision library
libcvaux-dev - development files for libcvaux
libcvaux1 - computer vision extension library
libhighgui-dev - development files for libhighgui
libhighgui1 - computer vision GUI library
opencv-doc - OpenCV documentation and examples
python-opencv - Python bindings for the computer vision library

Nie potrzebujemy dokumentacji, która jest dostępna tutaj (dla wersji 1.0) lub tutaj (dla wersji 1.1). W repozytorium znajduje się wersja 1.0. Wydaje mi się, że nie różni się ona zbytnio od 1.1, ale nie przeglądałem changeloga, więc nie wiem na pewno. W każdym razie dokumentacja jest w internecie, a Pythona nie zamierzam używać.
Zatem instalujemy paczki:

sudo apt-get install libcv1 libcv-dev libcvaux1 libcvaux-dev libhighgui1 libhighgui-dev

W odpowiedzi dostaniemy:

Czytanie list pakietów... Gotowe
Budowanie drzewa zależności
Odczyt informacji o stanie... Gotowe
Zostaną zainstalowane następujące dodatkowe pakiety:
libatk1.0-dev libavcodec-dev libavformat-dev libavutil-dev libcairo2-dev libdc1394-13-dev libexpat1-dev libfontconfig1-dev libfreetype6-dev libglib2.0-dev libgsm1-dev libgtk2.0-dev libice-dev libjpeg62-dev libogg-dev libpango1.0-dev libpixman-1-dev libpng12-dev libpthread-stubs0 libpthread-stubs0-dev libraw1394-dev libsm-dev libtheora-dev libtiff4-dev libtiffxx0c2 libvorbis-dev libx11-dev libxau-dev libxcb-xlib0-dev libxcb1-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxft-dev libxi-dev libxinerama-dev libxrandr-dev libxrender-dev x11proto-composite-dev x11proto-core-dev x11proto-damage-dev x11proto-fixes-dev x11proto-input-dev x11proto-kb-dev x11proto-randr-dev x11proto-render-dev x11proto-xext-dev x11proto-xinerama-dev xtrans-dev zlib1g-dev
Sugerowane pakiety:
libcairo2-doc libglib2.0-doc libgtk2.0-doc imagemagick libpango1.0-doc
libraw1394-doc
Zostaną zainstalowane następujące NOWE pakiety:
libatk1.0-dev libavcodec-dev libavformat-dev libavutil-dev libcairo2-dev libcv-dev libcv1 libcvaux-dev libcvaux1 libdc1394-13-dev libexpat1-dev libfontconfig1-dev libfreetype6-dev libglib2.0-dev libgsm1-dev libgtk2.0-dev libhighgui-dev libhighgui1 libice-dev libjpeg62-dev libogg-dev libpango1.0-dev libpixman-1-dev libpng12-dev libpthread-stubs0 libpthread-stubs0-dev libraw1394-dev libsm-dev libtheora-dev libtiff4-dev libtiffxx0c2 libvorbis-dev libx11-dev libxau-dev libxcb-xlib0-dev libxcb1-dev libxcomposite-dev libxcursor-dev libxdamage-dev libxdmcp-dev libxext-dev libxfixes-dev libxft-dev libxi-dev libxinerama-dev libxrandr-dev libxrender-dev x11proto-composite-dev x11proto-core-dev x11proto-damage-dev x11proto-fixes-dev x11proto-input-dev x11proto-kb-dev x11proto-randr-dev x11proto-render-dev x11proto-xext-dev x11proto-xinerama-dev xtrans-dev zlib1g-dev
0 aktualizowanych, 59 nowo instalowanych, 0 usuwanych i 0 nieaktualizowanych.
Konieczne pobranie 0B/17,3MB archiwów.
Po tej operacji zostanie dodatkowo użyte 62,9MB miejsca na dysku.
Czy chcesz kontynuować [T/n]?

Odpowiadamy, że oczywiście tak. Jak widać instaluje się mnóstwo innych paczek - z tego co widać jedne służą do obsługi różnych formatów obrazów i filmów, a inne do obsługi interface'u (np libgtk2.0-dev). Gdy ta czynność się zakończy pliki nagłówkowe będą zainstalowane w /usr/include/opencv, a biblioteki w /usr/lib.
Zaczynamy teraz pracę z NetBeans:
Tworzymy nowy projekt typu "C/C++ Application". Nadajemy mu nazwę "openCV Hello World".
Mamy czysty projekt z pojedynczym plikiem main.cpp. Teraz trzeba powiedzieć kompilatorowi, gdzie znajdują się biblioteki, które ma dołączyć do projektu. Należy kliknąć prawym przyciskiem w oknie "Projects" na obecnym projekcie i przejść do jego właściwości (Properties). Po wybraniu "Linker" dodać ścieżkę do bibliotek (Additional Library Directories): /usr/lib oraz biblioteki (Libraries): cv, cvaux, highgui.

Teraz możemy napisać trochę kodu. Oto propozycja:

#include <stdlib.h>
#include "opencv/cv.h"
#include "opencv/cvaux.h"
#include "opencv/highgui.h"

/*
 * 
 */
int main(int argc, char** argv) {
    //tworzenie zmiennej przechowującej obraz i załadowanie obrazu z pliku, 0 = czarno-biały
    IplImage* obraz = cvLoadImage("/home/daniel/Obrazy/hello.jpg", 0);
    //utworzenie okna nazwanego Hello World
    cvNamedWindow("Hello world");
    //wyświetlenie obrazu
    cvShowImage("Hello world", obraz);
    //oczekiwanie na wciśnięcie klawisza, domyślnie 0 = nieskonczonosc
    cvWaitKey();
    //zamknięcie okna, można użyć cvDestroyAllWindows()
    cvDestroyWindow("Hello world");
    //zwalniamy pamięć zajętą przez zmienną obraz
    cvReleaseImage(&obraz);
    return (EXIT_SUCCESS);
}

Efekt po wciśnięciu F6:

LaTeX

2009-07-19T23:23:00.007+02:00

Przeglądałem dziś sobie jakie programy są dostępne przez "Dodaj/Usuń programy" w Ubuntu i w oczy rzucił mi się Texmaker. Zainstalowałem go i próbowałem stworzyć prosty dokument. Skonfigurowałem sobie opcję "Quick build", aby po naciśnięciu F1 otrzymać gotowy plik PDF. Niestety dostawałem błędy w stylu "błąd podczas wykonywania polecenia", "nie istnieje plik dziennika (log file)". Swego czasu próbowałem już skompilować dokument na Windowsie i poległem. Za to w trakcie prób rozwiązania problemu natrafiałem na instrukcję dla Linuksów. Było tam wspomniane o poleceniach typu pdflatex. Sprawdziłem w terminalu czy mam coś takiego zainstalowanego. Okazało się, że nie, więc trzeba je doinstalować. Tylko jak się nazywa ta paczka. Poszukiwania (apt-cache search latex | less) doprowadziły do tego, że w oczy rzuciła mi się duża ilość paczek z "texlive" na początku. Tylko jak będzie się nazywać główny pakiet? Pewnie texlive. Polecenie apt-cache show texlive upewniło mnie, że zgadłem:

This metapackage provides a decent selection of the TeX Live packages which should suffice for the most common tasks.

Zainstalowałem zatem paczkę texlive wraz z texlive-lang-pl, gdyż uznałem, że ta druga może się przydać. Po tym wszystkim odinstalowałem i zainstalowałem ponownie Texmakera.
Teraz ponownie skonfigurowałem Quick Build, żeby tworzyło pdfa. Następnie przy wykorzystaniu "Quick Wizard" stworzyłem następujący dokument:

\documentclass[10pt,a4paper]{article}
\usepackage[latin2]{inputenc}
\author{Imię Nazwisko}
\title{O pisaniu w LaTeXu}
\begin{document}
Treść dokumentu
\end{document}

Zapisałem do pliku /home/daniel/Dokumenty/LaTeX/pierwszy. To był mój pierwszy błąd- pliki należy zapisywać koniecznie z rozszerzeniem .tex. Udało mi się skompilować tekst do pdfa, ale zamiast ź otrzymałem jakieś L z zawijasami. Zacząłem kombinować z różnymi paczkami:

\usepackage[polish]{babel}
\usepackage[]{polski}
\usepackage[OT4]{polski}
\usepackage[T1]{polski}
\usepackege[MeX]{polski}

Za każdym razem dostawałem inny efekt. A to zamiast ź było ij, a to w ogóle ź zostało pominięte. Przez pewien czas pomyślałem, że może brakuje mi czcionek, ale wersja zapisu ź z akcentem działała (wpisanie \'z również powoduje wyświetlenie ź).
Wtedy trafiłem na stronę morony.pl, gdzie opisywano instalację paczek dla Windows. Wykorzystałem przykładowy plik LaTeXa:

\documentclass[11pt,a4paper]{article}
\usepackage{polski}
\usepackage[cp1250]{inputenc}
\title{\LaTeX}
\author{Marcin Polkowski}
\begin{document}
\maketitle
\section{Matematyka}
$$f(x)=\left\{
\begin{array}{ccc}
\sin{x}&\mbox{dla}&x<0\\0&\mbox{dla}&x=0\\\cos{x}&\mbox{dla}&x>0
\end{array}
\right.$$
\section{Polskie krzaczki}
Późną nocą grań olśniła księżyca jasność.
Pchnąć w tę łódź jeża lub ośm skrzyń fig.
Różowy słoń ma usiąść na tępych gwoździach
\end{document}

Jako, że używam Ubuntu zmieniłem windowsowe kodowanie cp1250 na latin2. Nikt nie potrafi wyobrazić sobie mojego zdziwienia, gdy powyższy tekst skompilował się do pięknego pdfa. Na razie służy mi jako szablon do tworzenia kolejnych dokumentów. Może jak kiedyś zrozumiem na czym polega ustawianie opcji poszczególnych paczek to będę pisał preambułę sam. Na razie jest to dla mnie czarna magia i to rozwiązanie jest wystarczająco dobre.

Taka drobnostka, co do której nie jestem pewien czy ma znaczenie: w Options->Configure Texmaker->Editor ustawiłem kodowanie edytora na ISO-8859-2

Pomocą służyły mi dwa główne opracowania:
Nie za krótkie wprowadzenie do systemu LaTeX oraz Jak szybko zacząć pisać w LaTeX Pomocna również była strona Grupy Użytkowników Systemu Tex (w skrócie GUST).

NetBeans i C/C++

2009-07-13T11:27:00.008+02:00

Jako że będę niedługo potrzebował umiejętności pisania programów w C z Linuksem jako docelową platformą postanowiłem zrobić coś w tym kierunku. Korzystać będę z Ubuntu 8.04 LTS.
Rozpocząłem od przejrzenia książki Beginning Linux Programming z której to dowiedziałem się jak kompilować programy z pomocą linii komend. Zdaję sobie sprawę, że niektórzy to lubią i ma to "oldskulowy" urok, ale jednak cenię sobie wyżej wygodę niż bajery.
Swego czasu dużo dobrego słyszałem o NetBeans i postanowiłem je wypróbować. Jest to środowisko programistyczne, które można wykorzystać do programowania w wielu językach (pierwotnie była to chyba Java). Mnie interesowała wersja dla C/C++, toteż ściągnąłem odpowiedni instalator ze strony http://www.netbeans.org/downloads/index.html. Na stronie dostępne są też tutoriale dotyczące obsługi tego środowiska.
Instalację przeprowadzałem już jakiś czas temu, więc nie pamiętam wszystkich szczegółów, ale wydaje mi się, że brakowało tam kompilatora C++ - wystarczy doinstalować g++ na przykład za pomocą Synaptica i w Narzędzia=>Opcje=>C/C++=>Build Tools w okienku C++ Compiler: wpisać /usr/bin/g++. Od teraz można już działać bez przeszkód.
Moje dotychczasowe doświadczenia z programowaniem w C++ to głównie 2 programy: MS Visual Studio i C++ Builder z Borlanda. Ten drugi to już zabytek, więc nie ma co porównywać. Jak na tak stary program jest bardzo wygodny, ale znalezienie jakiejś instalki w internecie, a do niej jeszcze klucza rejestracyjnego to już nie jest zabawne. Acha, żeby działał debugger należy się zarejestrować. Swojego czasu ominąłem rejestrację i zachodziłem w głowę dlaczego debugger, który kiedyś działał bez problemu, teraz w ogóle nie chce tego robić. Wracając jednak do sedna - porównanie będzie odbywać się między VS, a NetBeans.
Jest kilka funkcji, które w IDE są przeze mnie wymagane. Działający debugger to podstawa - byłem bardzo mile zaskoczony, gdy zobaczyłem w NetBeans, że mogę bez problemu włączyć uruchomienie programu linia po linii wraz z poglądem zmiennych, dodawanie watchów itp. Bardzo miłe zaskoczenie.
Pisząc program bardzo pomocne są podpowiedzi nazw zmiennych i funkcji. Zarówno w VS, jak i NB mamy je dostępne pod ctrl+spacja, ale w tym drugim mamy to bardziej rozbudowane - podpowiadane są też nazwy plików nagłówkowych, dyrektywy preprocesora, rozwinięcia kodu (napisz "for", naciśnij ctrl+spacja, a dostaniesz podpowiedź "fori", które po wybraniu rozwija się w pętlę for ze zmienną i. To jeszcze nie koniec - zmienna i jest w polu, które uaktywnia się po rozwinięciu. Możemy wpisać dowolną nazwę zmiennej, a zastąpi ona i we wszystkich miejscach w pętli. Coś takiego dostępne w VS jest chyba tylko wtedy gdy piszemy w C# (albo może wszystko pisane przy użyciu CLR ma taką właściwość). Nie udało mi się za to znaleźć jak włączyć podpowiedź listy parametrów w funkcji, czyli odpowiednik Visualowego ctrl+shift+spacja, ale to pewnie jeszcze gdzieś to się przede mną ukrywa.
Co jeszcze mi się podoba w NB, a nie widziałem w VS to ilustracja czasu wykonywania programu i zużycia pamięci. Wciskamy F6, aby uruchomić nasz projekt i widzimy jak rośnie czy spada rozmiar naszego programu. Inny przykład to kombinacja alt+shift+f, która ładnie formatuje kod - wstawia spację między operatorami, wyrównuje wszystko, generalnie sprawia, że kod staje się czytelny.
Dodatkowo mamy integrację z CVS, SVN, Kenai i nie wiem nawet czym jeszcze. Trochę czasu minie zanim odkryję wszystkie funkcje. Wrażenia z użytkowania są niezmiernie zadowalające - obecnie staram się rozwiązać jak najwięcej zadań z Projektu Euler o którym napiszę więcej wkrótce.

Taki myk, żeby były polskie litery w Totemie

2008-06-19T21:59:00.009+02:00

Wiele osób narzeka na brak polskich znaków przy odtwarzaniu filmów w Ubuntu 8.04. Jedni sugerują, żeby po prostu zmienić kodowanie w Totemie na CP 1250. Takie jest kodowanie większości plików z napisami.

Istnieje drugi sposób:
Instalujemy pakiet "recode" w terminalu

sudo apt-get install recode

lub przez Menedżer pakietów Synaptic.

Nie będziemy oczywiście za każdym razem wywoływać polecenia recode z terminala, dlatego:
System->Preferencje->Centrum Sterowania->Nautilus Actions Configuration

Label ( nazwa ): Zmień na UTF8
Tooltip ( tekst podpowiedzi ): Konwersja z CP1250 do UTF8
Icon ( ikona ): według uznania, ja używam gtk-find-and-replace
Action:
Path (ścieżka): recode
Parameters: CP1250..UTF-8 %M

Conditions ( warunki ): Wybieramy czysty tekst: text/plain z rozszerzeniem *.txt dla pojedynczych plików.

Trzecia zakładka odpowiada za zakres dostępności polecenia. Ja zaznaczyłem tylko lokalne pliki.

Klikamy, że jest ok. Teraz możemy kliknąć prawym przyciskiem na jakiś plik z napisami i do wyboru mamy naszą nowostworzoną opcję.
Oczywiście ten myk nie zadziała jeśli początkowe kodowanie pliku nie było CP 1250. Według tego wzoru można stworzyć dowolną nową opcję konwersji. W razie problemów man recode odpowie na Wasze pytania.

Lab EiUA

2008-03-14T01:11:00.003+01:00

W tym tygodniu na laboratorium Elementów i Urządzeń Automatyki zaprogramowaliśmy 4 siłowniki pneumatyczne w taki sposób, że cyklicznie przepychają kulkę przez pewien przygotowany wcześniej tor. Oprócz tego, że kulka porusza się po wymyślonej przez nas trajektorii postawiliśmy sobie dodatkowo warunek cyklicznej pracy układu oraz urozmaicenia wizualnego całego procesu.
Program pisaliśmy w języku drabinkowym, który jest dla nas pewną nowością. Trochę trudno się połapać co z czym i do czego podłączyć. Ostatecznie wymyśliłem metodę opisywania układu siłowników 4 bitowym kodem. Przejście ze stanu do stanu wiąże się z odczekaniem pewnego czasu, co jest realizowane za pomocą timerów.
Brakowało nam przycisku startowego, a wpisywanie wartości do pamięci za pomocą środowiska programistycznego nie było zbyt eleganckie. Wodzu wymyślił więc sposób na zgrabną pętlę. Pierwszy timer załączamy negacją ostatniego. W ten sposób zawsze gdzieś jest 1, żeby wystartował timer. Karol za to wymyślił jak zdynamizować nasz układ. Zmierzyliśmy czas po jakim kulka przeturla się przez rynnę i zacznie spadać prawym szybem. Wtedy startuje siłownik i unosi ją do góry. Widać to w pierwszych sekundach filmu.