elettrofonesi

Pdnoo

2011-08-04T15:50:00.006+02:00

Pdnoo is a PDa port for caanoo.
PDa is a Pd clone for PDAs.
So with this port you can run Pd on your caanoo.

All needed files are downloadable on OpenHandhelds.org

Here is a copy of the included readme:

pdnoo
a PDa port for caanoo

pdnoo is composed by two softwares:
1. PDa (Pure Data Anywhere)
2. A 'proof of concept' frontend written in Bennu

PDa was compiled with the official GPH toolchain, using a modified makefile
(included into this distrubution) and without graphical support.
I added these lines to PDa makefile:

====================line40=====================
# CAANOO toolchain

ifeq ($(CC), arm-gph-linux-gnueabi-gcc)
pd_LDFLAGS += -elf2flt -static -static-libgcc
pd_LIBS = -lm -lpthread
pd_DEFINES +=  -D__linux__ -Dfork=getpid
extra_DEFINES += -D__linux__ -Dfork=getpid
endif

====================line128====================
caanoo:
        make pd_SRC="$(pd_SRC) $(extra_SRC)" DEFINES="-DPD -DUNIX -DSTATIC" CC="arm-gph-linux-gnueabi-gcc"\
             pd pd-watchdog $(BIN_DIR)/pdsend \
             $(BIN_DIR)/pdreceive

I also had to delete all esd related stuff.

To make PDa useful, you need some kind of frontend which have to speak with
pd in some way.
If you put a [netreceive] object into your pd-patch, you can send TCP
packets to pd.
This packets must follow the FUDI protocol, that can be easily implemented
into you custom code if you wish. A more simple approach is to call 'pdsend'
executable (included) that will make the job for you ('pdreceive' is also
included).

You can write a frontend in your favourite language, I made one with Bennu,
because its caanoo support is good and it is a very simple language.
You can read the source of my code by opening 'pdnoo.prg' with your favourite
editor.
'pdnoo.gpe' is a simple script that starts pd, compiles and starts the bennu
application.
To make everything work you have to install the bennu-runtime by coping
'bgd-runtime' directory into the same directory where 'pdnoo' directory and
'pdnoo.gpe' file are.
If you whish to install the runtime somewhere else, please edit the PATH lines
of 'pdnoo.gpe' properly.

Please condider my example frontend as 'proof of concept', its work is to read
touchscreen's coordinates and to send them to pd through 'pdsend'. It is not
perfect and right now to stop it you need to reset your caanoo.

If you are interested in updates or other things related to pdnoo please
visit my blog, where I will put my future improvements.
http://elettrofonesi.blogspot.com

If you are interested in the source code of PDa go here:
http://pd-anywhere.sourceforge.net

To read about and download Bennu go here:
http://www.bennugd.org

You can find the same GPH toolchain I used here:
http://git.fungp.com

If you do not have a caanoo but a gp2x here you can find a very similar thing
that actually inspired me:
http://mccormick.cx/projects/gp2xPd/


If you do not know Pd, please visit this page:
http://puredata.info

To learn more about FUDI protocol:
http://wiki.puredata.info/en/FUDI

I hope that this piece of software can be useful to musical experimenters or
to game developers who want to implement more dynamic sounds than a static
collection of waves.
Have fun with pdnoo, and please share your patch/code!

Enjoy!

Life without flash: tube script improved

2011-03-09T19:09:00.003+01:00

An improved version of my tube script.
With this edit URLs is not needed.
It extracts the VIDEO_ID and generates the URL.
It works with youtbe and vimeo only.

Call it in this way:

tube "http://vimeo/or/youtube/url"

#!/bin/bash
if [ `echo "$1" | grep vimeo` ]
  then
    VIDEO_ID=`echo "$1" | tr "=" "\n" | grep "&server" | tr -d [:alpha:] | tr -d "&"`
    VIDEO_URL="http://vimeo.com/$VIDEO_ID"
elif [ `echo "$1" | grep youtube` ]
  then
    if [ ! `echo "$1" | grep watch` ]
      then
        VIDEO_ID=`echo "$1" | awk -F "?" '{print $1}' | awk -F "/" '{print $5}'`
    else
        VIDEO_ID=`echo "$1" | awk -F "&" '{print $1}' | awk -F "=" '{print $2}'`
    fi
    VIDEO_URL="http://www.youtube.com/watch?v=$VIDEO_ID"
fi
clive --stream-exec="mplayer -really-quiet %i" -s $VIDEO_URL

Life without flash: How to see youtube/vimeo videos

2011-02-27T12:43:00.003+01:00

I use a script called tube:

#!/bin/bash
clive --stream-exec="mplayer -really-quiet %i" -s $*

syntax is important:

tube http://www.youtube.com/v/VIDEO_ID_NUM
tube http://www.youtube.com/watch?v=VIDEO_ID_NUM
tube http://vimeo.com/VIDEO_ID_NUM

New version here!

Debian on iMac G3 PPC

2011-01-24T13:52:00.000+01:00

I installed Debian squeeze in an old iMac G3 and it rocks!
It was a standard Debian PPC installation, the only difficult thing was to configure Xorg.
I was luky enough to find some xorg.conf on the web, from people with my same problems and I made a collage from two of them.
With the following file I have 1024x768 resolution, 24 bit colors and the rigth keyboardmap.

Section "InputDevice"
 Identifier "Generic Keyboard"
 Driver  "kbd"
 Option  "XkbRules" "xorg"
 Option  "XkbModel" "pc104"
 Option  "XkbLayout" "us"
EndSection

Section "InputDevice"
 Identifier "Configured Mouse"
 Driver  "mouse"
EndSection

Section "Device"
 Identifier "Configured Video Device"
 BusID  "PCI:0:16:0"
EndSection

Section "Monitor"
 Identifier "Configured Monitor"
 Option  "DPMS"
 HorizSync 59-61
  VertRefresh 75-117
EndSection

Section "Screen"
 Identifier "Default Ssdudcreen"
 Monitor  "Configured Monitor"
 DefaultDepth 24
EndSection

AltGr on Debian iBookG4

2011-01-16T17:34:00.003+01:00

I'm tired to press fn, press Alt and then release fn to have an AltGr like key.

For that reason I have added this line to my .xmodmaprc file:

keycode 104 = 0xfe03

Now, Enter key (that is not Return key) between Apple_R key and arrows is mapped as AltGr, and this is a wise thing.

wmiirc

2011-01-10T12:08:00.000+01:00

In the last days I played a lot with my wmiirc file, and now I think it's done.

Customizations:

xmodmap autostart (line 3).
Navigation keys (lines 8 to 12).
Theme (lines 15 to 18).
Status bar with volume, CPU, RAM, swap, battery, time (lines 39 to 46).
Keybindings (lines 130, 140 and from 158 to 167). Note the last one wich opens a custom menu called powerlist used to halt/reboot/sleep/hibernate the machine.
Actionlist menù does not show anymore some custom script inside .wmii directory (lines 239 to 243). Those are scripts to halt/reboot/etc and are called with powerlist.
Powerlist menù, shows only some file inside .wmii directory (lines 245 to 248).

#!/bin/sh -f

xmodmap ~/.xmodmaprc

# Configure wmii

# Configuration Variables
MODKEY=Mod4
UP=Up
DOWN=Down
LEFT=Left
RIGHT=Right

# Colors tuples: "<text> <background> <border>"
WMII_FOCUSCOLORS='#303030 #ecedee #ecedee'
WMII_NORMCOLORS='#959595 #303030 #303030'
WMII_BACKGROUND='#303030'
WMII_FONT='-xos4-terminus-*-*-*-*-*-*-*-*-*-*-*-*'

set -- $(echo $WMII_NORMCOLORS $WMII_FOCUSCOLORS)
WMII_MENU="dmenu -b -fn '$WMII_FONT' -nf '$1' -nb '$2' -sf '$4' -sb '$5'"
WMII_9MENU="wmii9menu -font '$WMII_FONT' -nf '$1' -nb '$2' -sf '$4' -sb '$5' -br '$6'"
WMII_TERM="x-terminal-emulator"

# Column Rules
wmiir write /colrules <<!
/.*/ -> 58+42
!

# Tagging Rules
wmiir write /tagrules <<!
/XMMS.*/ -> ~
/MPlayer.*/ -> ~
/.*/ -> sel
/.*/ -> 1
!

# Status Bar Info
status() {
 echo -n $(amixer get PCM | tail -1 | awk '{print $5}' | tr -d []%) '|' \
  $(uptime | awk '{print $9}' | tr -d , | cut -c 3-4) '|' \
  $(free | head -2 | tail -1 | awk '{print ($3 * 100) / $2}' | cut -c -2) '|' \
  $(free | tail -1 | awk '{print ($3 * 100) / $2}' | cut -c -4) '|' \
  $(ibam --percentcharge | head -1 | awk '{print $3}') '|' \
  $(date | awk '{print $5}' | cut -c -5)
}

# Event processing
#  Processed later by `wmiiloop' and evaled.
#  Duplicate the eval line and replace 'eval' with 'echo' for details.
eventstuff() {
 cat <<'!'
 # Events
 Event Start
  case "$1" in
  wmiirc)
   exit;
  esac
 Event Key
  fn=$(echo "$@" | sed 's/[^a-zA-Z_0-9]/_/g')
  Key_$fn "$@"
 Event CreateTag
  echo "$WMII_NORMCOLORS" "$@" | wmiir create "/lbar/$@"
 Event DestroyTag
  wmiir remove "/lbar/$@"
 Event FocusTag
  wmiir xwrite "/lbar/$@" "$WMII_FOCUSCOLORS" "$@"
 Event UnfocusTag
  wmiir xwrite "/lbar/$@" "$WMII_NORMCOLORS" "$@"
 Event UrgentTag
  shift
  wmiir xwrite "/lbar/$@" "*$@"
 Event NotUrgentTag
  shift
  wmiir xwrite "/lbar/$@" "$@"
 Event LeftBarClick
  shift
  wmiir xwrite /ctl view "$@"
 # Actions
 Action quit
  wmiir xwrite /ctl quit
 Action exec
  wmiir xwrite /ctl exec "$@"
 Action rehash
  proglist $PATH >$progsfile
 Action status
  set +xv
  if wmiir remove /rbar/status 2>/dev/null; then
   sleep 2
  fi
  echo "$WMII_NORMCOLORS" | wmiir create /rbar/status
  while status | wmiir write /rbar/status; do
   sleep 1
  done
 Event ClientMouseDown
  client=$1; button=$2
  case "$button" in
  3)
   do=$(eval $WMII_9MENU -initial "${menulast:-SomeRandomName}" Nop Delete Fullscreen)
   case "$do" in
   Delete)
    wmiir xwrite /client/$client/ctl kill;;
   Fullscreen)
    wmiir xwrite /client/$client/ctl Fullscreen on;;
   esac
   menulast=${do:-"$menulast"}
  esac
 # Key Bindings
 Key $MODKEY-Control-t
  case $(wmiir read /keys | wc -l | tr -d ' \t\n') in
  0|1)
   echo -n $Keys | tr ' ' '\012' | wmiir write /keys
   wmiir xwrite /ctl grabmod $MODKEY;;
  *)
   wmiir xwrite /keys $MODKEY-Control-t
   wmiir xwrite /ctl grabmod Mod3;;
  esac
 Key $MODKEY-space
  wmiir xwrite /tag/sel/ctl select toggle
 Key $MODKEY-d
  wmiir xwrite /tag/sel/ctl colmode sel default
 Key $MODKEY-s
  wmiir xwrite /tag/sel/ctl colmode sel stack
 Key $MODKEY-m
  wmiir xwrite /tag/sel/ctl colmode sel max
 Key $MODKEY-a
  Action $(actionlist | eval $WMII_MENU) &
 Key $MODKEY-p
  sh -c "$(eval $WMII_MENU <$progsfile)" &
 Key $MODKEY-Tab #t
  wmiir xwrite /ctl "view $(tagsmenu)" &
 Key $MODKEY-Return
  eval $WMII_TERM &
 Key $MODKEY-Shift-space
  wmiir xwrite /tag/sel/ctl send sel toggle
 Key $MODKEY-f
  wmiir xwrite /client/sel/ctl Fullscreen toggle
 Key $MODKEY-Shift-c
  wmiir xwrite /client/sel/ctl kill
 Key $MODKEY-Shift-Tab #t
  wmiir xwrite "/client/$(wmiir read /client/sel/ctl)/tags" "$(tagsmenu)" &
 Key $MODKEY-$LEFT
  wmiir xwrite /tag/sel/ctl select left
 Key $MODKEY-$RIGHT
  wmiir xwrite /tag/sel/ctl select right
 Key $MODKEY-$DOWN
  wmiir xwrite /tag/sel/ctl select down
 Key $MODKEY-$UP
  wmiir xwrite /tag/sel/ctl select up
 Key $MODKEY-Shift-$LEFT
  wmiir xwrite /tag/sel/ctl send sel left
 Key $MODKEY-Shift-$RIGHT
  wmiir xwrite /tag/sel/ctl send sel right
 Key $MODKEY-Shift-$DOWN
  wmiir xwrite /tag/sel/ctl send sel down
 Key $MODKEY-Shift-$UP
  wmiir xwrite /tag/sel/ctl send sel up
 Key $MODKEY-F7
  thunar &
 Key $MODKEY-F8
  iceweasel &
 Key $MODKEY-F9
  claws-mail &
 Key XF86AudioMute
  amixer sset PCM 0 &
 Key XF86PowerDown
  Action $(powerlist | eval $WMII_MENU) &
!
 for i in 0 1 2 3 4 5 6 7 8 9; do
  cat <<!
 Key $MODKEY-$i
  wmiir xwrite /ctl view "$i"
 Key $MODKEY-Shift-$i
  wmiir xwrite /client/sel/tags "$i"
!
 done
}

# WM Configuration
wmiir write /ctl << EOF
font $WMII_FONT
focuscolors $WMII_FOCUSCOLORS
normcolors $WMII_NORMCOLORS
grabmod $MODKEY
border 1
EOF

export WMII_MENU WMII_9MENU WMII_FONT WMII_TERM
export WMII_FOCUSCOLORS WMII_SELCOLORS WMII_NORMCOLORS

# Feed events to `wmiiloop' for processing
eval "$(eventstuff | sed 's/^[ ]//' | { . wmiiloop; })"

echo "$Keys" | tr ' ' '\n' | wmiir write /keys

# Functions
Action() {
 action=$1; shift
 if [ -n "$action" ]; then
  Action_$action "$@" \
  || conf_which $action "$@"
 fi
}

proglist() {
 paths=$(echo "$@" | sed 'y/:/ /')
 ls -lL $paths 2>/dev/null \
  | awk '$1 ~ /^[^d].*x/ && NF > 2 { print $NF }' \
  | sort | uniq
}

# Misc
progsfile="$WMII_NS_DIR/.proglist"
Action status &
proglist $PATH >$progsfile &

xsetroot -solid "$WMII_BACKGROUND" &

# Setup Tag Bar
seltag="$(wmiir read /tag/sel/ctl 2>/dev/null)"
wmiir ls /lbar |
while read bar; do
 wmiir remove "/lbar/$bar"
done
wmiir ls /tag | sed -e 's|/||; /^sel$/d' |
while read tag; do
 if [ "X$tag" = "X$seltag" ]; then
  echo "$WMII_FOCUSCOLORS" "$tag" | wmiir create "/lbar/$tag" 
 else
  echo "$WMII_NORMCOLORS" "$tag" | wmiir create "/lbar/$tag"
 fi
done

# More functions
tagsmenu() {
        wmiir ls /tag | sed 's|/||; /^sel$/d' | eval $WMII_MENU
}

actionlist() {
 { proglist $WMII_CONFPATH | grep -v dormi | grep -v iberna | grep -v riavvia | grep -v spegni
  echo -n $Actions | tr ' ' '\012'
 } | sort | uniq
}

powerlist() {
        {       proglist $WMII_CONFPATH | grep -v wmii | grep -v welcome
        } | sort | uniq
}


conf_which() {
 which=$(which which)
 prog=$(PATH="$WMII_CONFPATH" $which $1); shift
 [ -n "$prog" ] && $prog "$@"
}

# Stop any running instances of wmiirc
echo Start wmiirc | wmiir write /event || exit 1

wmiir read /event |
while read event; do
 set -- $event
 event=$1; shift
 Event_$event $@
done 2>/dev/null

Arduino on Debian PPC

2011-01-06T23:18:00.001+01:00

If you want to program Arduino boards in Debian PPC systems you should use arduino-core package, because the arduino package for PPC architecture is broken.
arduino-core is console based, and uses a Makefile to talk to arduino.
Here are the steps you have to follow to use it:

Install arduino-core:

# aptitude install arduino-core

(Remember to do not use aptitude if you usually use apt-get)

Add yourself to uucp and dialout groups:

# gpasswd -a USERNAME uucp
# gpasswd -a USERNAME dialout

dialout is needed to handle /dev/tty* files, uucp seems necessary to work with avrdude.

Now you have to create a Makefile in the same directory whre the .pde file is.
I have an Arduino 2009 with an ATmega329 microcontroller, so my Makefile looks like this:

ARDUINO_DIR = /usr/share/arduino

#TARGET       = CLItest
#ARDUINO_LIBS = LiquidCrystal

MCU          = atmega328p
F_CPU        = 32000000
ARDUINO_PORT = /dev/ttyUSB*

AVRDUDE_ARD_PROGRAMMER = arduino
AVRDUDE_ARD_BAUDRATE   = 57600
#AVRDUDE_ARD_EXTRAOPTS  = -F

include /usr/share/arduino/Arduino.mk

If you use a different microcontroller you should set MCU and F_CPU variables properly.

Now you are ready to program your arduino! Assuming that you want to upload Blink.pde (and that you and your Makefile is in the same directory of Blink.pde), type:

$ make TARGET=Blink
$ make TARGET=Blink upload

The first line creates the .hex file and the second upload it to the board.

For more informations:

nano /usr/share/doc/arduino-core/README.Debian

Allarme! v0.1

2011-01-01T20:02:00.000+01:00

A python alarm for my iBookG4.
It will be useful when I'll leave the desk of the public library looking for a cup of coffee.
It works on my Debian setup and probably will NOT work on your system without modifications.

#!/usr/bin/python

#Allarme! v0.1
#reads /sys/devices/ams/current file (senso) to get informations from the
#internal tilt sensor of Apple's iBooks. It works on my Debian iBookG4 and
#probably it will NOT work on your system without modifications.
#If the variation of one of sensor's values is greater than threshold (thr)
#it will play a sound (not included) located in $HOME/.allarme.wav and
#print a warning message (messo) on the console.
#Copyright 2011 Francesco Aggazio.

#This program is free software: you can redistribute it and/or modify
#it under the terms of the GNU General Public License as published by
#the Free Software Foundation, either version 3 of the License, or
#(at your option) any later version.

#This program is distributed in the hope that it will be useful,
#but WITHOUT ANY WARRANTY; without even the implied warranty of
#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#GNU General Public License for more details.

#You should have received a copy of the GNU General Public License
#along with this program.  If not, see .

import os
import time
import pygame

thr = 2
messo = "Mollami!"
senso = "/sys/devices/ams/current"
home = os.environ['HOME']

inf = open(senso, "r")
incat = inf.readline()
inli = incat.split()
x = int(inli[0])
y = int(inli[1])
z = int(inli[2])

pygame.init()

while 1:
  exx = x
  exy = y
  exz = z
  f = open(senso, "r")
  cat = f.readline()
  li = cat.split()
  x = int(li[0])
  y = int(li[1])
  z = int(li[2])
  dfx = abs(abs(exx) - abs(x))
  dfy = abs(abs(exy) - abs(y))
  dfz = abs(abs(exz) - abs(z))
  if dfx > thr or dfy > thr or dfz > thr:
    print messo
    pygame.mixer.Sound(os.path.join(home, ".allarme.wav")).play()
  #print exx, " ", exy, " ", exz, " : ", x, " ", y, " ", z
  time.sleep(1)

Debian and wmii for my iBookG4

2010-12-27T16:58:00.001+01:00

I just installed debian on my iBookG4, and wmii makes me happy.

Just a few hints for a good configuration:

Install pbbuttonsd for Apple's special buttons and power management.
Install ibam if you need a good battery monitor.
Install cpudyn to reduce power consuption.

And to integrate these new nice features to wmii:

Copy and edit wmiirc:

$ cp /etc/X11/wmii-3.5/wmiirc ~/.wmii-3.5/wmiirc
$ nano ~/.wmii-3.5/wmiirc

Replace this:

# Status Bar Info
status() {
        echo -n $(uptime | sed 's/.*://; s/,//g') '|' $(date)
}

With this:

# Status Bar Info
status() {
        echo -n $(amixer get Master | tail -1 | awk '{print $5}' | tr -d []%) '|' $(ibam --percentcharge | head -1 | awk '{print $3}') '|' $(date | awk '{print $5}' | tr -d ,.)
}

Now you can see in informations about volume, battery charge and time in your status bar.

Create halt, reboot, suspend and hibernate scripts:

~/.wmii-3.5/halt

#!/bin/bash
dbus-send --system --print-reply --dest="org.freedesktop.ConsoleKit" /org/freedesktop/ConsoleKit/Manager org.freedesktop.ConsoleKit.Manager.Stop

~/.wmii-3.5/reboot

#!/bin/bash
dbus-send --system --print-reply --dest="org.freedesktop.ConsoleKit" /org/freedesktop/ConsoleKit/Manager org.freedesktop.ConsoleKit.Manager.Restart

~/.wmii-3.5/sleep

#!/bin/bash
pbbcmd sleep

~/.wmii-3.5/hibernate

#!/bin/bash
pbbcmd hibernate

And do not forget to add yourself to powerdev group and to write a .xinitrc like this:

exec ck-launch-session wmii

Tcl/Tk for R 2.12 on MacOSX 10.4 PPC

2010-11-29T14:33:00.004+01:00

On my previous post I wrote how to install R 2.12 on MacOSX Tiger.
Unfortunately with that method you have to use the ugly X11 terminal to open a Tcl/Tk window, because if you try to load the library with a non X11 native terminal, like MacOSX default Terminal or I-Term, you'll get something like:

> library(tcltk)
Loading Tcl/Tk interface ... done
Warning message:
In fun(...) : no display name and no $DISPLAY environment variable

This error can be avoided setting DISPLAY system variable:

> Sys.setenv=("DISPLAY"=":0")

Now, if you have X11 running, every Tcl/Tk window will call the X11 server, and this is a good thing.

Even if it works, I actually don't like this solution. I want to use MacOSX native Tcl/Tk libraries and Aqua, but i don't find a way that doesn't require R recompilation.

HowTo: R 2.12 on Mac OS X Tiger 10.4 PPC

2010-11-21T13:09:00.011+01:00

R_GUI for Tiger is supported until R 2.10.
If you need R 2.12 the only way is to forget about graphical interfaces.
Manual compilations was a dependencies hell, fortunately there is a port called "r-base" in fink.

Install Xcode from your Mac OS X DVD.
Install X11 from the same DVD.
Install Fink from here.
If you want a GUI install Fink commander from here.
Enable Unstable packages, read how here.
Install "r-base". It will take some time...

Now you have R binary in:

/sw/bin/R

and R Framework in:

/Volumes/YourHD/sw/Library/Framework/R.framework/

I tried to manually compile R.app without luck, it doesn't like a library. If you can do it please tell me how.

Anyway, if you open X11 (Applications/Utilities/X11.app) you have an old school terminal where you can type:

cd /Volumes/YourHD/sw/bin
./R

R version 2.12.0 (2010-10-15)
Copyright (C) 2010 The R Foundation for Statistical Computing
ISBN 3-900051-07-0
Platform: powerpc-apple-darwin8.11.0 (32-bit)

R `e un software libero ed `e rilasciato SENZA ALCUNA GARANZIA.
Siamo ben lieti se potrai redistribuirlo, ma sotto certe condizioni.
Scrivi 'license()' o 'licence()' per dettagli su come distribuirlo.

R `e un progetto di collaborazione con molti contributi esterni.
Scrivi 'contributors()' per maggiori informazioni e 'citation()'
per sapere come citare R o i pacchetti di R nelle pubblicazioni.

Scrivi 'demo()' per una dimostrazione, 'help()' per la guida in linea, o
'help.start()' per l'help navigabile con browser HTML.
Scrivi 'q()' per uscire da R.

>

Nice, it calls an X11 window if you plot() something too!

Just too simple, obviously it's no time to claim victory. Try to compile some external library, probably you will get something like:

MACOSX_DEPLOYMENT_TARGET environment variable set to: 10.1

For which you have to type:

Sys.setenv("MACOSX_DEPLOYMENT_TARGET"="10.4")

before every:

install.packages()

Finally, I find X11 terminal too ugly, I like I-Term, try it!

------------------------------------------------------------------------------------

UPDATE:
Read here how to open Tcl/Tk windows.

Simple Preamp Layout

2010-11-05T16:06:00.007+01:00

Here is a stripboard layout of a simple preamp that you can wire up in ten minutes:

I just tried it with a piezo and it is good enough for me.

Based on this schematic from experimentalists anonymous.

L-catenula

2010-09-27T12:19:00.000+02:00

First attempt to play with L-systems. Lines oriented following Anabaena catenula development rules, degrees influenced by mouseY.

Development rules taken from Algorithmic Beauty of Plants.

void setup()
{
  size(500, 500);
  smooth();
}

void draw()
{
  background(0);
  Ciclo co = new Ciclo("ea", 9, 1);
}

class Ciclo
{
  //w è l'iniziatore
  String w = "";
  //Queste sono le variabili coinvolte nelle trasformazioni.
  //Le pNa sono cio che è, le pNb ciò che sarà.
  String p1a = "a", p1b = "eb";
  String p2a = "e", p2b = "da";
  String p3a = "b", p3b = "a";
  String p4a = "d", p4b = "e";
  //g0 è la generazione attuale, g1 è la generazione futura.
  String g0, g1 = "";
  int n, l;
  //Variabili per il disegno:
  int posX, posY; float posG;
  int lung; float grad;
  
  Ciclo(String _w, int _n, int _l)
  {
    w = _w; n = _n; l = _l;
    //La prima generazione in assoluto consiste nel solo iniziatore w.
    g0 = w;
    posX = mouseX; //width / 2;
    posY = height / 2;
    posG = 0;
    
    //Il ciclo si ripete per il numero di generazioni desiderato, indicato dalla variabile n.
    for (int i= 0; i < n; i++)
    {
      lung = 15; //int(map(abs(mouseX - (width / 2)), 0, width / 2, 10, 50));
      grad = map(mouseY, 0, height, 125, 55);
      //Prima si definisce il sistema attraverso le stringhe.
      stringa();
    }
  }
  
  private void stringa()
  {
    //La generazione attuale g0 viene esaminata in tutta la sua lunghezza.
    //l rappresenta il numero di lettere da esaminare alla volta, è pari a 1 se si desidera 
    //un'analisi lettera per lettera, pari a 2 per esaminare coppie di lettere e così via.
    for (int i = 0; i <= g0.length() - l; i = i + l)
    {
      //Si crea il segmento da comparare, questo parte dal punto in cui si è arrivati nella
      //stringa (i) al punto definito dalla lunghezza del segmento desiderato (i + l).
      String c = g0.substring(i, i + l);
      //Qui avvengono le trasformazioni in base alle variabili pN* per creare la nuova generazione.
      if (c.equals(p1a) == true)
      {
        g1 = g1 + p1b;
        linea(lung, true, grad);
      }
      else if (c.equals(p2a) == true)
      {
        g1 = g1 + p2b;
        linea(lung, true, grad);
      }
      else if (c.equals(p3a) == true)
      {
        g1 = g1 + p3b;
        linea(lung, false, grad);
      }
      else if (c.equals(p4a) == true)
      {
        g1 = g1 + p4b;
        linea(lung, false, grad);
      }
    }
    //println(g0);
    //La nuova generazione diventa la vecchia, e si azzera g1 per poter ricominciare il ciclo.
    g0 = g1;
    g1 = "";
  }
  
  private void linea(int lunghezza, boolean destra, float gradi)
  {
    if (destra == false)
    {
      gradi = 360 - gradi;
    }
    float nposG = posG + gradi;
    int nposX = posX + int((cos(radians(nposG))) * lunghezza);
    int nposY = posY + int((sin(radians(nposG))) * lunghezza);
    stroke(0x80558877); strokeWeight(6);
    line(posX, posY, nposX, nposY);
    posX = nposX;
    posY = nposY;
    posG = nposG;
  }
}

How to drive a floppy with arduino

2010-09-20T15:10:00.002+02:00

Every floppy has read/write head moved by a stepper motor.

It's easy to drive that motor using the built in interface, all you have to do is to wire some pin to ground ad power up the floppy.

Actually two pins are used to drive the motor. One controls direction (pin 18) and one controls steps (pin 20).

In my setup an arduino board controls those pins with the right timing to generate a sound of a specified frequency.

This is the wiring:

And this is the code:

//pin collegati ai floppy, due per ogni floppy, il primo è lo step_pin, il secondo il dir_pin
byte fd[] = {2, 3, 4, 5};

//sequencer
int steps = 16;
float seq_f[] = {400, 300, 200, 410, 130, 230, 270, 280, 300, 200, 100, 310, 230, 330, 370, 380};
int seq_t[] = {500, 500, 200, 500, 500, 300, 500, 500, 500, 500, 200, 500, 500, 300, 500, 500};
boolean seq_d[] = {true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false};

//------------------------------------------------------

void setup()
{
  //attiva i pin dei floppy
  for (byte i = 0; i < 4; i++)
  {
    pinMode(fd[i], OUTPUT);
  }
  //Serial.begin(9600);
}

//------------------------------------------------------

void loop()
{
  for (int i = 0; i < steps; i++)
  {
    muovi(0, seq_d[i], seq_f[i], seq_t[i]);
  }
}

//------------------------------------------------------

// fl: numero del floppy, dir: true == avanti, f: frequenza, n: numero di passi (n <= 86)
void muovi(byte fl, boolean dir, float f, int t)
{
  //setta i pin del floppy
  byte step_pin = fl * 2;
  byte dir_pin = (fl * 2) + 1;
  
  //calcola il periodo T di delay tra un passo e l'altro data la frequenza f
  float T = (1 / f) * 1000000;
  
  //alza o abbassa il dir_pin a seconda della direzione dir (true == avanti)
  if (dir == true)
  {
    digitalWrite(fd[dir_pin], HIGH); 
    digitalWrite(13, HIGH);  //led indicatore direzione
  }
  else
  {
    digitalWrite(fd[dir_pin], LOW);
    digitalWrite(13, LOW);
  }
  
  //numero di iterazioni (n) ottenuto dal tempo desiderato per una nota (t, in ms) diviso il
  //tempo richiesto per un ciclo (T per 2 passi) moltiplicato 1000 (poichè T è espresso in s)
  float n = t / (T * 2) * 1000;
  
  //alza e abbassa lo step_pin per un numero di passi n col giusto delay
  for (int i = 0; i < n; i++)
  {
    digitalWrite(fd[step_pin], HIGH);
    delayMicroseconds(T);
    digitalWrite(fd[step_pin], LOW);
    delayMicroseconds(T);
  }
  //Serial.println(n, DEC);
}

Here is a good article about floppy's motors.

.conkyrc

2010-06-01T18:55:00.003+02:00

My new .conkyrc file, based on this one.

Needs PizzaDude Bullets and StyleBats fonts.

use_xft yes
xftfont verdana:size=8
alignment top_left
gap_y -1
xftalpha 0.8
own_window no
own_window_type override
own_window_transparent yes
own_window_hints undecorated,sticky,below,skip_taskbar,skip_pager
double_buffer yes
draw_shades no
draw_outline no
draw_borders no
stippled_borders 10
border_margin 4
border_width 1
default_shade_color grey
default_outline_color black
default_color BADCDD
use_spacer none
no_buffers yes
uppercase no
color1 F8DF58

TEXT

${color 989898}${font StyleBats:size=16}2${font}  uptime:  ${uptime_short}

${color 989898}${font StyleBats:size=16}A${font}  cpu: ${cpu cpu0}%
${color 989898}${cpugraph 20,200 eth0 000000 989898}
${color 989898}${font StyleBats:size=16}l${font}  ram: $memperc%
${membar 6,200}
${color 989898}${font StyleBats:size=16}b${font}  swap: $swapperc%
${swapbar 6,200}

${color 989898}${font StyleBats:size=16}j${font}  root: ${fs_free /}/${fs_size /}
${fs_bar 6,200 /}
${color 989898}${font StyleBats:size=16}i${font}  partio: ${fs_free /media/partio}/${fs_size /media/partio}
${fs_bar 6,200 /media/partio}

${color 989898}${font PizzaDude Bullets:size=16}r${font}  download: ${downspeed eth0} Kb/s
${color 989898}${downspeedgraph 20,200 eth0 000000 989898}
${color 989898}${font PizzaDude Bullets:size=16}v${font}  upload: ${upspeed eth0} Kb/s 
${color 989898}${upspeedgraph 20,200 eth0 000000 989898}

Alternative Arduino Serial Monitor

2010-05-31T01:26:00.003+02:00

On my Arch64 box Arduino's Serial Monitor crashes. I don't know why but I'm used to this kind of bugs... live at 64bit was never easy.

So I wrote a simple python script which let me see serial communications on the console:

import serial
import time

seriale = serial.Serial('/dev/ttyUSB0', 9600, timeout = 1)

while 1:
  print(seriale.read(seriale.inWaiting()))
  time.sleep(0.1)

HowTo: OpenFrameworks on Arch Linux x86_64

2010-05-26T14:42:00.006+02:00

Install dependencies:

pacman gstreamer0.10 gstreamer0.10-plugins alsa-lib libxmu libxxf86vm udev base-devel libraw1394 ffmpeg mesa

Download the newest code from github.

Edit "libs/openFrameworksCompiled/project/linux64/makefile " and add "-D__STDC_CONSTANT_MACROS" to "USER_CFLAGS" (line 15).

Edit "libs/openFrameworks/video/ofUCUtils.cpp " and comment lines 19 and 20.

Go to "libs/openFrameworksCompiled/project/linux64" and launch "make".

Delete "libs/fmodex/lib/linux64/libfmodexp64.so" see why here.

Yamaha-DD6 e Pd

2010-05-21T17:41:00.002+02:00

Con questa semplicissima patch è possibile pilotare la Yamaha-DD6 modificata con lo stesso firmware scritto per python, d'altronde, sempre di connessione seriale si tratta.
Tutto ruota intorno a [comport] oggetto per il quale non sono riuscito a trovare una guida, ma che per fortuna ha un help abbastanza chiaro, per visualizzarlo attaccate all'input un messaggio con scritto "help" senza le virgolette e cliccatelo.

Il messaggio "devices" mostra nella console i dispositivi seriali disponibili, e "open" apre quello con il numero corrispondente.

I messaggi "10" "11" "12" "13" sono i messaggi che vengono mandati in seriale, e nel mio caso, corrispondono ai pin che arduino deve triggare.

Yamaha DD6 e Python

2010-05-21T11:07:00.009+02:00

Adesso posso pilotare la mia Yamaha-DD6 con python!
Mi sono basato sul software scritto da questo tizio per controllare dei servo.

Grazie al suo codice triggare la Yamaha da terminale è stato abbastanza indolore. Ma ora ecco i miei codici:

Questo è lo sketch di arduino, in pratica si limita ad aspettare una connessione seriale, e se esiste, prende un byte, presume che quel byte sia il numero del pin da triggare (non ho acora messo nessun tipo di controllo) e lo trigga:

void setup()
{
  for (int i = 10; i < 14; i++)
  {
    pinMode(i, OUTPUT);
  }
  Serial.begin(9600);
}

void loop()
{
  if (Serial.available() > 0)
  {
    trig(Serial.read());
  }
}

void trig(int pad)
{
  digitalWrite(pad, HIGH);
  delay(5);
  digitalWrite(pad, LOW);
}

Per quanto riguarda python, ho utilizzato pySerial per la comunicazione seriale.
Queste 8 righe fanno partire una connessione seriale e mandano attraverso questa un byte.
Quando si lancia la funzione trig(n), n è il bit trasmesso e deve corrispondere al numero del pin da triggare (in questo caso n = 11):

import serial

seriale = serial.Serial('/dev/ttyUSB0', 9600, timeout = 1)

def trig(pad):
  seriale.write(chr(pad))

trig(11)

Nota: Con lo stesso firmware si può usare anche Pd per pilotare la Yamaha.

Yamaha-DD6 e Arduino

2010-05-20T20:02:00.011+02:00

Ho appena finito di collegare la mia "nuova" Yamaha DD-6 ad Arduino.
Non è la prima volta che mi cimento a interfacciare una batteria elettronica ad Arduino (Dragga Machine) ma devo dire che questa volta sono stato davvero più pulito.
Ho usato pochissimi pezzi, e inoltre credo che questo metodo si possa tranquillamente implementare su altre batterie elettroniche provviste di pad piezoelettrici.

Ho collegato un pin digitale di Arduino per ogni contatto positivo dei piezo, ma tra questi ho messo una resistenza per proteggere la circuiteria interna della batteria, e un diodo per proteggere Arduino da eventuali "risalite" di corrente.
In pratica ho ripetuto quattro vole questo schema:

Ovviamente mettendo in comunicazione le masse della batteria elettronica e di arduino.
Alla fine ho ottenuto questo:

E l'ho avvitato sopra la PCB originale:

Ecco un particolare del collegamento al piezo:

Per ognuno dei quattro contatti ho usato un mini-jack per poter collegare facilmente qualunque cosa voglia usare per "triggare".

Finora ho provato solo con Arduino, ma dovrebbe bastare un qualunque impulso da 5V.

Infine ecco un semplicissimo sketch che ho usato come test, come vedete, per triggare basta "alzare" il pin per poi "abbassarlo" subito dopo, 5 millisecondi vanno benissimo.

int pad0 = 10;
int pad1 = 11;
int pad2 = 12;
int pad3 = 13;

int del = 500;

void setup()
{
  for (int i = pad0; i < 4; i++)
  {
    pinMode(i, OUTPUT);
  }
}

void loop()
{
  trig(pad0);
  delay(del);
  trig(pad1);
  delay(del);
  trig(pad2);
  delay(del);
  trig(pad3);
  delay(del);
}

void trig(int pad)
{
  digitalWrite(pad, HIGH);
  delay(5);
  digitalWrite(pad, LOW);
}

Prossimamente scriverò uno sketch per poter pilotare la batteria qualunque cosa possa mandare messaggi in seriale, come ad esempio Pd, python eccetera.
Anche provare a usarla con ttymidi dev'essere interessante...

Aggiornamento 21-05-2010:
Sono riuscito a triggare i pad attraverso python e una connessione seriale, i dettagli sono qui.
E con lo stesso sketch usato per python si può usare anche Pd per pilotarla.

Buddha Machine

2010-05-16T16:43:00.003+02:00

How many times have you found just a single resistor to bend?

For instance, this Buddha Machine is a one-stupid-resistor-toy:

But this time I connected a pitch knob and a LDR in series.

LDR is in front of a flashing led drived by a 555 timer. The result is an interesting pitch-tremolo-like effect:

This is the schematic of the added circuit:

I used a fixed value (1k) for R1, but if you put a variable resistor you can change the amount of dark time besides the blinking time.
Values are not critical, but this is a good combination.

LoFi-O

2010-05-03T13:15:00.008+02:00

LoFi-O è un generatore di suoni lo-fi che ho progettato ultimamente.
Contiene 2 oscillatori a onda quadra e 2 LFO basati sull'inverter CD40106, e un filtro passa basso attivo basato sull'opamp TL071.

I suoi suoni sono interessanti e ne sono abbastanza fiero, presto posterò lo schema e il layout per stripboard, intanto godetevi il video per farvi un'idea delle sue potenzialità:

Dato che sul video la qualità dell'audio fa abbastanza schifo ho uppato anche qualche minuto di audio su soundcloud. In realtà i suoni di LoFi-O sono molto LoFi, ma tanto vale sentire una registrazione quasi decente:

LoFi-O by aggaz

Schema:

Living Circuits

2010-04-16T11:47:00.001+02:00

oElica

2010-02-26T14:26:00.005+01:00

Un tempo questa era la sua forma:

In origine l'elicotterino doveva essere in grado di svolazzare e girare su se stesso, ma io l'ho ricevuto rotto, dato che un qualche stolto bambino ha avuto il coraggio di buttarlo, noncurante del suo suono perfetto.

Ho cominciato subito a bendarlo, e l'elicotterino deve aver apprezzato la cosa perchè ha mostrato subito il suo potenziale, anche se per trovare i punti migliori ovviamente c'è voluto un po' di tempo.

Ho aggiunto potenziometri e condensatori, dei primi adoro il controllo fine, i secondi hanno permesso gli pseudo filtri e i ritmi ipnotici.

Il circuito veniva alimentato con 4 pile da 1,5V, ma fortunatamente funzionava tranquillamente anche a 5V, così ho aggiunto un 7805 per poterlo alimentare con una batteria da 9V, che è meno ingombrante.

Ho comprato una scatolina bellissima per l'occasione e questo è il risultato finale:

Ovviamente non potevano mancare le immagini sonore:

Cianobatteri

2010-02-01T21:16:00.005+01:00

Just another Conway's game of life implementation, strongly based on "2D CA Glider" by Alasdair Turner, but with circles and colors that reminds me Cyanobacteria.

Click and drag to inoculate!

/* Cianobatteri
 * Just another Conway's game of life implementation,
 * strongly based on "2D CA Glider" by Alasdair Turner,
 * but with circles and colors that reminds me Cyanobacteria.
 * Writed by Francesco Aggazio, licensed under Creative Commons
 * Attribution-Share Alike 3.0 license.
 * Work: http://openprocessing.org/visuals/?visualID=7160
 * License: http://creativecommons.org/licenses/by-sa/3.0/
 */


int c = 50;
int cx; int cy;
int s = 500 / c;
boolean [][] cells;
boolean [][] nextcells;


void setup() 
{ 
  size(500,500);
  cells = new boolean [c][c];
  nextcells = new boolean [c][c];
  for (int i = 0; i < c; i++)
  {
    for (int j = 0; j < c; j++)
    {
      cells[i][j] = false;
    }
  }
  noStroke();
  smooth();
  frameRate(6);
}


void draw()
{
  background(0);
  color colore = 0x80000000;
  for (int i = 0; i < c; i++)
  {
    for (int j = 0; j < c; j++)
    {
      if (cells[i][j] == true)
      {
        int incol = 0;
        for (int m = -1; m <= 1; m++)
        {
          for (int n = -1; n <= 1; n++)
          {
            if (!(m == 0 && n == 0))
            {
              if (cells[(i+m+c)%c][(j+n+c)%c] == true)
              {
                incol++;
              }
            }
          }
        }
        if (incol < 3)
        {
          colore = 0x8030a236;//5dd463;
        }
        else if (incol == 3)
        {
          colore = 0x80256a6a;
        }
        else if (incol > 3)
        {
          colore = 0x805dd463;//8ed46a;
        }
        fill(colore);
        ellipse((i * s) + (s / 2), (j * s) + (s / 2), s * 2, s * 2);
      }
      // count up how many alive around us
      int number = 0;
      for (int m = -1; m <= 1; m++)
      {
        for (int n = -1; n <= 1; n++)
        {
          if (!(m == 0 && n == 0))
          {
            if (cells[(i+m+c)%c][(j+n+c)%c] == true)
            {
              number++;
            }
          }
        }
      }
      // counted up... now set state of cell for next generation
      if (number < 2 || number > 3)
      {
        nextcells[i][j] = false;
      }
      else if (number == 3)
      {
        nextcells[i][j] = true;
      }
      else
      {
        nextcells[i][j] = cells[i][j];
      }
    }
  }   
  for (int i = 0; i < c; i++)
  {
    for (int j = 0; j < c; j++)
    {
      cells[i][j] = nextcells[i][j];
    }
  }
}


void mousePressed()
{
  cx = int(mouseX / s);
  cy = int(mouseY / s);
  if (cells[cx][cy] == true)
  {
    cells[cx][cy] = false;
  }
  else
  {
    cells[cx][cy] = true;
  }
}


void mouseDragged()
{
  if (mouseX < width && mouseX > 0 && mouseY < height && mouseY > 0)
  {
  cx = int(mouseX / s);
  cy = int(mouseY / s);
  cells[cx][cy] = true;
  }
}

PixeLine

2010-01-25T12:05:00.000+01:00

This simple sketch controls pixel's colors of a picture and makes a line of the same color of the pixel itself if its color's value is in a certain range determined by cursor's position.

Left = Red
Rigth = Blue
Up = Green

For the first time I used OpenProcessing.org to run a sketch online, and this is a good thing! Enjoy!

And obviously, here is the code!

/* PixeLine. Makes lines over a pixel of the same color of 
 * the pixel itself if color's value is in a certain range 
 * determined by cursor's position. 
 * Writed by Francesco Aggazio and licensed under Creative 
 * Commons Attribution-Share Alike 3.0 Unported. 
 */ 
  
 
PImage img = loadImage("cubo.png"); 
color[] pic = new color[img.width * img.height]; 
 
 
void setup() 
{ 
  size(420, 315); 
  img.loadPixels(); 
  arrayCopy(img.pixels, pic); 
} 
 
 
void draw() 
{ 
  image(img, 0, 0); 
  color colo = 0; 
  arrayCopy(pic, img.pixels); 
  for (int i = 0; i < (width * height); i++) 
  { 
    int l = int(random(1) * 20); 
    int r = int(map(mouseX, 0, width, 254, 0)); 
    int g = int(map(mouseY, 0, height, 254, 0)); 
    int b = int(map(mouseX, 0, width, 0, 254)); 
    if (red(img.pixels[i]) < r && green(img.pixels[i]) < g && blue(img.pixels[i]) < b) 
    { 
      colo = img.pixels[i]; 
      for (int a = 0; a < l; a++) 
      { 
        int v = i - (width * a); 
        if ( v < 0) 
        { 
          v = 0; 
        } 
        img.pixels[v] = colo; 
      } 
    } 
  } 
  img.updatePixels(); 
}

MoscaView

2010-01-21T16:48:00.000+01:00

MoscaView è la naturale evoluzione di Esagonia.
I bordi dei singoli esagoni sono stati eliminati per avere un effetto somigliante alla visione che potrebbe avere una mosca. Ecco un breve video, anche questa volta accellerato non so perchè... Come se non bastesse youtube ha ridimensionato automaticamente il video, che altrimenti avrebbe l'asse y più lungo dell'x, ma rende comunque l'idea.

Sebbene le modifiche al codice siano minime, lo riporto qui sotto nella sua interezza, praticamente ho sostituito stroke(0, 0, 0) con noStroke(), e naturalmente ho eliminato strokeWidth().
Inoltre ho aggiunto il codice necessario alla registrazione del video sull'hard disk.

import processing.video.*;
Capture videoin;
MovieMaker film;


void setup()
{
  size(410, 450);
  colorMode(RGB, 255);
  background(0, 0, 0);
  noStroke();
  smooth();
//  println(Capture.list());
  videoin = new Capture(this, width, height, "la_tua_webcam", 30);
  film = new MovieMaker(this, width, height, "il_tuo_file", 30, MovieMaker.H263, MovieMaker.HIGH);
}


void captureEvent(Capture videoin)
{
  videoin.read();
}


void draw()
{
  pattern(23, 6);
  film.addFrame();
}


void esagono(int x, int y, int l)
{
  beginShape();
  vertex(x + (l / 2), y);
  vertex(x + (l / 2) + l, y);
  vertex(x + (l * 2), y + sqrt(sq(l) - sq(l / 2)));
  vertex(x + (l / 2) + l, y + (sqrt(sq(l) - sq(l / 2)) * 2));
  vertex(x + (l / 2), y + (sqrt(sq(l) - sq(l / 2)) * 2));
  vertex(x, y + sqrt(sq(l) - sq(l / 2)));
  vertex(x + (l / 2), y);
  endShape();
}


void pattern(int n, int l)
{
  int x = (width / 2) - l; int y = 0; int b = int(sin(radians(60)) * l);
  for (int e = 0; e < n; e++)  
  {
    int ix = x; int iy = y;
    for (int i = 0; i < (n + e); i++)
    {
      color colore = videoin.get((ix + l), (iy + b));
      fill(colore);
      esagono(ix, iy, l);
      ix = ix + (l + (l / 2));
      iy = iy + b;
    }
    x = x - (l + (l / 2));
    y = y + b;
  }
  
  int c = (n - 1) * 2;
  x = x + (l + (l / 2));
  y = y + b;
  for (int a = 0; a < c; a++)
  {
    int ix = x; int iy = y;
    for (int o = 0; o < c; o++)
    {
      color colore = videoin.get((ix + l), (iy + b));
      fill(colore);
      esagono(ix, iy, l);
      ix = ix + (l + (l / 2));
      iy = iy + b;
    }
    c = c - 1;
    y = y + (b * 2);
  }
}


void keyPressed()
{
  if (key == ' ')
  {
    film.finish();
  }
}

Devo ringraziare Venom per avermi suggerito di togliere i bordi, è stata proprio una buona idea e dato che mi ha fatto notare che la comprensione del codice non è proprio immediata ecco una breve descrizione delle funzioni principali:

esagono(int x, int y, int l)

calcola le coordinate di tutti i vertici necessari alla creazione di un esagono e lo disegna. Il calcolo delle coordinate è impostato in maniera tale da poter variare senza difficoltà sia le coordinate dell'esagono stesso (x e y) sia la lunghezza del lato dell'esagono (l). Per ottenere questo risultato ho fatto un ampio uso del teorema di pitagora, scelta ovvia se si considera un esagono come un insieme di triangoli. Mi sono basato su questo disegno partendo dal vertice in alto a sinistra, quindi a chi è interessato a studiare il codice consiglio di dargli un'occhiata durante la lettura.

pattern(int n, int l)

genera un esagono di esagoni, che è il pattern che da la forma all'immagine vista. È possibile scegliere sia la lunghezza del lato di ogni esagono in pixel (l), sia la lunghezza del lato dell'esagono di esagoni, in numero di esagoni (n). La variabile b è l'equivalente di a dell'immagine sopra. Ogni esagono è posizionato nelle giuste coordinate attraverso due serie di due cicli for. Il motivo è chiarificato dall'immagine accanto.

La prima serie posiziona gli esagoni numerati in nero, e a ogni ciclo aggiunge un esagono, mentre la seconda quelli coi numeri in bianco, e ad ogni ciclo sottrae un esagono. I numeri rispecchiano l'ordine seguito dall'algoritmo. In questa maniera, a ogni ciclo, pattern() chiama esagono(), posiziona l'esagono alle sue coordinate e lo colora con il colore del pixel dell'input video corrispondente al centro dell'esagono stesso.

Esagonia

2010-01-21T00:01:00.000+01:00

Genera un esagono di esagoni e li colora a seconda dell'input video proveniente dalla webcam.

Sia la lunghezza del lato dei singoli esagoni (l) che il numero degli esagoni che compongono il lato del grande pattern esagonale (n) sono facilmente modificabili.

Questa accanto è un'immagine processata con questo algoritmo, ritrae un temibile draghetto di plastica. L'immagine è scalata del 50%, ma la dimensione originale può essere visualizzata cliccando sopra l'immagine stessa.

Questo è lo stesso input non processato, notate le fauci.

Infine ecco il codice:

import processing.video.*;
Capture videoin;


void setup()
{
  size(600, 633);
  colorMode(RGB, 255);
  background(0, 0, 0);
  stroke(0, 0, 0);
  strokeWeight(2);
  smooth();
//  println(Capture.list());
  videoin = new Capture(this, width, height, "nome_della_tua_webcam", 30);
}


void captureEvent(Capture videoin)
{
  videoin.read();
}


void draw()
{
  pattern(32, 6);
}


void esagono(int x, int y, int l)
{
  beginShape();
  vertex(x + (l / 2), y);
  vertex(x + (l / 2) + l, y);
  vertex(x + (l * 2), y + sqrt(sq(l) - sq(l / 2)));
  vertex(x + (l / 2) + l, y + (sqrt(sq(l) - sq(l / 2)) * 2));
  vertex(x + (l / 2), y + (sqrt(sq(l) - sq(l / 2)) * 2));
  vertex(x, y + sqrt(sq(l) - sq(l / 2)));
  vertex(x + (l / 2), y);
  endShape();
}


void pattern(int n, int l)
{
  int x = (width / 2) - l; int y = 0; int b = int(sin(radians(60)) * l);
  for (int e = 0; e < n; e++)  
  {
    int ix = x; int iy = y;
    for (int i = 0; i < (n + e); i++)
    {
      color colore = videoin.get((ix + l), (iy + b));
      fill(colore);
      esagono(ix, iy, l);
      ix = ix + (l + (l / 2));
      iy = iy + b;
    }
    x = x - (l + (l / 2));
    y = y + b;
  }
  
  int c = (n - 1) * 2;
  x = x + (l + (l / 2));
  y = y + b;
  for (int a = 0; a < c; a++)
  {
    int ix = x; int iy = y;
    for (int o = 0; o < c; o++)
    {
      color colore = videoin.get((ix + l), (iy + b));
      fill(colore);
      esagono(ix, iy, l);
      ix = ix + (l + (l / 2));
      iy = iy + b;
    }
    c = c - 1;
    y = y + (b * 2);
  }
}

Context Free Art

2010-01-08T20:16:00.000+01:00

Ho scoperto Context Free Art e mi piace moltissimo!

CFDG è un simpatico programma open source che permette di generare immagini da algoritmi descritti in maniera molto semplice, senza la complessa sintassi tipica dei linguaggi di programmazione a cui siamo abituati. Ciò è reso possibile grazie all'utilizzo di una grammatica libera dal contesto, che è una forma di grammatica formale.

Una grammatica formale è qualcosa di diverso dalla grammatica dei linguaggi naturali, le sue regole sono regole matematiche e astratte, e per definizione deve essere costituita da:

Un insieme finito di simboli terminali (in pratica lettere).
Un insieme finito di simboli non terminali.
Un insieme finito di regole di produzione.
Un simbolo iniziale.

Con questi elementi è possibile generare un certo numero di stringhe che sono le parole che nel loro insieme formano il linguaggio formale.

Noam Chomsky è stato il pioniere che durante gli anni 50 studiò i vari tipi di grammatiche formali e fu il primo a descriverne una gerarchia in base al loro potere generativo. La sua ricerca era orientata verso la comprensione delle strutture dei linguaggi naturali, quelli parlati da noi umani, ma i principi da lui esposti possono essere utilizzati anche per altri scopi.

Chris Coyne è quello che ha scritto CFDG e per farlo si è basato su questi principi, solo che il suo programma usa come simboli terminali forme anzichè lettere. Quest'approccio permette di generare forme complesse a partire da forme semplici quali quadrati, triangoli e cerchi.

Per dare un'idea del potenziale di questo fantastico software pubblico qui sotto qualche immagine che ho generato in questi giorni accompagnate dai rispettivi codici. Vedrete come poche righe bastino per avere risultati complessi.
Siccome mi trovo a Crotone, terra di Pitagora, ho cominciato generando un semplice albero pitagorico:

startshape ALBEROPITAGORICO

rule ALBEROPITAGORICO {
 SQUARE {}
 ALBEROPITAGORICO {y 1 x -0.5 r 45 s 0.7}
 ALBEROPITAGORICO {y 1 x 0.5 r -45 s 0.7}
}

È immediatamente evidente come sia semplice creare un'iterazione.
startshape è la prima istruzione obbligatoria, e indica la forma base, in questo caso ALBEROPITAGORICO. ALBEROPITAGORICO è la prima e unica regola, crea un quadrato e poi chiama se stessa due volte, ma con qualche variazione. In entrambi i casi crea un quadrato più piccolo, pari al 70% del primo, ma mentre nel primo caso il quadrato è ruotato di 45°, nel secondo invece è ruotato di -45°. Anche la posizione rispetto all'asse x è diversa nei due quadrati "figli", poichè sono posizionati ognuno su un lato diverso, mentre quella rispetto all'asse y è uguale nei due casi, perchè entrambi sono sopra il quadrato "padre".
Tale operazione viene ripetuta per ogni quadrato figlio (iterazione) generando il frattale qui sopra.

Poichè parliamo di Pitagora e poichè da poco so cos'è un coseno ho deciso di generare un'altro albero simile al primo ma con le proporzioni dei quadrati figli diverse, in modo da avere un triangolo rettangolo tra i quadrati.
Poichè un angolo deve essere di 90° ho ruotato i quadrati figli di 60° e 30°, e per la grandezza ho dato il valore di sin(30) al più piccolo e di cos(30) al più grande. Qualche aggiustamento agli assi x e y et voilà:

startshape ALBEROPITAGORICO_RETTANGOLO

rule ALBEROPITAGORICO_RETTANGOLO {
 SQUARE{}
 ALBEROPITAGORICO_RETTANGOLO {y 1.1 x 0.34 r -30 s 0.87}
 ALBEROPITAGORICO_RETTANGOLO {y 0.85 x -0.6 r 60 s 0.5}
}

Infine ho preso questo bel ramo a spirale e l'ho ruotato 7 volte di 45° in modo da avere una forma circolare composta da 8 rami che mi ricorda un cavolo, ecco dunque, senza ulteriori indugi, il cavolo pitagorico:

startshape CAVOLO_PITAGORICO

rule RAMO {
 SQUARE{}
 SQUARE{s 0.9 b 1}
 RAMO {y 1.1 x 0.34 r -30 s 0.87}
 RAMO {y 0.85 x -0.6 r 60 s 0.5}
}

rule CAVOLO_PITAGORICO {
 RAMO {}
 RAMO {r 45}
 RAMO {r 90}
 RAMO {r 135}
 RAMO {r 180}
 RAMO {r 225}
 RAMO {r 270}
 RAMO {r 315}
}

Questa volta ho dovuto aggiungere un quadrato bianco più piccolo sopra ogni quadrato nero di base, per ottenere solo i bordi dei quadrati, in modo da non avere come risultato un'immagine troppo confusa.

Questo è quello che fin'ora ho fatto con CFDG, e sopratutto solo quello che ho capito del suo funzionamento. Per chi volesse approfondire, oltre ai tutorial sul sito ufficiale e alle varie pagine di wikipedia già linkate, consiglio un'ottimo articolo chiamato "Structural Synthesis using a Context-Free Grammar Approach" scaricabile in pdf da questo post, e le lezioni del corso "DECO2013: Generative Design Systems" consultabili qui. Essenziale è il pdf "Context Free in a Nutshell" che sta qui.

Circular Pixels

2009-12-27T23:15:00.000+01:00

In questi ultilimi giorni ho giocato un po' con Processing e Arduino. Nonostante la mia poca esperienza con Processing, i risultati sono stati molto soddisfacenti.
Avvelendomi delle librerie Serial e Video incluse nell'ultima versione sono riuscito con poco sforzo a manipolare i pixel dell'input video della webcam con sei potenziometri collegati ad arduino.

Arduino si limita a prendere i sei valori analogici, ad allinearli in una comoda stringa e a spedire questa stringa via comunicazione seriale.

int anali = 6;
int tolleranza = 9;
int valore[6];
int vecchio[6];

void setup()
{
  Serial.begin(57600);  
}  

void loop()
{
  for (int n = 0; n < anali; n++)
  {
    valore[n] = analogRead(n);
    if (abs(vecchio[n] - valore[n]) > tolleranza)
    {
    vecchio[n] = valore[n];
    for (int i = 0; i < anali; i++)
    {
      Serial.print(valore[i], DEC);
      if (i < (anali - 1))
      {
        Serial.print(",");
      }
    }
    Serial.println();
    }
  }
}

Processing riceve questa stringa, la divide nei singoli valori (i quali sono separati da virgole), e li associa ad alcune divertenti variabili. Allo stesso tempo si collega alla webcam, prende il colore di un pixel ogni tanto e traccia un cerchio di quel colore a quelle coordinate, il risultato finale è un'immagine composta non da punti, ma da cerchi.

import processing.serial.*;
import processing.video.*;
Serial seriale;
Capture videoin;
MovieMaker film;

int x = 400;
int y = 300;
int an0 = 1;
int an1 = 1;
int an2 = 1;
int an3 = 1;
int an4 = 1;
int an5 = 1;


void setup()
{
  size(x, y);
  background(0);
  smooth();
  noFill();

  videoin = new Capture(this, width, height, "Common PixArt PAC207 based webcam (0x2468)", 30);
  film = new MovieMaker(this, width, height, "/Volumes/partio/cpawm7.avi", 30, MovieMaker.BMP, MovieMaker.HIGH);
  
  seriale = new Serial(this, Serial.list()[2], 57600);
  seriale.bufferUntil('\n');
  seriale.clear();
}

void draw()
{ 
  //image(videoin, 0, 0);
    
  color rosso = color(an4, 0, 0);
  color verde = color(0, an5, 0);
  color blu = color(0, 0, an0);
  
  color csum1 = blendColor(rosso, verde, ADD);
  color csum2 = blendColor(csum1, blu, ADD);
  
  int raggio = an1;
  int spazio = an2;
  int opacita = an3;
  
  for (int scany = 0; scany < y; scany = scany + spazio)
  {
    for (int scanx = 0; scanx < x; scanx = scanx + spazio)
    {
      color colore = videoin.get(scanx, scany);
      int colorsum = blendColor(colore, csum2, ADD);
      stroke(colorsum, opacita);
      ellipse(scanx, scany, raggio, raggio);
    }
  }
  film.addFrame();
}

void serialEvent(Serial seriale)
{
  String flusso = seriale.readStringUntil('\n');
  flusso = trim(flusso);
  int quanti[] = int(split(flusso, ','));

  an0 = int(map(quanti[0], 0, 1023, 0, 254));
  an1 = int(map(quanti[1], 0, 1023, 1, 100));
  an2 = int(map(quanti[2], 0, 1023, 5, 100));
  an3 = int(map(quanti[3], 0, 1023, 0, 254));
  an4 = int(map(quanti[4], 0, 1023, 0, 254));
  an5 = int(map(quanti[5], 0, 1023, 0, 254));
  
  print(an0);
  print(",");
  print(an1);
  print(",");
  print(an2);
  print(",");
  print(an3);
  print(",");
  print(an4);
  print(",");
  println(an5);
}

void captureEvent(Capture videoin)
{
  videoin.read();
}

void keyPressed()
{
  if (key == ' ')
  {
    film.finish();
  }
}

Dei sei potenziometri, uno controlla il raggio dei cerchi, uno lo spazio tra i cerchi, un'altro l'opacità dei cerchi. Gli altri tre possono influenzare il colore variando la quantità di rosso, verde e blu.
Nello sketch ci sono pure le righe che ho usato per registrare il video sull'hard disk, ovvero tutte le chiamate a MovieMaker, che fa parte della libreria video.

Non so per quale motivo il video salvato è accellerato, forse è una conseguenza del fatto che il mio mac è vecchio e lento, e java è ancora più lento e, mentre registro, per passare da un frame all'altro, processing ci impiega più di quanto dovrebbe, effetto che sparisce quando si guarda la registrazione (che appare quindi velocizzata). Non so, ma in ogni caso gli effetti grafici sono interessanti e lo smanettamento è divertente.

Dragga Machine

2009-11-25T10:42:00.001+01:00

I added two new knobs to my awesome Bontempi toy drum machine.

The first time I modified this toy I was able to found only the pitch resistor. When I tried do add other bends I fried a fuse-resistor and I had to go to a TV specialist to repair it! (I did not know nothing about the existence of fuse-resistors at the time).
After this bad experience I added some contact to link it with arduino.

Firstly I built a bad looking perfboard prototype. It worked but I fried some transistor.
Anyway I was able to drive it with Pd, as showed in this old video:

At a later time I etched an handmade arduino shield. Like the first prototype it's based on 2N2222 transistors, but this time I added a vactrol for digital pitch control!

Some day ago I tried again to bend it, and this time I was lucky! I was able to add two more noisy knobs and now it's perfect for lofi techno amateurs!

I don't have a schematic of the board, but it's a really simple circuit based on trasistor switches.
For those interested in software, I used the Pduino Object + Firmata Firmware and there's my patch!

Arduinome x16adc mod

2009-11-22T13:41:00.002+01:00

Some times ago I hacked my arduinome to add 16 potentiometers to it.
I writed about it only on monome's forum but I think it can be a good subject for my first article on this blog.

Basically, it's a good way to fill arduino's free analog input pins. They should be free if, like me, you are playing with an unsped shield.

Arduinomes works on three levels:

Hardware

Firmware

Software

we must touch all these levels to add our potentiometers.

Hardware
An arduino board has 6 analog input pins, but we can add more inputs with multiplexing.
I choosed cd4067 multiplexer, it's an analog multiplexer 100% arduino compatible.
Luckily I found some free information about how to use it, "Introduction to Physical Computing" was very usefull.
I developed a simple circuit to add it to your arduinome, here is the schematic:

As you can see I used analog pins to drive cd4067, actually only ANALOG_0 is an analog input, others choose multiplexer's channel only, so they act like digital output pin. You can use every arduino's digital pin to do it, but I found them comfortable.
C2 (I know, it shoul be C1) is there for supply decoupling.

Firmware
Obviously I had to change arduinome's firmware. Arduinome firmware is part of an open source project, the original version can be found on sourceforge. The pde file with my modifications can be downloaded through monome's forum, it's in the x16adc_code.zip archive.
I will not write here all modifications I wrote, I will discuss most important modifications only.

1. I added to arduinome's firmware the same code of the tutorial linked above to handle cd4067 pins. These lines are crucial:

void cd4_setChannel(int cd4_whichChannel)
{
  for (int cd4_bitPosition = 0; cd4_bitPosition < 4; cd4_bitPosition++)
  {
    int cd4_bitValue = (cd4_whichChannel >> cd4_bitPosition) & 1;
    int cd4_pinNumber = cd4_firstPin + cd4_bitPosition;
    digitalWrite(cd4_pinNumber, cd4_bitValue);
  }
}

cd4_whichChannel can be a number from 0 to 15, each value is shifted 4 times and masked. These 2 operations are needed to generate 16 different combinations of the 4 control pins. Read this bit math tutorial if you don't know nothing about bit shifting and masking.
The following table shoul clearify what the function do:

Every value is shifted of 0 and masked, then is shifted of 1 and masked, and so on, until 3. The last four columns represents the pin states of the 4 control pins in the 16 calls, as you can see every row is different from each other. This means that every call returns a different control pin pattern.

2. This was the most important modification:

void sendADC(int port, int value)
{
  Serial.print((1 << 4) | (port & 0xF), BYTE);
  Serial.print(((value >> 2) & 0xFF), BYTE);
}

the original code was:

void sendADC(int port, int value)
{
  Serial.print((1 << 4) | ((port << 2) & 0x0C) | ((value >> 8) & 0x03), BYTE);
  Serial.print(value & 0xFF, BYTE);
}

This function sends ADC values to Arduinome Serial following monome's serial protocol. As you can see on the link above, adc_val stream has "value" 10 bit long and "port" only 2 bit long. This means that we can have 1024 different adc values, but only 4 ports. This is why monomes can handle 4 potentiometers only. A 10 bit resolution is a very good resolution, it's the same of arduino's analog digital converters, so this protocol passes down adc values at the maximum resolution. I had to sacrifice resolution to add more than 4 potentiometers, I taked 2 bits from "value" and put it to "port", so now I have a 8 bit resolution for values and up to 16 ports.
In my version of sendADC "address" is the same, "port" has 4 relevants bits ("& 0xF" means "& 1111") and there's no need to add the first 2 bits of "value" to "data0".
"data1" contains the 8 bits of value, and all bits are relevant ("& 0xFF" means "& 11111111").

3. I'm not a C developer, I can't modify Arduinome Serial GUI to have 16 switch, so I had to bypass the ADCEnableState control in Arduinome Firmware to always send ADC values.
For that reason I've commented 610, 611, 617 lines.

Software
Now that the protocol is different, it's necessary to change Arduinome Serial too.
I can't "speak" C, but luckily modifications were easy to find. I had to change only 6 lines on 3 different files of the source code. You can download Arduinome serial souce and edit the files yourself or download my modified files from monomes's forum (Mac OS X only, look inside x16adc_code.zip). In any way you have to compile the source.
Here is all modified lines:

message.c lines: 28 to 32

void messagePackAdcVal(t_message *message, uint8 port, uint8 val)
{
  message-&gt;data0 = (kMessageTypeAdcVal &lt;&lt; 4) | (port &amp; 0x0F);
  message-&gt;data1 = (uint8)val;
}

message.h lines: 67, 68

#define messageGetAdcPort(message) ((message).data0 & 0xF)
#define messageGetAdcVal(message) ((uint16)(message).data1)

line 89

void messagePackAdcVal(t_message *message, uint8 port, uint8 val);

(uint8 val was uint16 val)

ApplicationController.mm line 193

handleAdcValueChangeEvent(device, messageGetAdcPort(*message), (float)(messageGetAdcVal(*message)) / (float)0xFF);

(was 0x3FF)

Basically there are the same "serial stream" modifications, but from the point of view of the reciver.
I changed uint16 to uint8 because now "value" has 8 bits only.
Value's relevant bits are 8 and not 10, so I changed 0x3FF to 0xFF.
END!

Now is time for a good picture of the finished product!

The thing woks, but it's not perfect. It's an hack more than a mod, and some error can occur.
I tried it with Pd on Mac Os X only, and sometimes values seems to flicker. I don't know why, maybe Pd serial communication is slow? I think so because if I only watch values on the console monitor without playing there's no flickering. I can't be sure about it because I need testers! If you are interested, you can download my Pd patch to try the mod here.
It's a 8 step sequencer with filter and sample rate control.
If you don't have modded your arduinome you can play with the original version of this patch, it's called stePd and is free.

This is the maximum I was able to do, I think it can be better, so it would be nice if someone would try to build and refine it.
If you like potentiometers and arduinomes, drop me a line!