Metronom z dysku twardego

Opublikowano 10 lutego 2013 autor: Łukasz Więcek 31 2 294

Majsterkowo » Elektronika » Arduino » Metronom z dysku twardego

Plumkając sobie ostatnio na gitarze doszedłem do wniosku, że przydałby mi się metronom. Mam co prawda metronom w formie programu na PC, jak i aplikacji na Androida, ale zamarzył mi się taki prawdziwy metronom sprzętowy :) I nie mam tutaj na myśli jakiegoś piszczącego pudełeczka, ale coś bardziej mechanicznego…

Początkowo myślałem nad wykorzystaniem serwomechanizmu, ale szybko wybiłem sobie ten głupi pomysł z głowy ;) Serwa same w sobie są głośne i tylko by przeszkadzały w czasie gry. Musiałem więc znaleźć coś innego, co pozwoliłoby wystukiwać wyraźny rytm, ale jednocześnie pracować bezszelestnie. I wtem spojrzałem na swoją szlifierkę z dysku twardego i mnie olśniło – w roli metronomu idealnie powinno się sprawdzić ramię głowicy z dysku HDD :D

Jak działa ramię dysku twardego?

Ramię głowicy jest napędzane dzięki cewce umieszczonej między dwoma silnymi magnesami stałymi. Gdy przez cewkę przepuści się prąd, wytwarza się w niej pole magnetyczne, które powoduje przyciągnięcie całego ramienia do jednego z biegunów magnesów. Dokładnie ten sam efekt jest wykorzystywany w opisywanym wcześniej głośniku zrobionym z dysku twardego :)

W czasie normalnej pracy kierunek przepływu prądu przez cewkę jest zmieniany z olbrzymią częstotliwością, dzięki czemu sterownik dysku może bardzo precyzyjnie sterować położeniem ramienia z głowicą. Ja w swoim metronomie aż takiej precyzji nie potrzebowałem, dlatego mogłem sobie odpuścić stosowanie wysublimowanego sterownika, zastępując go zwykłym mostkiem H.

Ale po kolei…

Jak zrobić metronom z dysku twardego?

Pracę zaczynamy od rozebrania na części pierwsze dowolnego dysku twardego. Na początek rozkręcamy obudowę:

Następnie wykręcamy talerze dysku wraz z silnikiem:

Odwracamy dysk na drugą stronę i odkręcamy płytkę z całą elektroniką:

Zostawiamy sobie jedynie magnesy i ramię głowicy:

Z tego, co nam zostało, powstanie metronom. Ramię głowicy będzie wybijało rytm, a obudowa dysku będzie pełniła rolę obudowy metronomu (złożymy ją tylko nieco inaczej;)

Omówmy jednak najpierw nieco teorii…

Jak wprawić metronom w ruch?

Do sterowania metronomem zdecydowałem się użyć mikrokontrolera, dzięki któremu będzie można wyposażyć metronom w kilka predefiniowanych programów (trybów pracy), a także dodać kilka przydatnych bajerów ;)

Sam mikrokontroler nie byłby jednak w stanie zasilić cewki, dlatego do układu dołożyłem jeszcze mostek H (układ L293DNE). Ostatecznie układ przybrał taki kształt:

Jak widzicie, całość zdecydowałem się zasilać napięciem 12V. Głównym powodem była cewka, która przy niższym napięciu dosyć niepewnie poruszała ramieniem. Oba układy scalone zostały z kolei zasilone za pośrednictwem stabilizatora 5V, na którego wyjściu dałem dwa kondensatory filtrujące napięcie – elektrolityczny C1 o pojemności 22µF, oraz ceramiczny C2 o pojemności 100nF (C2 powinien się znajdować jak najbliżej mikrokontrolera).

Dodatkowo pierwsza nóżka mikrokontrolera (reset) została podciągnięta rezystorem 10k do zasilania.

Sam mostek H (układ L293DNE) został podłączony do mikrokontrolera poprzez diody 1N4007, które zabezpieczają µC przed większym napięciem wracającym z cewki.

Na schemacie znalazł się też przycisk, który będzie służył do zmieniania tempa pracy metronomu.

Jest to pierwsza wersja metronomu, która będzie jeszcze rozbudowywana i dalej rozwijana w kolejnych postach :)

Program

Program obsługujący metronom zdecydowałem się oprzeć na bibliotece Timers autorstwa Sprae. Co prawda w obecnej wersji metronomu mógłbym się spokojnie obyć bez tej biblioteki, ale przy wprowadzaniu planowanych ulepszeń będzie ona już sporym ułatwieniem pracy i pozwoli w znacznym stopniu uprościć kod :)

#include <Timers.h>
Timers<1> timer;

#define mostekH_PIN1 2
#define mostekH_PIN2 3
#define przycisk_PIN 4

int przycisk, poprzedniPrzycisk;

unsigned long rytm = 0;
unsigned long aktualnyRytm = 0;
unsigned long poprzedniRytm = 0;
unsigned long wcisniety;

void setup() {
  timer.attach(0, 0, metronom);

  pinMode(przycisk_PIN, INPUT_PULLUP);
  pinMode(mostekH_PIN1, OUTPUT);
  pinMode(mostekH_PIN2, OUTPUT);
  digitalWrite(mostekH_PIN1, HIGH);
  digitalWrite(mostekH_PIN2, LOW);

  poprzedniPrzycisk = HIGH;
}

void metronom() {                   // funkcja zmieniająca położenie ramienia metronomu
  static byte met = LOW;            // początkowe ustawienie zmiennej "met" na LOW
  digitalWrite(mostekH_PIN1, met);  // podanie stanu "met" na wejście "1" mostka H
  met = ~met;                       // zmiana stanu "met" na przeciwny
  digitalWrite(mostekH_PIN2, met);  // podanie zmienionego "met" na wejście "2" mostka H
}

void loop() {
  timer.process();
  przycisk = digitalRead(przycisk_PIN);

  if(przycisk != poprzedniPrzycisk) {
    if(przycisk == LOW) {
      aktualnyRytm = millis();
      wcisniety = millis();
      rytm = aktualnyRytm - poprzedniRytm;
      poprzedniRytm = aktualnyRytm;

      timer.setInterval(0, rytm);  // ustawianie nowej częstotliwości pracy metronomu
      metronom();                  // zmiana położenia ramienia (przy wciskaniu przycisku)

      delay(100);
    }
  }

  if(przycisk == LOW) {
    int czasWcisniecia = millis() - wcisniety;
    if(czasWcisniecia >= 500) {    // JEŻELI przycisk jest wciśnięty dłużej niż 0,5s:
      timer.setInterval(0, 0);     // zatrzymaj metronom
    }
  }

  poprzedniPrzycisk = przycisk;
}

#include <Timers.h>

Timers<1> timer;

#define mostekH_PIN1 2

#define mostekH_PIN2 3

#define przycisk_PIN 4

int przycisk, poprzedniPrzycisk;

unsigned long rytm = 0;

unsigned long aktualnyRytm = 0;

unsigned long poprzedniRytm = 0;

unsigned long wcisniety;

void setup() {

timer.attach(0, 0, metronom);

pinMode(przycisk_PIN, INPUT_PULLUP);

pinMode(mostekH_PIN1, OUTPUT);

pinMode(mostekH_PIN2, OUTPUT);

digitalWrite(mostekH_PIN1, HIGH);

digitalWrite(mostekH_PIN2, LOW);

poprzedniPrzycisk = HIGH;

}

void metronom() { // funkcja zmieniająca położenie ramienia metronomu

static byte met = LOW; // początkowe ustawienie zmiennej "met" na LOW

digitalWrite(mostekH_PIN1, met); // podanie stanu "met" na wejście "1" mostka H

met = ~met; // zmiana stanu "met" na przeciwny

digitalWrite(mostekH_PIN2, met); // podanie zmienionego "met" na wejście "2" mostka H

}

void loop() {

timer.process();

przycisk = digitalRead(przycisk_PIN);

if(przycisk != poprzedniPrzycisk) {

if(przycisk == LOW) {

aktualnyRytm = millis();

wcisniety = millis();

rytm = aktualnyRytm - poprzedniRytm;

poprzedniRytm = aktualnyRytm;

timer.setInterval(0, rytm); // ustawianie nowej częstotliwości pracy metronomu

metronom(); // zmiana położenia ramienia (przy wciskaniu przycisku)

delay(100);

}

if(przycisk == LOW) {

int czasWcisniecia = millis() - wcisniety;

if(czasWcisniecia >= 500) { // JEŻELI przycisk jest wciśnięty dłużej niż 0,5s:

timer.setInterval(0, 0); // zatrzymaj metronom

}

poprzedniPrzycisk = przycisk;

}

Program nie jest zbyt skomplikowany (jeszcze), więc mam nadzieję, że każdy sobie poradzi ze zrozumieniem jego działania :) Generalnie całość sprowadza się do jednego – program zapamiętuje czas, jaki minął między dwoma ostatnimi wciśnięciami przycisku i ustawia go jako czas pomiędzy kolejnymi zmianami położenia ramienia metronomu. Uh – brzmi skomplikowanie, więc postaram się wyjaśnić to prościej ;)

Wystarczy palcem wystukać rytm (wciskając przycisk), żeby metronom zaczął pracować z tą samą częstotliwością.

Składamy metronom

Cały układ zmontowałem na płytce uniwersalnej:

Na płytce zamontowałem sobie też gniazdo ICSP, żeby w przyszłości móc szybko podpiąć programator i zmienić program w mikrokontrolerze.

Pod płytkę włożyłem podkładkę z tworzywa, żeby uniknąć możliwości zrobienia zwarcia przez metalową obudowę:

Cewkę ramienia podłączyłem od spodu, wyłamując najpierw wszystkie zbędne goldpiny, w miejsce których wkleiłem gniazdo zasilania (metronom będzie zasilany zasilaczem sieciowym od jakiegoś starego routera):

Płytkę przykręciłem dwoma wkrętami korzystając z oryginalnych otworów znajdujących się w obudowie:

Na powyższym zdjęciu widać też już przykręcony i podłączony przycisk, pod który otwór wywierciłem wcześniej :)

I to wszystko :) Na koniec przykręcamy obudowę “od tyłu”, tzn. tak, żeby zakryć całą elektronikę, a ramię z magnesami zostawić na wierzchu. Do skręcenia obudowy będziemy potrzebować dłuższych śrubek (ja u siebie dałem śrubki o długości 2cm):

Tadaaam – metronom skończony!

Nie jest to jednak metrodom doskonały, dlaczego czekają nas jeszcze…

Drobne poprawki

Metronom w czasie pracy wydawał nieprzyjemny, metaliczny dźwięk. Spowodowany był drżeniem blaszek w ramieniu głowicy:

Żeby pozbyć się tego przydźwięku, wkleiłem pomiędzy elementy ramienia małe gumki (wycięte z gumowej uszczelki). Przy okazji pozbyłem się też tych cienkich blaszek z końca ramienia, do których była zamocowana sama głowica:

Dźwięk był już czysty, ale nadal trochę stłumiony. Przyczyną były gumowe elementy amortyzujące znajdujące się z drugiej strony ramienia (od strony magnesów):

W różnych dyskach te elementy mogą wyglądać inaczej, ale generalnie są to jakieś gumowe amortyzatorki mające chronić ramię przed mocnymi uderzeniami w skrajnych położeniach. Z jednej strony znajdziecie też najprawdopodobniej mały magnesik (widoczny na powyższym zdjęciu na końcu prawej gumki), który możecie usunąć razem z gumką (normalnie magnesik ma trzymać ramię w jednej pozycji, gdy dysk nie jest używany).

No – i teraz można już chyba powiedzieć, że to koniec pracy (na dziś;)