Nuovo manico per il braccetto della macchina del caffè espresso

Può capitare che l'iserimento del braccetto nella macchina risulti un po' difficoltoso, che qualche volta si inceppi o che faccia i capricci ad agganciarsi... e quindi cosa si fa? 

Si spinge di brutto.

Ma di brutto proprio, il risultato?

Questo:

Qulche tempo fa in un giro di acquisti compulsivi comprai diversi manici per diversi utensili di uso comune come la mazzetta, il martello, l'accetta e così via - perché? non si sa mai! e infatti...

Preso il manico, ho praticato un foro del giusto diametro (12mm) ed ho scalpellato le due scanalature con la sgorbia.

Dopo aver inserito il portafiltro nel nuovo manico in legno ed aver fatto le varie prove di tenuta, ho smontato nuovamente tutto e ho ripassato il pezzo con abbondante colla epossidica: ottima soluzione per giuntare legno e metallo.

Un'accorciatina la manico, che in partenza doveva essere per una mazzetta da mezzo chilo.

Una bella carteggiata sulla levigatrice da banco per sagomare meglio il fondo del manico; e dopo una veloce carteggiata con carta fine (400 circa) ecco il risultato:

Totale tempo impiegato per questo lavoro: 6 Minuti

Oscilloscopio: lo stai usando nel modo giusto. ovvero come scrivere o disegnarci su con arduino e un po' di fantasia...

lo scorso anno mi sono cimentato in una divertente attività con l'oscilloscopio, per il periodo natalizio avevo fatto un addobbo particolare che trovate QUI!

quest'anno avendo qualche difficoltà a riprodurre l'esperimento mi sono messo a studiare e sono andato un po' oltre, e ho fatto questo:

Il circuito è lo stesso del progetto analogo dello scorso anno

Per poter disegnare e scrivere sono necessari dei punti X Y, potete trovare questi punti da dare in pasto all'oscilloscopio tramite arduino utilizzando un semplice programma che trovate QUI!

Lo sketch lo trovate QUI!

Charlie Plexing, Chubby Bunny, addobbi natalizi con l'attiny 85 e altre sventure.

intanto carico il filmatino di un aggeggio che stamane ho appeso alla porta del mio laboratorio,

un bel lavoretto realizzato grazie alla sapiente programmazione di Dario Gavezzone . (La rima imponeva).

Tutta l'elettronica è basata su di un ATtiny 85, qualcosa in merito lo trovate anche QUI!

Lo schema a fritzing è un disastro:

più comprensibile lo schema dei soli led recuperato direttamente dalla pagina di wikipedia qui sotto:

lo sketch è questo:

#include <avr/pgmspace.h>  //This is in the Arduino library

// inizio implementazione assert con output in compilazione

#define CONCAT_TOKENS( TokenA, TokenB )       TokenA ## TokenB

#define EXPAND_THEN_CONCAT( TokenA, TokenB )  CONCAT_TOKENS( TokenA, TokenB )

#define ASSERT( Expression )                  enum{ EXPAND_THEN_CONCAT( ASSERT_line_, __LINE__ ) = 1 / !!( Expression ) }

#define ASSERTM( Expression, Message )        enum{ EXPAND_THEN_CONCAT( Message ## _ASSERT_line_, __LINE__ ) = 1 / !!( Expression ) }

// fine implementazione assert con output in compilazione

#define ISDIGIT(n) (n >= '0' && n <= '9')

#define OCTAVE_OFFSET 0

#define SPEAKER_PIN 4

#define BUTTON_PIN 3

const int notes[] = { 0,

 262,  277,  294,  311,  330,  349,  370,  392,  415,  440,  466,  494, // 4

 523,  554,  587,  622,  659,  698,  740,  784,  831,  880,  932,  988, // 5

1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1976, // 6

2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951, // 7

};

char *songs[] = {

  "R:d=4,o=5,b=160:8g,a,8g,e,c6,a,2g.,8g.,16a,8g.,16a,g,c6,1b,8f,g,8f,d,b,a,2g.,8g.,16a,8g.,16a,g,d6,2c.6",

  "J:d=4,o=5,b=112:8a,8a,a,8a,8a,a,8a,8c6,8f.,16g,2a,8a#,8a#,8a#.,16a#,8a#,8a,8a.,16a,8a,8g,8g,8a,g,c6",

  "W:d=8,o=5,b=140:4d,4g,g,a,g,f#,4e,4c,4e,4a,a,b,a,g,4f#,4d,4f#,4b,b,c6,b,a,4g,4e,4d,4e,4a,4f#,2g",

};

const char pins[] = {0, 1, 2};

const char ledPins[5][2] = {

  {0, 1},

  {1, 0},

  {1, 2},

  {2, 1},

  {2, 0},

};

byte giro = 0;

byte j = 0;

#define NUM_OF_SONGS 3

#define NUM_OF_PINS (sizeof(pins) / sizeof(char))

#define NUM_OF_LEDS 5

ASSERT(NUM_OF_LEDS <= (NUM_OF_PINS * (NUM_OF_PINS-1)));

void setup(void) {

  pinMode(SPEAKER_PIN, OUTPUT);

  pinMode(BUTTON_PIN, INPUT_PULLUP);

}

void loop(void) {

  alloff();

  if ( digitalRead(BUTTON_PIN) == LOW ) {

    play_rtttl(songs[giro]);

    giro = (giro < (NUM_OF_SONGS -1)) ? giro + 1 : 0;

  }

}

void play_rtttl(char *p) { // http://www.interactiondesign.se/wiki/attiny

  // Absolutely no error checking in here

  byte default_dur = 4;

  byte default_oct = 6;

  int bpm = 63;

  int num;

  long wholenote;

  long duration;

  byte note;

  byte scale;

  // format: d=N,o=N,b=NNN:

  // find the start (skip name, etc)

  // legge il titolo

  while(*p != ':') p++;    // ignore name

  p++;                     // skip ':'

  // get default duration

  if(*p == 'd') {

    p++; p++;              // skip "d="

    num = 0;

    while(ISDIGIT(*p)) {

      num = (num * 10) + (*p++ - '0');

    }

    if(num > 0) default_dur = num;

    p++;                   // skip comma

  }

  // get default octave

  if(*p == 'o') {

    p++; p++;              // skip "o="

    num = *p++ - '0';

    if(num >= 3 && num <=7) default_oct = num;

    p++;                   // skip comma

  }

  // get BPM

  if(*p == 'b') {

    p++; p++;              // skip "b="

    num = 0;

    while(ISDIGIT(*p)) {

      num = (num * 10) + (*p++ - '0');

    }

    bpm = num;

    p++;                   // skip colon

  }

  // quante note da un quarto stanno in un minuto

  wholenote = (60 * 1000L / bpm) * 4  ;  // this is the time for whole note (in milliseconds)

  // now begin note loop

  while(*p) {

    // first, get note duration, if available

    num = 0;

    while(ISDIGIT(*p)) {

      num = (num * 10) + (*p++ - '0');

    }

    if (num) duration = wholenote / num;

    else duration = wholenote / default_dur;  // we will need to check if we are a dotted note after

    // now get the note

    note = 0;

    switch(*p) {

      case 'c':

        note = 1;

        break;

      case 'd':

        note = 3;

        break;

      case 'e':

        note = 5;

        break;

      case 'f':

        note = 6;

        break;

      case 'g':

        note = 8;

        break;

      case 'a':

        note = 10;

        break;

      case 'b':

        note = 12;

        break;

      case 'p':

      default:

        note = 0;

    }

    p++;

    // now, get optional '#' sharp

    if(*p == '#') {

      note++;

      p++;

    }

    // now, get optional '.' dotted note

    if(*p == '.') {

      duration += duration/2;

      p++;

    }

    // now, get scale

    if(ISDIGIT(*p)) {

      scale = *p - '0';

      p++;

    } else {

      scale = default_oct;

    }

    scale += OCTAVE_OFFSET;

    if(*p == ',')

      p++;       // skip comma for next note (or we may be at the end)

    // now play the note

    if(note) {

      freqout(notes[(scale - 4) * 12 + note], duration);

    } else {

      delay(duration);

    }

  }

}

void freqout(int freq, int t) {

  freqout(freq, t, SPEAKER_PIN);

}

void freqout(int freq, int t, byte speaker) { // http://www.arduino.cc/playground/Main/Freqout

  turnon(random(0, NUM_OF_LEDS - 1));

  // freq in hz, t in ms

  const int hperiod = 500000 / freq - 7;              // subtract 7 us to make up for digitalWrite overhead

  const long cycles = ((long)freq * (long)t) / 1000;  // calculate cycles

  pinMode(SPEAKER_PIN, OUTPUT);                       // turn on output pin

  for (long i = 0; i <= cycles; i++) {                // play note for t ms  - SOFTWARE PWM?

    digitalWrite(SPEAKER_PIN, HIGH);

    delayMicroseconds(hperiod);

    digitalWrite(SPEAKER_PIN, LOW);

    delayMicroseconds(hperiod - 1);                   // - 1 to make up for digitaWrite overhead

  }

  pinMode(SPEAKER_PIN, INPUT);                        // shut off pin to avoid noise from other operations

//  alloff();

//  j = (j < (NUM_OF_LEDS - 1)) ? j + 1 : 0;

}

void turnon(int led) { // http://www.instructables.com/id/CharliePlexed-LED-string-for-the-Arduino/

  // This turns on a certian led from the list of leds

  int pospin = ledPins[led][0];

  int negpin = ledPins[led][1];

  pinMode (pospin, OUTPUT);

  digitalWrite (pospin, HIGH);

  pinMode (negpin, OUTPUT);

  digitalWrite (negpin, LOW);

}

void alloff() { // http://www.instructables.com/id/CharliePlexed-LED-string-for-the-Arduino/

  // This turns all the LED's off

  for(int i = 0; i < NUM_OF_PINS; i++)

    pinMode (pins[i], INPUT);

}

Super Cap, spine USB con la millefori, vecchie conoscenze e robe fatte male

basetta millefori sulla quale vi sono montati un supercap, una resistenza, un led.

sulla sinistra le quattro piste della spina USB adeguatamente limate

Ed alla destra del led che non si riesce più a spegnere (neanche mettendo in corto il condensatore) il super cap, eh sì, è da un Farad. (5.5 Volt)

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.