Imperial March, la Marcia Imperiale, come fa suonare un Attiny85

Come programmare un Attiny 85 lo potete scoprire QUI

L'attino ha un pallino, quello è il pin numero 1, gli altri pin fino al numero 8 si contano in senso antiorario. Lo schema è così composto:
pin 4 gnd
pin 8 vcc
pin 6 spk
come speaker ho adoperato un comune piezo elettrico
l'alimentazione è a 3 Volt con una 2032
lo scketch che ho caricato sull'attiny è questo qui sotto,
(come sempre prima sparare il bootloade, se restituisce errore riprovare all'inifinito, l'attino è impostato a 8mega)


___________________________________________________________
const int Note_C  = 239;
const int Note_CS = 225;
const int Note_D  = 213;
const int Note_DS = 201;
const int Note_E  = 190;
const int Note_F  = 179;
const int Note_FS = 169;
const int Note_G  = 159;
const int Note_GS = 150;
const int Note_A  = 142;
const int Note_AS = 134;
const int Note_B  = 127;

int Speaker = 1;

void setup()
{
  pinMode(Speaker, OUTPUT);
}

void loop()
{
  playTune();
  delay(10000);
}

void TinyTone(unsigned char divisor, unsigned char octave, unsigned long duration)
{
//  TCCR1 = 0x90 | (8-octave); // for 1MHz clock
   TCCR1 = 0x90 | (11-octave); // for 8MHz clock
  OCR1C = divisor-1;         // set the OCR
  delay(duration);
  TCCR1 = 0x90;              // stop the counter
}

// Play a scale
void playTune(void)
{
 TinyTone(Note_G, 4, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 4, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 4, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_DS, 4, 375);//RED
 TinyTone(Note_DS, 1, 50);
 TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
 //*********
 TinyTone(Note_G, 4, 500);//SOL
 TinyTone(Note_G, 1, 50);
  TinyTone(Note_DS, 4, 375);//RED
 TinyTone(Note_DS, 1, 50);
 TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
 TinyTone(Note_G, 4, 1000);//SOL
 TinyTone(Note_G, 1, 50);
 //****************************
 TinyTone(Note_D, 5, 500);//RE
 TinyTone(Note_D, 1, 50);
  TinyTone(Note_D, 5, 500);//RE
 TinyTone(Note_D, 1, 50);
  TinyTone(Note_D, 5, 500);//RE
 TinyTone(Note_D, 1, 50);
  TinyTone(Note_DS, 5, 375);//RED
 TinyTone(Note_DS, 1, 50);
  TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
 //******
  TinyTone(Note_G, 4, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_DS, 4, 375);//RED
 TinyTone(Note_DS, 1, 50);
  TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
 TinyTone(Note_G, 4, 1000);//SOL
 TinyTone(Note_G, 1, 50);
 //*****
  TinyTone(Note_G, 5, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 4, 375);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 4, 125);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 5, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_FS, 5, 375);//FAD
 TinyTone(Note_FS, 1, 50);
  TinyTone(Note_F, 5, 125);//FA
 TinyTone(Note_F, 1, 50);
 //*****
 TinyTone(Note_E, 5, 125);//MI
 TinyTone(Note_E, 1, 50);
 TinyTone(Note_DS, 5, 125);//RE
 TinyTone(Note_DS, 1, 50);
  TinyTone(Note_E, 5, 250);//MI
 TinyTone(Note_E, 1, 250);
 TinyTone(Note_GS, 4, 250);//SOLDIESI UN OTTAVO
 TinyTone(Note_GS, 1, 50);
 TinyTone(Note_CS, 5, 500);//DODIESIS
 TinyTone(Note_CS, 1, 50);
  TinyTone(Note_C, 5, 375);//DO
 TinyTone(Note_C, 1, 50);
 TinyTone(Note_B, 4, 125);//SI
 TinyTone(Note_B, 1, 50);
 //******
  TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
  TinyTone(Note_A, 4, 125);//LA
 TinyTone(Note_A, 1, 50);
 TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 375);
 TinyTone(Note_DS, 4, 250);//MID
 TinyTone(Note_DS, 1, 50);
 TinyTone(Note_FS, 4, 500);//FAD
 TinyTone(Note_FS, 1, 50);
 TinyTone(Note_DS, 4, 375);//MID
 TinyTone(Note_DS, 1, 50);
 TinyTone(Note_FS, 4, 125);//FAD
 TinyTone(Note_FS, 1, 50);
 //*******
 TinyTone(Note_AS, 4, 500);//LAD
 TinyTone(Note_AS, 1, 50);
 TinyTone(Note_G, 4, 375);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
 TinyTone(Note_D, 5, 1000);//LAD
 TinyTone(Note_D, 1, 50);

 //RIPRESA

 //*****
  TinyTone(Note_G, 5, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 4, 375);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 4, 125);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_G, 5, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_FS, 5, 375);//FAD
 TinyTone(Note_FS, 1, 50);
  TinyTone(Note_F, 5, 125);//FA
 TinyTone(Note_F, 1, 50);
 //*****
 TinyTone(Note_E, 5, 125);//MI
 TinyTone(Note_E, 1, 50);
 TinyTone(Note_DS, 5, 125);//RE
 TinyTone(Note_DS, 1, 50);
  TinyTone(Note_E, 5, 250);//MI
 TinyTone(Note_E, 1, 250);
 TinyTone(Note_GS, 4, 250);//SOLDIESI UN OTTAVO
 TinyTone(Note_GS, 1, 50);
 TinyTone(Note_CS, 5, 500);//DODIESIS
 TinyTone(Note_CS, 1, 50);
  TinyTone(Note_C, 5, 375);//DO
 TinyTone(Note_C, 1, 50);
 TinyTone(Note_B, 4, 125);//SI
 TinyTone(Note_B, 1, 50);
 //******
  TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
  TinyTone(Note_A, 4, 125);//LA
 TinyTone(Note_A, 1, 50);
 TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 375);
 TinyTone(Note_DS, 4, 250);//MID
 TinyTone(Note_DS, 1, 50);
 TinyTone(Note_FS, 4, 500);//FAD
 TinyTone(Note_FS, 1, 50);
 TinyTone(Note_DS, 4, 375);//MID
 TinyTone(Note_DS, 1, 50);
 TinyTone(Note_FS, 4, 125);//FAD
 TinyTone(Note_FS, 1, 50);
 //****
 TinyTone(Note_G, 4, 500);//SOL
 TinyTone(Note_G, 1, 50);
 TinyTone(Note_FS, 4, 375);//FAD
 TinyTone(Note_FS, 1, 50);
 TinyTone(Note_AS, 4, 125);//LAD
 TinyTone(Note_AS, 1, 50);
 TinyTone(Note_G, 4, 1000);//SOL
 //TinyTone(Note_G, 1, 50);

}

Giocattoli in legno, i primi prototipi...

Canguri

Conigli

Qualche addobbo per il Natale

Altri addobbi

Una prova per un trenino in legno

Die levigatrici a tamburo, la prima ricavata mettendo in morsa un dremel, la seconda costruendo un tamburo da innestare sul trapano a colonna, la carta si può sostituire con un comodo sistema "a spina" in metallo.

La sega a nastro.

Ecco il tamburo applicato al trapano a colonna

Nuovo arrivo in casa: la Spartamet

 "Ma ti sei comprato un'altra bici? " 

Sì, beh, non proprio...

Questa ha il motore.

_____________________________________________________

Ok, fine del teatrino.

La Spartamet -conosciuta anche come Saxonette o Hercules -  è una bici con motore Sachs da 30cc, due tempi, 0,5Kw di aggressiva potenza, motore praticamente integrato con la ruota posteriore, in lega, da 26". Sotto il motore si vede bene il marmittino, e appena sopra, incastrato nel portapacchi, il serbatoio per la miscela da un paio di litri. Comando gas al manubrio del tipo classico a chiocciola, comando aria e spegnimento tramite leva sempre al manubrio, avviamento "a strappo" tipo tagliaerba con la grande comodità del decompressore automatico (che consente l'avviamento anche in movimento senza dislocarsi una spalla).

Consumi ridottissimi - circa 70Km/litro - per una velocità che si aggira intorno ai 30 Km/h.

La coppia non è spaventosa, ma per quello ci sono i pedali, come d'altra parte in tutti i moped.

Cosa sia un Moped esattamente lo lascio scoprire a voi qui.

Contro qualunque etica del "vado in bici così faccio un po' di moto e non inquino" ho preso questo mezzo da portare con me nei vari viaggi in camper. Molto comodo per brevi e medi spostamenti, senza doversi trascinare dietro tutto, come faccio al solito con la bici tradizionale ma con molta più autonomia e capacità di carico. A differenza delle pedalata assistita non necessita di ricarica alla presa 220V (non sempre disponibile nei miei viaggi, soprattutto in quelli brevi del fine settimana) e soprattutto gode di un'autonomia infinita.

Qualche dato tecnico dal sito ufficiale Spartamet.

_____________________________________________________

Il motore è un concentrato di tecnologia, più concentrato che tecnologia però. Composto solo dal minimo indispensabile per il suo funzionamento è realizzato con due sole fusioni di alluminio.

In una trova posto cilindro/testa/albero/frizione/ingranaggi demoltiplicatori/parte del carter pompa.

L'altra è soltanto un coperchio.

Motore montato, a sinistra il cilindro in alluminio con in testa oltre che la candela il dispositivo del decompressore. Nella parte centrale all'altezza del marchio si trova la puleggia per l'avviamento "a strappo"la cui corda inguainata si vede andare verso l'alto sotto la sella. Da destra si trova il coperchio del filtro dell'aria ed il carburatore. Nella parte alta, al centro dei raggi il sistema di demoltiplica.

Nelle foto qui sotto, scattate durante un intervento di controllo e manutenzione di questi ultimi giorni, riporto le fasi dello smontaggio e lo spaccato del motore :

Motore già smontato e montato sul banco

Rimuovo la ruota dal motore

per non dimenticare l'ordine dei vari dadi e rondelle...

Rimosso il coperchio scatola del filtro dell'aria e il filtro dell'aria (che purtroppo ancora non ho) 

Rimozione della centralina, la foto serve a ricordare l'ordine dei cavi.

Questo è il cavo che dalla centralina (rosso) arriva al carburatore (blu) altro non è che un interruttore normalmente chiuso che viene aperto quando, dal comando a leva sul manubrio, decidiamo di spegnere il motore disattivando la centralina e quindi la relativa scintilla alla candela.

Sistema frenante con ganasce e tamburo, su entrambe le ruote, da smontare nel posteriore integrato nel motore

Fondo del motore lato carburatore (dove si intravede la finestra del pacco lamellare appena rimosso)

questo è tutto l'impianto elettrico del mezzo. sul volano c'è il magnete, sopra in azzurro la bobina AT e -credo- il pick up che comanda l'accensione.

questo il sistema di ingranaggi per la demopltiplica. Nella parte destra si vede il fondo del sistema biella/manovella (il cilindro è orientato verso il basso in questa foto) con albero a gomito in basso e sistema frizione centrifuga in alto. Il moto dall'albero motore passa ad una ampia vite senza fine, in cima all'albero nell'immagine, che trasmette a sua volta la rotazione al grande ingranaggio con denti elicoidali in alto a sinistra. Questo ingranaggio con un sistema del tipo a "Giunto di sopravanzo" è direttamente collegato alla ruota.

Questo è il pignone con la frizione di tipo centrifugo affrancata direttamente all'albero.

Bene, dopo aver smontato tutto, verificato cosa facesse quel rumore di lavastovglie col piatto messo male, ho rimontato tutto e in questo filmato si sente l'aggressivo ruggito del teutonico propulsore.

Pubblico altri tre filmatini che rendono meglio l'idea dell'insieme

Avviamento a freddo

versione a pedali della spartamet

versione a motore

Attiny 85 e servomotore: amore possibile!

Per muovere un servomotore ci vuole una libreria apposta per Attiny, la Softwareservo.h,
per la programmazione dell'Attiny  vi rimando qui.
Lo schema qui sotto:

qui il codice ad esempio per il Knob:

#include <SoftwareServo.h>

#define PIN_SERVO 0

#define PIN_POT 2

#define PULSE_MIN 600 // in microsecs

#define PULSE_MAX 2400 // in microsecs

#define READINGS_COUNT 10

SoftwareServo servo;

long potValue = 0;

int readings[READINGS_COUNT] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};

byte readingsPos = 0;

unsigned long nextReadingDue = 0;

void setup(){

servo.attach(PIN_SERVO);

servo.setMinimumPulse(PULSE_MIN);

servo.setMaximumPulse(PULSE_MAX);

}

void loop(){

// read the analog pin once every millisec, and store the data until we have enough to filter

unsigned long currentTime = micros();

if(currentTime > nextReadingDue){

readings[readingsPos] = analogRead(PIN_POT);

readingsPos ++;

nextReadingDue = currentTime + 1000;

}

// once every READINGS_COUNT readings, clean the data and update the servo

// also filter using weighted moving average to avoid excessive jittering due to poor potentiometer

if(readingsPos > READINGS_COUNT){

potValue = (9 * potValue + getCleanReading())/ 10;

servo.write(map(potValue, 0, 1023, 0, 180));

readingsPos = 0;

}

// good to call this as often as we can, so that we don't miss the moment when the signal has to go up or down

SoftwareServo::refresh();

}

// reads several analog values and tries to do some smart filtering

int getCleanReading(){

int reading, minReading=9999, maxReading=0;

long result = 0;

for(byte i=0; i<READINGS_COUNT; i++){

readings[i] = analogRead(PIN_POT);

result += readings[i];

if(readings[i] < minReading){

minReading = readings[i];

}

if(readings[i] > maxReading){

maxReading = readings[i];

}

}

// reaturn the average after eliminating min and max readings

return (result - minReading - maxReading) / (READINGS_COUNT - 2);

}

Anche io POV con Attiny

POV: Persistence of Vision
è quel fenomeno per cui, se vi sventolate una mano davanti alla faccia, vedete un sacco di dita...
lo state facendo adesso vero?
sfruttando questo fenomeno possiamo per esempio riprodurre dei caratteri grafici componendoli "una colonna alla volta" e spostandoci poi di un'altra colonna...

 

Chi fa questa cosa? Questo arnese qui:

Da sinistra: le batterie (3V sono sufficienti) l'interruttore, l'attiny 85 e i 5 led collegati.

che post di merda che sto scrivendo.

La scritta "Ciao belli!" manca la lettera C, c'era un piccolo bug risolto...

Questo è lo schema, sotto aggiungo il codice. ciao, arrangiatevi.

Programmare un Attiny con Arduino

Lo schema lo si deduce bene dall'immagine, io ho adoperato un duemilanove ma credo vada bene anche UNO. L'Atmel è un Attiny 85 20PU. Attenzione a posizionare correttamente l'attiny sulla bread board, la "chiave" nello schema è in basso a sinistra!

Quali sono le operazioni da compiere? Beh, bisogna prestare attenzione e fare tutto nel giusto ordine:

Caricare le librerie per Attiny, le più aggiornate le trovate qui.
Create una cartella che chiamerete "Hardware" dentro la cartella Arduino (accanto a libraries),
una volta scaricate le librerie le unzippate e le copiate pari pari dentro  "Hardware" la cartella Libraries di Arduino, vedrete che compariranno una serie di nuove voci tra le opzioni selezionabili all'interno di "tipo di arduino"

Caricare il software nell'Arduino,
- File> Esempi> ArduinoISP
- Strumenti>tipo di Arduino >Duemilanove (selezionate il vostro)
- Porta seriale> Com xx
- Tipo di programmatore> AVRISP mk II
a questo punto si carica lo sketch


Poi, dopo aver collegato l'attiny si passa alla programmazione di questo:

- File> Esempi> Basics>Blink (per esempio, in questo caso sostituire il pin 13 con lo 0)
- Strumenti>tipo di arduino>Attiny 85 (per esempio 8MHz)
- Porta seriale> com xx
- Tipo di programmatore> Arduino as ISP
- scrivi bootloader (serve per settare il clock dell'attiny, nativamente è impostato a 1MHz, nel mio esempio lo porto a 8 MHz)
caricare lo sketch --> che finirà ovviamente sull'Attiny
al termine del caricamento comparirà il messaggio:
avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85
avrdude: please define PAGEL and BS2 signals in the configuration file for part ATtiny85

niente paura, significa che tutto è andato a buon fine!

per verificare che tutto funzioni adesso sarà sufficiente collegare un led, con la sua resistenza in serie, al pin0 (piedino 5 nello schema qui sotto) se lampeggia allora è andato tutto a buon fine!