A friend of mine bought this vintage keyboard: a Farfisa Matador (Mod. 611-E) coming directly from the ’70s. By the way the seller forgot to mention that, despite being very well conserved on the outside, it produced a strong and unpleasant hiss that made it almost unusable; it sounded like a out-of-tune chord, so the guy said it was just some dirt under the keys. False…

So I had the honour to put my hands inside this beautiful keyboard. I want to share this experience with you posting some photos I made during the troubleshoot process (se serve una traduzione in italiano chiedete nei commenti).

An overview of the Farfisa family can be found at combo-organ.com, luckily the schematics are available as well: Farfisa.org.

Overview

Serial n° 6338/147

Inside

The Matador is based on the subtractive sysnthesis in which 12 oscillators (one for every semi-tone: DO, RE#, RE, MI …) produce 12 square waves at fixed frequency. These signals are frequency multiplied and distributed across the octaves of the keyboard. When a key is pressed, the square signal is routed toward the the filters (treble and bass filters), the vibrato/percussion board and, finally, the output amplifier.

Filters board (left) and Percussion/Vibrato board (right)

Draw-bar switches (basically small metal flexible coils are bended by the plastic drawbar, touching the wire next to them)

Output amplifier (push-pull with 2 power NPN).
The number 7340 is marked on the two transistors: this could be the date of production (1973, 40th week) but I’m not sure about that.

Under the keyboard, the 12 oscillators.

Repair

As I said, a continuous unpleasant noise was plaguing the output sound of the keyboard. So, with my oscilloscope, I started to trace back the noise from the output amplifier toward the oscillators, in order to find out its origin.

At last, I found the problem. The Manual Bass circuit has a small pre-amplifier, which takes its power supply from the 12 V line. In order to reduce the noise, a large electrolytic capacitor is used as pre-amp power decoupler (It’s called Cc31, in DWG4, if you downloaded the schematic).
By the way, it turns out that after almost 40 years of life, this capacitor has lost its ability to filter out the noise (and there’s a lot of noise in this keyboard: there are 12 square-wave oscillators and lot of wires everywhere).

The solution is quite simple: I replaced the old component with a new one of the same value (1000 uF, 16V).

Removing the failed capacitor

The new one, in place.

A dust cleaning and minor adjustments were the only additional interventions needed by this awesome Farfisa to come back to rock !

The theory behind this circuit seems to be obscure as we can find lot of comments and questions like: “can I add turns ?”, “can I increase the resistor ?”, “will it work with two batteries ?” and so on…

I decided to figure out the working mechanism of this smart circuit in order to understand the rules behind it and try to improve the efficiency. I’ll carry out a theoretical analysis, supported by some scope screen-shots.

I’ll split the study in two parts:

I- Transistor ON

Let’s imagine to link the circuit to the battery. Forget the transformer for a second. The current has three possible paths:

• It flows through the secondary and enter into the emitter of the BJT (=> MAYBE, only if the transistor is turned on somehow, which means vBE >= vBEon)
• It flows through the secondary and enter into the LED (=> NO, since the Vt of the LED is about 3 V and our battery is just 1 V. we can’t forward bias it.)
•  It flows through the primary and enter into the base of the BJT (=> YES, since the turn on-voltage of the base of a silicon transistor is about 0,6V)

We can conclude that the transistor is ON, the next step is to determine the currents flowing through its terminals and its region of operation.
The transformer helps us in this task: iB (base current) flows in the primary winding, iC (collector current) flows in the secondary. According to the laws of an ideal transformer (the sum of the currents is zero), these two currents are equals (iB = iC). We can therefore state that the transistor is not in the active forward region (iC should be hFE times greater than iB, this is not the case) but it is more likely in the saturation region.

It’s time to study the voltage levels across the transformer. On the secondary winding we have the BJT in saturation (vCE = vCEsat ~ 0,2V) so almost the entire VCC is presented across the transformer. This tension -(VCC – vCEsat) is presented on the primary side (ideal transformer).

Let’s calculate the voltage across the base resistor. It easy to compute and it is equals to VCC minus the voltage of the primary winding and minus the voltage of the base-emitter junction, therefore vR = VCC – vPRI – vBEon (in which we can substitute vPRI with – VCC + vCEsat as seen earlier).
Now we can determine the current flowing through the resistor iR, which is also the base current iB.

iB = iR = vR / R = ( VCC + VCC – vCEsat – vBEon ) / R

Under the assumption of a 1V battery and a silicon BJT we can state that VCC is almost equal to (vCEsat + vBEon). Thus, the approximate version of the current is:

iB = VCC / R

Before we treated our transformer as an ideal component but that is not 100% exact. A real transformer has also a magnetizing inductance, we’ll call it L. This impedance is responsible of a build up of energy inside the magnetic core (later used to light up the led). Let’s put L in parallel to the secondary winding to facilitate our study.

As every inductance, its current is a function of the voltage across the terminals and its value in Henry:

iL(t) = (vSEC / L)*t = [(VCC - vCEsat)/L]*t ~ (VCC/L)*t

The total current passing through the collector of the BJT is therefore the sum of two current:

1.  the copy on the secondary winding of the base current, created by the ideal transformer
2.  the magnetizing current that builds up inside the magnetizing inductance

so iC(t) = iB + iL(t).

Every voltage and current are now known and life is good… until the switching time.

Scheme 1: equivalent circuit (BJT ON)

The switch-off

As we have seen, the magnetizing inductance increases the collector current, linearly with the time. After a certain delay, the current through the transistor will be too high for the actual base current. An increase of iB would be necessary but it is not possible, because it is fixed by resistor R. The BJT tries to compensate this, increasing the vCE voltage but, because of the transformer, this will trigger a reduction of the tension across the base resistance. The result is a decreasing in the base current (exactly the opposite of what would be necessary to keep the BJT conducting in saturation). This trigger a new increase in vCE, which trigger a new decrease of iB… and so on. Until the complete turn off of the transistor.
To resume: when the magnetizing current reach a certain value (tens of time bigger than iB), the BJT is forced to change its operation region but the only viable solution in an automatic turn-off.

The current switch-off threshold is fixed by the temperature, the current gain of the transistor (hFE) and the base current.

II- Transistor OFF

The magnetizing current, now at its maximum value of iLmax, can’t disappear and therefore it needs a way to flow. Its previous path, the BJT, in now OFF thus the only solution is the LED. Despite the high threshold level, it is forward biased and so the LED finally lights up.

The voltage on the secondary is now:
vSEC = vLED – VCC (positive, because we assume that vLED > VCC).
This voltage is transfered to the primary winding as well, keeping the BJT base reverse biased.

In this case the magnetizing inductance L is forced to decrease its current:
iL(t) = iLmax – (vSEC / L)*t = iLmax – (vLED – VCC)/L*t

After a certain amount of time, iL current reaches 0 and the LED turns off. All the energy stored as magnetic field inside the transformer is now gone and a new cycle can start.

Scheme 2: equivalent circuit (LED ON)

Warning: use always a load, otherwise high (BJT killer) tensions will build up across the transformer.

Screenshots

I measured the current with a 8 Ohm shunt. In picture 1 is very easy to see the positive ramp caused by the small build up of magnetizing current created by VCC (@1V) and the fast discharge caused by the LED (@3,5V)

Figure 1: magnetizing current (peak: 45 mA, freq: 65 kHz)

In picture 2 I changed the base resistor to a smaller one. Increasing the base current, an higher current peak is reached, as stated in the theoretical part. This means a brighter LED.

Figure 2: magnetizing current (peak: 58 mA, freq: 50 kHz)

The slopes of the current are unchanged (only modification of VCC, vLED or L can influence that).

Building Tips

The aim is to have the good amount of current through the LED while keeping the base current (which is wasted) as small as possible.
Keeping the switching frequency low can reduce BJT losses as well.

The key factor to efficiency is the BJT NPN. Find an high hFE transistor (high means at least 100, better if 300). This will let you reduce the base current without sacrificing LED brightness.
Avoid devices with Absolute Maximum Rating under 50V and 0,2 A.

I tested 2N3904 and BC547 (X13003 as well, easily found in CFL lamps, solid but it has low hFE).

Start with a base resistor of 1k and try to maximize it. Try to reach a good trade-off between brightness and battery current.

The number of turns in the windings is not very critical: i tried from 3 to A LOT, an always worked (but remember that the frequency can be lowered to the audible range). Between 7 and 12 turns should be in the safe area of 40-80 kHz.

In the next 3 photos you can see some of the transformers that I used in my circuit (they all come from disposed circuits like CFL lamps).

The next scheme can guide you in the setup/adjust process.

Scheme 3: the influence of the parameters in the magnetizing current

Conclusions

I tried to explain all I learned about this boost circuit. This report can be a good starting point for other studies and tests. I estimated a total efficiency of about 72%, not bad for such a small circuit.

Where I found out the circuit:
http://www.emanator.demon.co.uk/bigclive/joule.htm
A lot of photos about the construction:
http://www.evilmadscientist.com/2007/weekend-projects-with-bre-pettis-make-a-joule-thief/

In un articolo datato 1 APRILE 2008 ho detto che Stallman sosteneva Sinistra Critica, con tanto di fotomontaggio ad hoc (rigorosamente fatto con Gimp). http://dainaccio.wordpress.com/2008/04/01/richard-stallman-per-sinistra-critica/

Tutto ciò è FALSO, 100% !

(come se fosse necessario ribadirlo… una delle promesse è il 2% del PIL italiano a programmatori di Free Software ! ahah !)

Ecco il paragrafo incriminato che riprende la mia burla:

Dato che entrambi i riferimenti usati sono abbastanza farlocchi (quello al mio blog è, come detto, un falso nemmeno tanto difficile da scoprire, e nell’altro Stallman non compare tra la lista dei firmatari…) ho il dubbio che il paragrafo sia scritto un po’ in mala fede, magari da qualche simpatizzante di SC volenteroso di schierare Stallman dalla sua parte. In tal caso non posso accettare che la mia burla sia complice di questa mistificazione politica ed è per questo che ho scritto questa smentita.

In ogni caso: NEVER TRUST THE INTERNET

My code produces a 10kHz squared wave to the pin of the green led. A little 386-based audio amplifier is wired as well, to transform the signal in an audible sound.

Actually, 10kHz is still audible by humans: it’s just for testing the audio system. If you can hear the high pitched sound everything is OK; now you can switch to 14 or 15 kHz by pressing the S2 button (each press increments the frequency by 1000). These high frequencies are still audible by mosquitoes and they’ll keep them away.

# This software is released under GPLv3 license:
# http://www.gnu.org/licenses/gpl.html

#include <io.h>
#include <signal.h>

// Hertz
#define CLOCK         16000000
#define FREQ        10000
#define DELTA_F    1000

#define     LED0                  BIT0
#define     LED1                  BIT6
#define     LED_DIR               P1DIR
#define     LED_OUT               P1OUT

#define     BUTTON                BIT3
#define     BUTTON_OUT            P1OUT
#define     BUTTON_DIR            P1DIR
#define     BUTTON_IN             P1IN
#define     BUTTON_IE             P1IE
#define     BUTTON_IES            P1IES
#define     BUTTON_IFG            P1IFG
#define     BUTTON_REN            P1REN

static void __inline__ delay(register unsigned int n);

int i;

int main(void)
{
// Watch Dog settings
WDTCTL = WDTPW|WDTHOLD;        // Stop watchdog timer

// Clock settings
BCSCTL1 = CALBC1_16MHZ;        // clock 1MHz
DCOCTL = CALDCO_16MHZ;

// Leds settings
LED_DIR |= LED0 + LED1;

// TimerA settings
TACCR0 = CLOCK/(2*FREQ);            // Timer end value
TACTL = TASSEL_2 + MC_1 + ID_0;    // SMCLK/1, up mode
TACCTL0 = CCIE;                        // Timer Interrupt Enable

// Button settings
i = 0;
BUTTON_DIR &= ~BUTTON;    // input
BUTTON_OUT |= BUTTON;    // high (for pull resistor)
BUTTON_REN |= BUTTON;    // pull up
BUTTON_IES |= BUTTON;    // high to low interrupt
BUTTON_IFG &= ~BUTTON;    // clear interrupt
BUTTON_IE |= BUTTON;        // interrupt enable

// Interrupts settings
__bis_SR_register(GIE);                // General Interrupts Enable

while(1) ;

return 0;
}

interrupt(TIMERA0_VECTOR) timer_int(void)
{
LED_OUT ^= LED1;
}

interrupt(PORT1_VECTOR) button_int(void)
{
BUTTON_IFG = 0;              // clear Interrupt Flag Register
BUTTON_IE &= ~BUTTON;    // disable Button Int (debounce)

i++;
TACCR0 = CLOCK/(2*(FREQ + i*DELTA_F));

delay(500);
BUTTON_IE |= BUTTON;        // enable Button Int

}

// Delay Routine from mspgcc help file
static void __inline__ delay(register unsigned int n)
{
__asm__ __volatile__ (
“1: \n”
” dec %[n] \n”
” jne 1b \n”
: [n] “+r”(n));
}

I wanted to create a 9600 asynchronous serial connection with my TI LaunchPad.
I started my development from the source code of the example program that I found in it (temp. sensor with serial connection and leds modulation) but I wanted three more things: a faster link (9600 which is four times greater), a mspgcc4 compatibility (the free-software compiler that I’m using) and a CPU working at 16 MHz (instead of 1 MHz of the example).

The task is not very difficult and I carried it in a completely free environment (Ubuntu + MSPGCC + mspDebug).

Introduction

First of all, the asynchronous serial communication is a way to send and receive data over a link, without the need of a clock signal. In its simplest implementation we have the transmission of 10 symbols: a starting 0 (start bit), eight bits of data and an ending 1 (stop bit).
From this we can add a parity bit (and other things…) to aim to a more strong/error-free connection but that’s not our case of study.

To allow a communication between two units we have to set the same “communication speed” parameter, which impose the time duration of each bit. Its unit is the BAUD: the maximal number of symbols each second.
For example 9600 BAUD means that every symbol needs to be 1/9600 seconds long (otherwise we cannot meet the desired top speed).

void Transmission(void)

As in the software example of TI, the serial transmission is made by putting the 8 bits to send in a variable (TXByte) and then calling the function void transmission().

This function prepares the transmission adding a Start Bit and a Stop Bit to the data that we want to send. It also actives the interrupt of the TimerA, the timing device inside the MSP430 that is used to create a good and compliant serial signal.

With Bitime we set the number of cycles of the timer between each interruption. This is done by adding this value to the TimerA configuration register CCR0.

The main program is blocked inside this function until the transmission is completed.

interrupt(TIMERA0_VECTOR) uart(void)

This function is responsible for changing the output of the UART according to the data bit to send. It checks the number of the bits already sent (BitCnt) and if the communication is not terminated.

Configurations

As stated before, we set up the internal oscillator at 16 MHz (=MSCKL = SMCLK).
The TimerA is working in continuous mode, incremented at the frequency of SMCLK divided by 8 (Timer Clock).

Bitime is derived from the Timer Clock speed and the Communication speed.
The relation is:

BAUD = Timer Clock / Bitime

In the example we have Bitime = 52, which is ( Timer Clock / BAUD ) = ( (1 MHz / 8 ) / 2400).
In our case I changed both the Clock and the BAUD, so the new Bitime is (16 MHz / 8 ) / 9600 = 209.

–> Actually 209 didn’t worked… I changed to 250, but I don’t know why…

Source code


#include
#include

// Delay Routine from mspgcc help file
static void __inline__ delay(register unsigned int n)
{
__asm__ __volatile__ (
"1: \n"
" dec %[n] \n"
" jne 1b \n"
: [n] "+r"(n));
}


Ciò è dovuto al fatto che Skype ritiene che sia un microfono stereo e, nel tentativo di rimuovere il rumore, fa la differenza dei 2 canali arrivando così ad annullare il segnale.

La soluzione è installare un mixer per PulseAudio

sudo apt-get install pavucontrol

e, una volta avviato, modificare i livelli audio del microfono, andando ad abbassare a livello 0 uno dei 2 canali.

Nelle impostazioni Skype, inoltre, va inibito l’auto-settaggio dei volumi.

Fortunatamente ho trovato una soluzione estremamente comoda…

Per prima cosa bisogna andare sulle preferenze della tastiera (Sistema -> Preferenze -> Tastiera)

Da qui va selezionata la linguetta “Disposizioni” (1) e poi “Aggiungi” (2). Nella finestra che si apre, va scelta una tastiera contenente gli accenti desiderati. Visto che nel mio caso si trattava di accenti francesi, ho aggiunto una tastiera a disposizione francese, come si vede in figura.

Fatto questo, bisogna impostare quale tasto sarà incaricato di fare lo swith da una tastiera all’altra. Per fare ciò si va su “Opzioni…” (3).

Tra le tante voci presenti nella finestra di opzioni, bisogna cercare ed espandere quella denominata “Tasto o tasti per cambiare disposizione”. Personalmente ho attivato “Tasto di Windows (mentre è premuto)”.

In questo modo, ogni volta che mi serve un accento straniero, tengo premuto il “tasto di Windows” e lo digito come avessi davanti la tastiera, nel mio caso, francese. Fête !

Se invece, come è capitato a me, c’è l’interesse ad un controllo più approfondito dei file di un computer remoto (una vera e propria amministrazione, più che una semplice condivisione classica) allora una delle soluzioni più vantaggiose è rappresentata dalla suite SSH.

Installando un server SSH su una macchina, la si rende disponibile ad essere amministrata da qualsiasi computer remoto, permettendo l’esecuzione di comandi e lo scambio di file.

Ciò avviene con il comando :
sudo apt-get install ssh

Una volta fatto ciò, si potrà accedere al computer tramite la comoda voce “Accedi al server…”, che in Ubuntu si trova nel menù “Risorse”.
Nella tipologia server va selezionato “SSH” e va inserito il nome utente (dimenticavo… dovete avere un utente nella macchina remota !).

Se la procedura va a buon fine, si aprirà una finestra di Nautilus contenente i file presenti in remoto, da cui potrete svolgere le operazioni desiderate (navigazione, copia, eliminazione, ecc…) con la stessa comodità d’uso dei file locali.

L’unico limite è rappresentato dai privilegi di cui gode l’utente utilizzato nel computer remoto.

Ormai che è stato installato il server SSH, segnalo che è possibile accedervi anche con un client SSH da terminale. La sintassi è:

ssh ipRemoto -l nomeUtenteRemoto

Sicurezza
Dopo aver installato un server SSH, di default la macchina accetta le connessioni dai client esterni e ciò non va sottovalutato.
Buona pratica è avere un numero di utenti limitato e ben noto, ognuno dei quali con una password non banale. Inoltre, se il servizio SSH viene utilizzato solo raramente, conviene disattivarlo dall’esecuzione automatica (o disinstallarlo quando terminato il lavoro…).
Non sottovalutate questi aspetti, soprattutto se il computer non è in una rete casalinga o è accessibile anche da internet.

Un must per gli scienziati del Controllo Automatico è rappresentato da Matlab, un software molto utile e versatile ma proprietario.

Avendo solo umili esigenze, ho imparato come ottenere esiti equivalenti con programmi open.
La scelta è ricaduta su Octave, presente nei repository Ubuntu, a cui va aggiunto il modulo “Control”, non installato di default:

sudo apt-get install octave3.2 octave-control

Per utilizzarlo basta aprire un terminale e digitare “octave”.
Ecco una lista di comandi di riferimento (help comando per maggiori informazioni):

Definizioni di un sistema:
Funzione di trasferimento:
G = tf([1 -1],[1 5 2]);
Zeri e poli:
G = zp([1],[-1 -1 -13/5], 1);

Grafici vari:
Luogo delle radici:
rlocus(G);
Risposta in frequenza (Diagramma di Bode):
bode(G);
Diagramma di Nyquist:
nyquist(G);

Avere un terminale a disposizione può sempre essere utile, se poi punta direttamente alla cartella corrente tanto meglio.
Ecco quindi come ottenere la funzione “Apri un terminale”, direttamente nel menù del tasto destro di Nautilus.

sudo apt-get install nautilus-open-terminal