electronics

bass!

for a project in collaboration with stine janvin motland i built this 4-channel transducer bass shaker system.

the system has four transducers (visaton bs 130, 4Ω), two class d stereo amplifiers (2x50w, tda7492 chip) and a powerful atx switching power supply (codecom pm-350c).

i modified the power supply to only give out 12v (yellow&black cables) and also made it start up automatically by shorting the green cable (ps-on) to ground (black).

transducers 1

transducers 2

there's no volume control so better take care - the system is very hot.

audioSerial

clean-up: #56

compared to generating a serial bitstream in audio, analyzing and extract serial data from audio is much harder. the supercollider code below does it, but the program has limitations and is quite sensitive for noise.

the code takes a string, chops it up into groups of six 8bit bytes and generates a serial audio bitstream from that. another part listens to this sound and tries to decode it. if it finds six full bytes it sends the result back to sclang via osc where it is printed.
to test the example connect an audio cable directly from your computer's output to its input (preferably via a small mixer), or change the audioSerial synthdef to use an internal audio bus. i can also imagine it could function with a mic next to the speakers - but i didn't test this.
if it only prints gibberish try with a different threshold setting, different volume on you computer or use a lower baud rate.

(
s.waitForBoot{
        var baudrate= 9600;
        SynthDef(\serialAudio, {|out= 0, amp= -0.5|                     //for sending out serial via audio
                var data= Control.names([\data]).kr(Array.fill(60, 0)); //max 6 bytes
                var src= Duty.ar(1/baudrate, 0, Dseq(data), 2);
                OffsetOut.ar(out, src*amp);
        }).add;
        SynthDef(\audioSerial, {|in= 0, thresh= 0.05|           //for receiving serial via audio
                var raw= 0-SoundIn.ar(in); //here change to In.ar if trying internal audio bus
                var src= raw>thresh;
                var reading= DelayC.ar(Trig1.ar(src, 1/baudrate*9), 1/baudrate/2, 1/baudrate/2);
                var osc= Phasor.ar(reading, baudrate/SampleRate.ir);
                var clock= (osc-Delay1.ar(osc))<0+Impulse.ar(0);
                var index= PulseCount.ar(clock, reading);
                var stopTrig= index>7;
                var data= Latch.ar(src, index>=#[7, 6, 5, 4, 3, 2, 1]);
                var byte= (1-data).sum{|x, i| 2**(6-i)*x};
                SendReply.ar(stopTrig, '/data', byte);
                DC.ar(0);
        }).add;
        OSCFunc({|msg| msg[3].asInteger.asAscii.post}, '/data');
        s.sync;
        Synth(\audioSerial);
};
)

(
var str= "hello supercollider!";
var baudrate= 9600;
fork{
        1.wait;
        str.ascii.clump(6).do{|bytes|
                var data= bytes.collect{|x| [1]++(1-x.asBinaryDigits.reverse)++[0]}.flat;
                s.bind{
                        Synth(\serialAudio, [\data, data]);
                };
                (1/baudrate*60+0.005).wait;
        };
};
)

one can use this technique to communicate with another computer via audio. to communicate with a microcontroller (e.g. an arduino), one needs additional electronics (amplification, rectification). here's schematics for a bi-directional circuit for talking to a 5v arduino.

this audio-to-serial technique was used to get input from rfid, touch and bend sensors in our reflect installation. i.e. sc is running on an ipod touch and receives all sensor data via audio from an atmega168 microcontroller.

serialAudio

clean-up: #55

another way (compared to fsk in my previous blog entry) of sending data via audio is to directly generate the serial bit stream using supercollider.

to test and learn about these things i first wrote and uploaded a very simple program to an arduino board. the program just transmitted the bytes 128, 10, 20, 30, 40 and 50.

//arduino testcode
void setup() {
  Serial.begin(9600);
}
void loop() {
  delay(1000);
  Serial.write(128);
  Serial.write(10);
  Serial.write(20);
  Serial.write(30);
  Serial.write(40);
  Serial.write(50);
}

then i connected the arduino serial tx pin (pin1) to the audio line-in of my laptop (via a 1k + 10k voltage divider) and recorded the sound of the serial transmission.

i then analyzed the sound by hand and wrote a little program in sc that could generate similar waveforms.

s.boot;
o= {|chr| [1]++(1-chr.asBinaryDigits.reverse)++[0]};
(
SynthDef(\serialAudio, {|amp= -0.5|     //for sending out serial via audio
        var data= Control.names([\data]).kr(Array.fill(60, 0));//max 6 bytes
        var src= Duty.ar(1/9600, 0, Dseq(data), 2);     //baudrate
        OffsetOut.ar(1, src*amp);
}).add;
)
Synth(\serialAudio, [\data, [128, 10, 20, 30, 40, 50].collect{|c| o.value(c)}.flat, \amp, -0.5]);

this screenshot show the signal recorded from the arduino in the first channel, and the supercollider generated one in the second.

after all this i could reverse the process, generate any serial data and send it back to the arduino rx pin (pin0). a small amplifier circuit in between helped to get a more stable communication going.

this serial-to-audio technique was used to control the 24 leds (6 pwm channels) in our reflect installation. i.e. sc is running on an ipod touch and sends out serial audio to an atmega168 microcontroller.

here is another example that can fade a single led by sending serial commands over audio. includes schematics for an amplifier circuit plus sc and pd example code.

and for a more advanced (actually using a much better technique) example see here

redUniform2

for an upcoming performance i've revisited the electronics for my redUniform piece. my old setup used a nordic nRF24L01 wireless chip but now i changed to wifi and the adafruit cc3000 module.

the circuit is really minimal and simple. basically it's just the cc3000 wifi module, an atmega328, a 16Mhz chrystal, an on/off switch, one 1000mAh Li-ion and last two 6p connectors for the sensors.

the sensors are two modified minIMU-9.


with the battery fully charged i had it sending osc data at 50hz for more than a whole day.

attached are schematics and arduino code for reading sensors via spi. the code also show how to talk to the cc3000 and send sensor data via osc.
there are also two classes for supercollider called RedUniform2 and RedUniform2GUI.

redAlertLight

for a new piece i'm working on (redAlert) i wanted hundreds of red leds attached to special 'blobs' or lamps spread out on stage (designed by Jenny Michel). each led should be able to be freely placed and controlled individually and they had to be fairly bright. and because of the custom led placement i couldn't have used led strips - strips have a fixed distance between the leds.

so i built three circuits that could drive 32 pwm channels each and thereby got 96 pwm channels in total. each channel connects three leds in series (in a single package) and a resistor. that makes in total 288 leds.

the led i selected was the LED 5252 uh rt/1700mcd. it has 120 degrees spread angle and comes in a 5x5mm 6pin smd package that's possible to solder by hand. i bought it from segor where it costs 0.42 euro if you buy +100.

here a picture of it from the back side. the 270ohm resistor is chosen to match 12v and the three leds are connected in series using thin copper wire.

redAlertLight01

the three boards are controlled wirelessly and i send osc commands from supercollider to control all the leds. there's a class for supercollider attached below that helps with addressing and packaging of the network data. one can build and connect as many of these 32ch boards as one likes.

for actually generating the 12v pwm i used on each board two tlc5490 in combination with four uln2803a. and i also added a barebone arduino to get a stable spi communication with the tlc5490.

redAlertLight00

back side...
redAlertLight02

for receiving wireless osc data i added a raspberry pi (model a) with an usb wlan stick. on the rpi there's just a small python program that receives osc and sends out serial commands to the arduino.

last i have a tp-link TL-WR703N with open wrt installed acting as a router. when the boards start up they try to connect to this router and gets an ip assigned dynamically. this ip i use in supercollider to differentiate between the three boards.

installation instructions

//--
* put 2013-09-25-wheezy-raspbian.img on a sd-card with Pi Filler
* put the card in a raspberry pi MODEL B, connect ethernet and 5v
* find the IP with LanScan.app

(* ssh-keygen -R 192.168.1.51)
* ssh pi@192.168.1.51
* default password: raspberry
* sudo raspi-config
* select 'Expand Filesystem', change password, reboot and log in with ssh again

* sudo apt-get update
* sudo apt-get upgrade
* sudo pico /etc/inittab
* comment out the line 'T0:23:respawn:/sbin/getty -L ttyAMA0 115200 vt100' near the bottom and save
* sudo pico /boot/cmdline.txt
* remove 'console=ttyAMA0,115200 kgdboc=ttyAMA0,115200' and save
* sudo reboot

* sudo apt-get install python-serial
* git clone git://gitorious.org/pyosc/devel.git
* cd devel
* sudo ./setup.py install
* cd ~

//--set up wlan on the rpi
* sudo nano /etc/network/interfaces
* edit to say...
        auto wlan0
        allow-hotplug wlan0
        iface wlan0 inet dhcp
                wpa-ssid SSID_NAME
                wpa-psk SSID_PASS
                wireless-power off
* sudo ifdown wlan0
* sudo ifup wlan0

//--copy file from laptop to rpi
* scp redAlertLight.py pi@192.168.1.51:/home/pi/

//--automatically start the python program at startup
* sudo pico /etc/rc.local
* add the following before the exit line: (sleep 1; python /home/pi/redAlertLight.py) & # autostart

//now move the sd card over to model a, connect the circuit and try

//--useful if you log in via ssh and want to stop the python program
* sudo pkill python

here is the python code...

#redFrik 2013

import serial
import socket
import OSC
import threading
import time
import os

addy= '0.0.0.0', 15000  #from sc
osc_server= OSC.OSCServer(addy)

port= serial.Serial('/dev/ttyAMA0', 115200)     #to atmega168
port.open()

def osc_led(addr, tags, data, source):
        #print tags
        #print "incoming osc data: %s" % data
        arr= bytearray()
        arr.append(254)
        for val in data:        #data has size 16 (24bit ints)
                hi_val= val>>12
                lo_val= val&4095
                #here can be optimized later to send fewer bytes (48 instead of 64)
                arr.append(hi_val>>8)
                arr.append(hi_val&255)
                arr.append(lo_val>>8)
                arr.append(lo_val&255)
        arr.append(255)
        port.write(arr)

osc_server.addMsgHandler("/led", osc_led)

def osc_stop(addr, tags, data, source):
        #print tags
        #print "shutting down"
        shutdown()

osc_server.addMsgHandler("/stop", osc_stop)

thread= threading.Thread(target= osc_server.serve_forever)
thread.start()

def all_led_off():
        osc_led(None, None, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], None)

def shutdown():
        close()
        os.system("sudo halt")
        exit()

def close():
        print "\nclosing"
        osc_server.close()
        all_led_off()
        port.close()
        #thread.join()

def main():
        try:
                while True:
                        line= port.readline()
                        if line.startswith("stop"):
                                shutdown()
        except KeyboardInterrupt:
                close()

if __name__ == "__main__":
        main()

attached is schematics, arduino firmware, partslist...

AttachmentSize
Image icon redAlertLight_schem.png1.5 MB
Package icon redAlert_mega168.zip1.1 KB
Plain text icon partlist.txt533 bytes
Package icon RedAlertLight.zip7.58 KB

redThermoKontroll2

for my upcoming solo at the sound of stockholm festival, i decided to rebuild my main wireless controller. previously it used a nordic nRF24L01+transceiver as radio module, but the range wasn't great and communication often broke down during live performances. i don't know much about these things, but i guess that when the audience bring in mobile phones the radio spectrum quickly fills up.

so i constructed a new circuit from scratch and while i was at it also reworked the resistor ladders and other cabling inside the box. now it's using wifi. the new radio module i installed in the controller box is adafruit's great CC3000 WiFi Breakout, and as receiver i use a small tl-wr703n wifi router running openwrt.
the wireless range is now excellent and everything is a lot more stable. i could also drastically reduce the amount of data being sent by fixing the resistor ladders.

circuit... (basically just one atmega382p, a 16 channel adc, voltage divider resistors and the wifi module)

redThermoKontroll2-00

inside...
redThermoKontroll2-01

outside...
redThermoKontroll2-02

100ohm resistor ladder...

redThermoKontroll2-03

below are parts list, schematics, firmware and a supercollider class.

redThermoKontroll (wifi version) parts list:

1 4067 multiplexer
1 atmega328p
1 16mhz crystal
2 27p
1 socket 2x14 (28pin)
1 adafruit cc3000 module
1 1x9 pin header
1 1x10 pin header
1 1x8 pin header
1 1x5 pin header

1 resettable fuse 1a
1 zener diode 5.6v
1 0.1uF cap
1 100uF electrolytic cap
1 470uF electrolytic cap

10 220, 270, 330, 680, 1k, 2, 10k resistors
1 220 resistor for led

1 power jack
1 ldr
1 red led

lots of 100ohm resistors for resistor ladders

redThermoKontroll-schematics2

//redThermoKontroll2
//redFrik 2013 gnu gpl v2
//updated 150920 - automatically send to IP x.x.x.99 (constructed from given DHCP IP)

//make sure to use Paul Stoffregen's branch of the Adafruit_CC3000 library
//and cc3000 firmware 1.24 (1.11.1)
//select board UNO and upload to a ATMEGA328P chip (using a usbtinyisp programmer)
//test in terminal with command: nc -ul 58100

#include <Adafruit_CC3000.h>
#include <ccspi.h>
#include <SPI.h>

#define WLAN_SSID       "xxx"
#define WLAN_PASS       "yyy"
#define WLAN_SECURITY   WLAN_SEC_WPA2

#define PORT            58100
#define DELAY           10
#define PINGRATE        2000

#define ADAFRUIT_CC3000_IRQ   3   //mega328 pin 5
#define ADAFRUIT_CC3000_VBEN  8   //mega328 pin 14
#define ADAFRUIT_CC3000_CS    10  //mega328 pin 16
Adafruit_CC3000 cc3000 = Adafruit_CC3000(ADAFRUIT_CC3000_CS, ADAFRUIT_CC3000_IRQ, ADAFRUIT_CC3000_VBEN, SPI_CLOCK_DIVIDER);
Adafruit_CC3000_Client client;

uint8_t buf[16];
byte last[] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

byte cnt = 0;
unsigned long time;

void setup(void) {
  Serial.begin(115200);  //debug

  //--pins
  pinMode(7, OUTPUT);         //led
  pinMode(6, OUTPUT);         //4067 d (DDD6)
  pinMode(5, OUTPUT);         //4067 c (DDD5)
  pinMode(4, OUTPUT);         //4067 b (DDD4)
  pinMode(2, OUTPUT);         //4067 a (DDD2)
  pinMode(A5, INPUT);         //4067 x
  pinMode(A4, INPUT_PULLUP);  //capa1 (right)
  pinMode(A3, INPUT_PULLUP);  //capa0 (left)
  pinMode(A2, INPUT_PULLUP);  //swiUp (up)
  pinMode(A1, INPUT_PULLUP);  //swiUp (down)
  pinMode(A0, INPUT_PULLUP);  //swiOn

  //--wifi
  flash(1);
  Serial.println(F("Starting"));
  if (!cc3000.begin()) {
    Serial.println(F("Unable to initialise the CC3000! Check your wiring?"));
    while (1);
  }
  flash(2);
  Serial.println(F("\nDeleting old connection profiles"));
  if (!cc3000.deleteProfiles()) {
    Serial.println(F("Failed!"));
    while (1);
  }
  cc3000.connectToAP(WLAN_SSID, WLAN_PASS, WLAN_SECURITY);
  Serial.println(F("Connected!"));
  flash(3);
  Serial.println(F("Request DHCP"));
  while (!cc3000.checkDHCP()) {
    delay(100); // ToDo: Insert a DHCP timeout!
  }
  uint32_t ipAddress, netmask, gateway, dhcpserv, dnsserv;
  while (!cc3000.getIPAddress(&ipAddress, &netmask, &gateway, &dhcpserv, &dnsserv)) {
    Serial.println(F("Unable to retrieve the IP Address!"));
    delay(100);
  }
  Serial.print(F("\nCC3000 IP Addr: "));
  cc3000.printIPdotsRev(ipAddress);
  //the following sets receiver to x.x.x.99 and assume cc3000 will never get exactly that IP itself
  ipAddress = cc3000.IP2U32(ipAddress >> 24 & 255, ipAddress >> 16 & 255, ipAddress >> 8 & 255, 99);
  Serial.print(F("\nReceiver IP Addr: "));
  cc3000.printIPdotsRev(ipAddress);
  client = cc3000.connectUDP(ipAddress, PORT);

  //--osc message [/tk2, index, value]
  buf[0] = 47;   // /
  buf[1] = 116;  // t
  buf[2] = 107;  // k
  buf[3] = 50;   // 2
  buf[4] = 0;
  buf[5] = 0;
  buf[6] = 0;
  buf[7] = 0;
  buf[8] = 44;   // ,
  buf[9] = 105;  // i
  buf[10] = 0;
  buf[11] = 0;
  buf[12] = 0;   //msb - index
  buf[13] = 0;   //
  buf[14] = 0;   //
  buf[15] = 0;   //lsb - value
}

void loop(void) {
  byte val;

  //--analog inputs
  for (byte i = 0; i < 13; i++) {
    setChan(i);
    delay(1);                //not sure if needed
    val = analogRead(A5) >> 2; //from 10 to 8 bits
    if (val != last[i]) {
      sendOsc(i, val);
      last[i] = val;
    }
  }

  //--digital inputs
  val = PINC & 0b00011111;
  if (val != last[13]) {
    sendOsc(13, val);
    last[13] = val;
  }

  //--ping
  if (millis() - time > PINGRATE) {
    sendOsc(127, 0);      //ping
    time = millis();
  }
}

void sendOsc(byte index, byte val) {
  buf[12] = index;
  buf[15] = val;
  if (cnt++ % 2 == 0) {   //toggle red led
    PORTD &= ~_BV(DDD7);
  }
  else {
    PORTD |= _BV(DDD7);
  }
  client.write(buf, sizeof(buf));
  delay(DELAY);
}

void setChan(byte index) {
  switch (index) {
    case 0:
      PORTD &= ~_BV(DDD2);                                      //low
      PORTD &= ~_BV(DDD4);                                      //low
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 1:
      PORTD |= _BV(DDD2);                                               //high
      PORTD &= ~_BV(DDD4);                                      //low
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 2:
      PORTD &= ~_BV(DDD2);                                      //low
      PORTD |= _BV(DDD4);                                               //high
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 3:
      PORTD |= _BV(DDD2);                                               //high
      PORTD |= _BV(DDD4);                                               //high
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 4:
      PORTD &= ~_BV(DDD2);                                      //low
      PORTD &= ~_BV(DDD4);                                      //low
      PORTD |= _BV(DDD5);                                               //high
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 5:
      PORTD |= _BV(DDD2);                                               //high
      PORTD &= ~_BV(DDD4);                                      //low
      PORTD |= _BV(DDD5);                                               //high
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 6:
      PORTD &= ~_BV(DDD2);                                      //low
      PORTD |= _BV(DDD4);                                               //high
      PORTD |= _BV(DDD5);                                               //high
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 7:
      PORTD |= _BV(DDD2);                                               //high
      PORTD |= _BV(DDD4);                                               //high
      PORTD |= _BV(DDD5);                                               //high
      PORTD &= ~_BV(DDD6);                                      //low
      break;
    case 8:
      PORTD &= ~_BV(DDD2);                                      //low
      PORTD &= ~_BV(DDD4);                                      //low
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD |= _BV(DDD6);                                               //high
      break;
    case 9:
      PORTD |= _BV(DDD2);                                               //high
      PORTD &= ~_BV(DDD4);                                      //low
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD |= _BV(DDD6);                                               //high
      break;
    case 10:
      PORTD &= ~_BV(DDD2);                                      //low
      PORTD |= _BV(DDD4);                                               //high
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD |= _BV(DDD6);                                               //high
      break;
    case 11:
      PORTD |= _BV(DDD2);                                               //high
      PORTD |= _BV(DDD4);                                               //high
      PORTD &= ~_BV(DDD5);                                      //low
      PORTD |= _BV(DDD6);                                               //high
      break;
    case 12:
      PORTD &= ~_BV(DDD2);                                      //low
      PORTD &= ~_BV(DDD4);                                      //low
      PORTD |= _BV(DDD5);                                               //high
      PORTD |= _BV(DDD6);                                               //high
      break;
  }
}
void flash(int num) {
  for(byte i= 0; i<num; i++) {
    digitalWrite(7, HIGH);
    delay(100);
    digitalWrite(7, LOW);
    delay(100);
  }
}

AttachmentSize
Package icon redThermoKontroll2-supercollider.zip8.59 KB

arduino programming via soundcard

with lots of study of the AudioBoot_V2_0 java code by chris at roboterclub-freiburg.de, i managed to write supercollider code for uploading sketches to an arduino via the soundcard. no ftdi chip needed!
it's a very cheap solution for programming barebone arduinos (well, atmega168 microcontrollers really). you only need a few resistors, a capacitor and a mega168. the only difficult part is to 'initialize' this microcontroller by burning the special bootloader on to it. this requires an avr programmer of some sort (STK500, USBtinyISP etc).

the preparation steps are as follows...
1. burn the bootloader on to a mega168
2. build the barebone circuit
3. prepare the arduino ide
4. install the RedArduino class

after that one can compile hex files in the arduino ide and upload them using supercollider and a standard audio cable.

1. burn the bootloader on to a mega168

the trick behind all this is the special 'sound enabled' bootloader that i found here... http://www.hobby-roboter.de/forum/viewtopic.php?f=4&t=127. i downloaded the AudioBoot_V2_0.zip file and used my stk500 avr programmer together with the great avr crosspack. the terminal command i used for burning the bootloader was the following...

avrdude -v -p m168 -b 115200 -P /dev/tty.PL2303-000013FA -c stk500v2 -U flash:w:/Users/Stirling/arbeten/sc/scAudioino/AudioBoot_V2_0/Atmega_Source/chAudioBoot_ATMEGA168_IN_PD1_LED_PB5.hex -U lfuse:w:0xE2:m -U hfuse:w:0xDF:m -U efuse:w:0xFA:m

2. build the barebone circuit

then i built a minimal and barebone arduino circuit after the schematics found here... http://www.hobby-roboter.de/forum/viewtopic.php?f=4&t=128&p=531. again credit to chris.

this is the schematics i drew...

and here the resulting circuit...


i run it off 4,5v (3 batteries) but it could also be powered from the usb port.

3. prepare the arduino ide

to compile hex files for this barebone arduino, i needed to set up a custom board in the arduino ide. one way to do this is to create a new text file called boards.txt and put it inside a new folder in the arduino/hardware folder. on mac osx that could be something like ~/Documents/Arduino/hardware/BareBones/boards.txt. the boards.txt should contain the following...

minimal168.name=ATmega168 bare bone (internal 8 MHz clock)
minimal168.upload.speed=115200
minimal168.bootloader.low_fuses=0xE2
minimal168.bootloader.high_fuses=0xDD
minimal168.bootloader.extended_fuses=0×00
minimal168.upload.maximum_size=16384
minimal168.build.mcu=atmega168
minimal168.build.f_cpu=8000000L
minimal168.build.core=arduino:arduino
minimal168.build.variant=arduino:standard

then restart the arduino ide and under boards there should be a new option with mega168 and 8mhz internal clock. i make sure this board is selected every time before compiling hex files for sound uploading.
another thing that needs to be done is to enable 'verbose compile' in the arduino ide preferences. that will print out the file path of the hex file each time you compile a sketch.

4. install the RedArduino class

i wrote a couple of classes for supercollider to help with the encoding and signal generation of hex files. they're found in my redSys quark (under redTools) and are most easily installed from within supercollider itself with these commands...

Quarks.checkoutAll;             //update
Quarks.install("redSys");       //install. recompile after this

there are two helper classes and one main class. the RedIntelHex class parses hex files and RedDifferentialManchesterCodeNegative helps to encode the signal as differential manchester code. the main class RedArduino figures out the paging of data and generates a bit stream that is played back using demand rate ugens.

uploading

i upload sketches by compiling them in arduino ide (click verify - not upload) and copy&paste the file path of the resulting hex file into supercollider and the RedArduino's read method. i connect the left sound output channel to the barebone arduino, put my mac volume to ~80%. last i press the reset button on the circuit and quickly (within seconds) call the upload method in sc. the led should blink slowly directly after a reset, and fast when receiving data.

here's a video demonstrating how to do it. i'm just uploading the simple Blink example. near the end you will also hear how that sounds.

audioino from redFrik on Vimeo.

there's also some sc code i wrote here that will do the same thing but without the need of the redSys quark classes.

trash or treasure

some weeks ago i found a canon pixma MP510 on the street. a "Photo All-in-One with economical single inks that prints, copies or scans in colour". someone had thrown it away regarding it as a piece of junk. i saw a pile of gold.

taking it apart i got...
* four really nice motors: two steppers and two dc motors
* a 33x25 cm piece of glass
* boxed and reusable 220v powersupply
* a small lcd colour display
* a scanner head
* some leds
* five infrared sensors (paper sensors)
* lots of screws and springs
* wire and cog belts
* some switch buttons
* two usb jacks
* various other components



alike http://makezine.com/projects/dont-waste-ewaste-unmaking-a-canon-printerscannerfax-into-parts/

Pages

Subscribe to RSS - electronics