Processing music frequency visualizer super mario version

Today I'm posting about a new project in processing that uses minim audio library to visualize frequency using super mario tubes.
I think it's cool, here is the code

import ddf.minim.signals.*;
import ddf.minim.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*;
import ddf.minim.ugens.*;

Minim minim;
AudioPlayer song;
FFT fft;

String song_file = "song.mp3";
PImage tube_up;
PImage tube_sec;
PImage bg_mario;
int m = 3;

void setup(){
  size(1200, 622);
  tube_up = loadImage("tube_up.png");
  tube_sec = loadImage("tube_sec.png");
  bg_mario = loadImage("bg_mario.png");
  frameRate(60);
  minim = new Minim(this);
  song = minim.loadFile(song_file, 512);
  song.play();
  fft = new FFT(song.bufferSize(), song.sampleRate());
}

void draw(){
  background(bg_mario);
  fft.forward(song.mix);
  stroke(127, 255, 0, 200);
  for(int i = 0; i <= fft.getFreq(80)*m; i++){
    image(tube_sec, 10, height-(10+i));
    }
  image(tube_up, 10, height-(74+fft.getFreq(80)*m));
  for(int i = 0; i <= fft.getFreq(150)*m; i++){
    image(tube_sec, 180, height-(10+i));
    }
  image(tube_up, 180, height-(74+fft.getFreq(150)*m));
  for(int i = 0; i <= fft.getFreq(200)*m; i++){
    image(tube_sec, 350, height-(10+i));
    }
  image(tube_up, 350, height-(74+fft.getFreq(200)*m));
  for(int i = 0; i <= fft.getFreq(300)*m; i++){
    image(tube_sec, 520, height-(10+i));
    }
  image(tube_up, 520, height-(74+fft.getFreq(300)*m));
  for(int i = 0; i <= fft.getFreq(400)*m; i++){
    image(tube_sec, 690, height-(10+i));
    }
  image(tube_up, 690, height-(74+fft.getFreq(400)*m));
  for(int i = 0; i <= fft.getFreq(500)*m; i++){
    image(tube_sec, 860, height-(10+i));
    }
  image(tube_up, 860, height-(74+fft.getFreq(500)*m));
  stroke(255);
}

I think it's a simple sketch so I won't explain how does it function.

You can download the sketch and the file you need to run it here.
You can also try a web version here(java required).

The demo song that I put in the zip folder and that I used in the web version is
Drive Hard - PrototypeRaptor

I hope you like my post, if you have any question please comment or send me an e-mail to damianoandre@gmail.com

Bye, Dami

P.S.:probably next week I'm gonna post about a TV B gone made using arduino and an Attiny85

CODEMOTION THE EVENT OPEN TO ALL LANGUAGES AND TECHNOLOGIES

Codemotion is the event open to all languages and technologies. It is the evolution of Javaday Roma, which after four editions has become the event of the art of programming.
The first edition of Codemotion has been in March 2011 and over 2000 people, 25 communities and 22 sponsor firms have become members.
During Codemotion 2011 there have been 65 talks on: gaming, mobile, hacking,  os, tools, what’s hot, language and innovation.
The second edition of Codemotion will be held on 23rd and 24th March and there will be two main innovations: the lengthening of activities from one to two days and the fact that two events will be held simultaneously in Rome and Madrid.
Codemotion’s program will be defined through Call for Paper which is open to everyone. The proposals’ selection will be done by representatives of the official communities which are connected to both the analysis of language and software development.
During Codemotion, all participants will have the chance to have new professional opportunities by leaving  their CV to the sponsor firms.
We are working on a project to promote the relationship between developers and startups and their synergic work for innovation.
Codemotion will be hosted by the Engineering department of the Third University of Rome.
Entry is free, as always.
For any further information contact us on: http://www.codemotion.it

FGES v1.0 released

I released the version 1.0 of FGES(First Grade Equation Solver).
You can download it from here.

I hope you like.
Bye, Dami

Easy Arduino POV

This is a simple project about making a simple POV project using arduino.

What is POV?
 POV stands for Persistence Of Vision and here is a simple definition from wikipedia:
Persistence of vision is the phenomenon of the eye by which an afterimage is thought to persist for approximately one twenty-fifth of a second on the retina.
The POV can be used to write letters simply blinking LEDs.

About the project --> hardware
In the hardware side we only need to connect 7 LEDs to the pins from 2 to 8.

About the project  ---> software
First of all we need an array that contains the matrix of the font that we will write using POV.
This is a simple matrix that we're going to use for the project:

const byte font[][5] = {                     
        {0x00,0x00,0x00,0x00,0x00},   //   0x20 32 0
        {0x00,0x00,0x6f,0x00,0x00},   // ! 0x21 33 1
        {0x00,0x07,0x00,0x07,0x00},   // " 0x22 34 2
        {0x14,0x7f,0x14,0x7f,0x14},   // # 0x23 35 3
        {0x00,0x07,0x04,0x1e,0x00},   // $ 0x24 36 4
        {0x23,0x13,0x08,0x64,0x62},   // % 0x25 37 5
        {0x36,0x49,0x56,0x20,0x50},   // & 0x26 38 6
        {0x00,0x00,0x07,0x00,0x00},   // ' 0x27 39 7
        {0x00,0x1c,0x22,0x41,0x00},   // ( 0x28 40 8
        {0x00,0x41,0x22,0x1c,0x00},   // ) 0x29 41 9
        {0x14,0x08,0x3e,0x08,0x14},   // * 0x2a 42 10
        {0x08,0x08,0x3e,0x08,0x08},   // + 0x2b 43 11
        {0x00,0x50,0x30,0x00,0x00},   // , 0x2c 44 12
        {0x08,0x08,0x08,0x08,0x08},   // - 0x2d 45 13
        {0x00,0x60,0x60,0x00,0x00},   // . 0x2e 46 14
        {0x20,0x10,0x08,0x04,0x02},   // / 0x2f 47 15
        {0x3e,0x51,0x49,0x45,0x3e},   // 0 0x30 48 16
        {0x00,0x42,0x7f,0x40,0x00},   // 1 0x31 49 17
        {0x42,0x61,0x51,0x49,0x46},   // 2 0x32 50 18
        {0x21,0x41,0x45,0x4b,0x31},   // 3 0x33 51 19
        {0x18,0x14,0x12,0x7f,0x10},   // 4 0x34 52 20
        {0x27,0x45,0x45,0x45,0x39},   // 5 0x35 53 21
        {0x3c,0x4a,0x49,0x49,0x30},   // 6 0x36 54 22
        {0x01,0x71,0x09,0x05,0x03},   // 7 0x37 55 23 
        {0x36,0x49,0x49,0x49,0x36},   // 8 0x38 56 24
        {0x06,0x49,0x49,0x29,0x1e},   // 9 0x39 57 25
        {0x00,0x36,0x36,0x00,0x00},   // : 0x3a 58 26
        {0x00,0x56,0x36,0x00,0x00},   // ; 0x3b 59 27
        {0x08,0x14,0x22,0x41,0x00},   // < 0x3c 60 28
        {0x14,0x14,0x14,0x14,0x14},   // = 0x3d 61 29
        {0x00,0x41,0x22,0x14,0x08},   // > 0x3e 62 30
        {0x02,0x01,0x51,0x09,0x06},   // ? 0x3f 63 31
        {0x3e,0x41,0x5d,0x49,0x4e},   // @ 0x40 64 32
        {0x7e,0x09,0x09,0x09,0x7e},   // A 0x41 65 33
        {0x7f,0x49,0x49,0x49,0x36},   // B 0x42 66 34
        {0x3e,0x41,0x41,0x41,0x22},   // C 0x43 67 35
        {0x7f,0x41,0x41,0x41,0x3e},   // D 0x44 68 36
        {0x7f,0x49,0x49,0x49,0x41},   // E 0x45 69 37
        {0x7f,0x09,0x09,0x09,0x01},   // F 0x46 70 38
        {0x3e,0x41,0x49,0x49,0x7a},   // G 0x47 71 39
        {0x7f,0x08,0x08,0x08,0x7f},   // H 0x48 72 40
        {0x00,0x41,0x7f,0x41,0x00},   // I 0x49 73 41
        {0x20,0x40,0x41,0x3f,0x01},   // J 0x4a 74 42
        {0x7f,0x08,0x14,0x22,0x41},   // K 0x4b 75 43
        {0x7f,0x40,0x40,0x40,0x40},   // L 0x4c 76 44
        {0x7f,0x02,0x0c,0x02,0x7f},   // M 0x4d 77 45
        {0x7f,0x04,0x08,0x10,0x7f},   // N 0x4e 78 46
        {0x3e,0x41,0x41,0x41,0x3e},   // O 0x4f 79 47
        {0x7f,0x09,0x09,0x09,0x06},   // P 0x50 80 48
        {0x3e,0x41,0x51,0x21,0x5e},   // Q 0x51 81 49
        {0x7f,0x09,0x19,0x29,0x46},   // R 0x52 82 50
        {0x46,0x49,0x49,0x49,0x31},   // S 0x53 83 51
        {0x01,0x01,0x7f,0x01,0x01},   // T 0x54 84 52
        {0x3f,0x40,0x40,0x40,0x3f},   // U 0x55 85 53
        {0x0f,0x30,0x40,0x30,0x0f},   // V 0x56 86 54
        {0x3f,0x40,0x30,0x40,0x3f},   // W 0x57 87 55
        {0x63,0x14,0x08,0x14,0x63},   // X 0x58 88 56
        {0x07,0x08,0x70,0x08,0x07},   // Y 0x59 89 57
        {0x61,0x51,0x49,0x45,0x43},   // Z 0x5a 90 58
        {0x3c,0x4a,0x49,0x29,0x1e},   // [ 0x5b 91 59
        {0x02,0x04,0x08,0x10,0x20},   // \ 0x5c 92 60
        {0x00,0x41,0x7f,0x00,0x00},   // ] 0x5d 93 61
        {0x04,0x02,0x01,0x02,0x04},   // ^ 0x5e 94 62
        {0x40,0x40,0x40,0x40,0x40},   // _ 0x5f 95 63
        {0x00,0x00,0x03,0x04,0x00},   // ` 0x60 96 64
        {0x20,0x54,0x54,0x54,0x78},   // a 0x61 97 65
        {0x7f,0x48,0x44,0x44,0x38},   // b 0x62 98 66
        {0x38,0x44,0x44,0x44,0x20},   // c 0x63 99 67
        {0x38,0x44,0x44,0x48,0x7f},   // d 0x64 100 68
        {0x38,0x54,0x54,0x54,0x18},   // e 0x65 101 69
        {0x08,0x7e,0x09,0x01,0x02},   // f 0x66 102 70
        {0x0c,0x52,0x52,0x52,0x3e},   // g 0x67 103 71
        {0x7f,0x08,0x04,0x04,0x78},   // h 0x68 104 72
        {0x00,0x44,0x7d,0x40,0x00},   // i 0x69 105 73
        {0x20,0x40,0x44,0x3d,0x00},   // j 0x6a 106 74
        {0x00,0x7f,0x10,0x28,0x44},   // k 0x6b 107 75
        {0x00,0x41,0x7f,0x40,0x00},   // l 0x6c 108 76
        {0x7c,0x04,0x18,0x04,0x78},   // m 0x6d 109 77
        {0x7c,0x08,0x04,0x04,0x78},   // n 0x6e 110 78
        {0x38,0x44,0x44,0x44,0x38},   // o 0x6f 111 79
        {0x7c,0x14,0x14,0x14,0x08},   // p 0x70 112 80
        {0x08,0x14,0x14,0x18,0x7c},   // q 0x71 113 81
        {0x7c,0x08,0x04,0x04,0x08},   // r 0x72 114 82
        {0x48,0x54,0x54,0x54,0x20},   // s 0x73 115 83
        {0x04,0x3f,0x44,0x40,0x20},   // t 0x74 116 84
        {0x3c,0x40,0x40,0x20,0x7c},   // u 0x75 117 85
        {0x1c,0x20,0x40,0x20,0x1c},   // v 0x76 118 86
        {0x3c,0x40,0x30,0x40,0x3c},   // w 0x77 119 87
        {0x44,0x28,0x10,0x28,0x44},   // x 0x78 120 88
        {0x0c,0x50,0x50,0x50,0x3c},   // y 0x79 121 89
        {0x44,0x64,0x54,0x4c,0x44},   // z 0x7a 122 90
        {0x00,0x08,0x36,0x41,0x41},   // { 0x7b 123 91
        {0x00,0x00,0x7f,0x00,0x00},   // | 0x7c 124 92
        {0x41,0x41,0x36,0x08,0x00},   // } 0x7d 125 93
        {0x04,0x02,0x04,0x08,0x04},   // ~ 0x7e 126 94
    };

Then we need to set the pin in the setup() function:


void setup(){
  for(int i = 2; i <= 8; i++){ //I set the digital pin from 2 to 8 as OUTPUT pins
    pinMode(i, OUTPUT);
    }
  for(int i = 2; i <= 8; i++){ //I turn off the pins
    digitalWrite(i, LOW);
    }
  }

Now we have to use 2 for(;;) cycles, one for write each column (in this case 5, it depends from the matrix) and the other one for each row (or each LED). Now we use the bitRead() function to read the bit of a row and to turn on the LED if the bit value is 1.

void loop(){
  for(int col = 0; col <= 5; col++){ //for each column
    for(int row = 0; row <=6; row++){ //and for each row  in a column:
      int val = bitRead(font[33][col], row); //I read the bit of the "A" byte at the current column and in the current row
      if(val==1){
        digitalWrite(row+2,  HIGH); // if the bit value is 1 I turn on the LED that represents the row
        }
      else{
        digitalWrite(row+2, LOW); // if the bit value is  0 I turn off the LED
        }
      }
      delay(3); //before starting  with the next column I delay 5 milliseconds
    }
    delay(100);
  }

You can download the full code at this link.

Here are some photos of the project:

I hope you enjoy this project, for more info comment or send me an e-mail to damianoandre@gmail.com

Bye, Dami

Processing Text-image generator Processing

This is a simple post about a processing sketch that makes you able to generate from a normal image an image like this, formed by letter/numbers of differents colors.

This is the processing sketch:

PImage img;
String txt = "hello"; //here goes your text
float spacex = txt.length()*2.9;
//you should need to recalibrate this variable
float spacey = 5.0;

void setup(){
  img = loadImage("img2.jpg");
  size(img.width*2, img.height*2);
  noStroke();
  background(255);
  smooth();
  }

void draw(){
  for(int xpix = 0; xpix <= img.width; xpix += spacex){
    for(int ypix = 0; ypix <= img.height; ypix += spacey){
      color pixcol = img.get(xpix, ypix);
      fill(pixcol);
      text(txt, int(map(xpix, 10, img.width, 10, img.width*2)), int(map(ypix, 10, img.height, 10, img.height*2)));
      }
    }
    saveFrame("img-text.jpg");
  }

This sketch simply create the image getting the color of the processed pixel and save the final result (saveFrame) as an image.
This sketch can generate from this image:

this image:

I hope you like this post, if you have questions comment or send me an e-mail to damianoandre@gmail.com

Bye, Dami

P.S.:the sketch it's calibrated to wite "0" but if you want to write something else you have to recalibrate some things.

10024 total blog views :DD

Hi,
I'm happy to say that my blog have more than 10000 total views :DD
Bye, Dami

Arduino and processing led blinking following music rythm

Hi,
Today I'm writing about a simple project with Arduino and Porcessing to blink 5 LEDs following the music rythm.
To do it we need an audio librari for processing called minim, (created by Damien di Fede) and we need the Firmata library for communicating to Arduino.
For this project you need:
-Arduino board
-5 LEDs (1,8-2v)
-5 220ohm resistors
-breadboard
-some wires
-arduino library for processing (http://www.arduino.cc/playground/Interfacing/Processing)
-minim audio library(http://code.compartmental.net/minim/distro/minim-2.0.2-lib.zip)

First of all prepare the simple connections on your breadboard following this image:

Then open the arduino software and upload the standardFirmata sketch (File>examples>Firmata>StandardFirmata).
Now, before writing the processing code I'd like to tell you something aboute the libraries we're going to use: Firmata is a library made for communciating between processing and Arduino. When you run Firmata in arduino, you can call arduino functions from processing using the arduino library for processing.
The minim library is an audio library for processing, I think it's the best library about audio and sound for processing because it's easy to use but have lots of functions. For the reference chek this link: http://code.compartmental.net/tools/minim/.
Now download the libraries and write the following code in a processing sketch:

import ddf.minim.*;
import ddf.minim.signals.*;
import ddf.minim.analysis.*;
import ddf.minim.effects.*; //Import ddf.minim library
import processing.serial.*; //Import serial library
import cc.arduino.*; //Import Arduino library

Arduino arduino;
Minim minim;
AudioPlayer song;
FFT fft;
//I create the objects

//To play another song change the song_file value
String song_file = "song.mp3";
int xmax = 600; //window width
int ymax = 300;//window height

void setup()
{
  size(xmax, ymax);
  minim = new Minim(this);
  arduino = new Arduino(this, Arduino.list()[1], 57600);
  song = minim.loadFile(song_file);
  song.play();
  fft = new FFT(song.bufferSize(), song.sampleRate());
  // in this function I create the minim object, I start
  //communicating with Arduino,I load the song and I play it and
  // I start the Fast Fourier Transofrm
}

void draw()
{
  background(0);
  fft.forward(song.mix);
  stroke(127, 255, 0, 200); //I set the color of my lines
  for(int i = 10; i < fft.specSize(); i++){
    line(i, height-30, i, height - (30+fft.getFreq(i*10)));
    // I create lines that represent the amplitude
    // of each frequency.
    text("Min Freq", 10, height-10);
    text("Max Freq", fft.specSize(), height-10);
  }
  ledcontrol(); //I call the function for the arduino
}

void ledcontrol(){
  //In this function I use arduino analogWrite function
  // to write in PWM pins the amplitude
  // of five general frequency
  arduino.analogWrite(3, int(fft.getFreq(500)));
  arduino.analogWrite(5, int(fft.getFreq(400)));
  arduino.analogWrite(6, int(fft.getFreq(250)));
  arduino.analogWrite(9, int(fft.getFreq(150)));
  arduino.analogWrite(10, int(fft.getFreq(80)));
  }

The code is simple so I think it's not necessary to explain it.
You can download the project files (.zip) here: download.
Here is a test:

For more information about the project comment or send me an e-mail to damianoandre@gmail.com

Bye, Dami