Przeszukaj forum

Z dekady na dekadę pojawiają się nowe rozwiązania w audio, co niejako wymusza na konsumentach zakup nowego sprzętu. Obecnie nie ma co narzekać bo słuchanie muzyki czy innego przekazu audio jest tanie i wygodne. Liczne niegdyś przenośne oraz stacjonarne źródła dźwięku zostały zredukowane do smartfona a interfejs BT wyeliminował przewodowe połączenia z głośnikami czy słuchawkami. Starszy sprzęt stał się niekompatybilny ze współczesnymi standardami, bo np. mało kto używa obecnie kaset magnetofonowych czy nawet płyt CD i niejednokrotnie sprzęt dobrej klasy stoi przez to bezczynnie. Na szczęście elektronika jest w stanie dostarczyć sposobów jak sobie z tym poradzić. Jednym z nich jest użycie transmisji FM jako "adaptera" umożliwiającego połączenie w prawie dowolnego źródła dźwięku. W takim systemie audio po jednej stronie mamy źródło dźwięku oraz nadajnik FM, po drugiej stronie starszy sprzęt wyposażony w radio FM. Projekt elektroniczny, który prezentuję jest takim nadajnikiem, umożliwiającym transmisję stereo. Bazuje on na dosyć wiekowym już układzie scalonym BA1404, który powstał gdzieś na początku lat 90-tych, albo i nawet wcześniej, w japońskiej firmie ROHM. Układy te, choć może już nie oryginalne, obecnie są tanie i łatwo dostępne na chińskich portalach z elektroniką, co powinno zachęcić do poeksperymentowania zainteresowanych z układami radiowymi. Na początek trochę informacji o tym, jak wygląda transmisja stereo w modulacji FM (CCIR). Rysunek poniżej przedstawia schemat blokowy nadajnika FM stereo oraz wykres widma sygnału przed modulatorem radiowym. Na wejściu mamy sygnał audio stereo, czyli rozdzielony na kanał lewy (L) i prawy (R). Następnie oba kanały są sumowane (L+R) i odejmowane (L-R) w wyniku czego powstają dwa sygnały. Są one następnie poddawane preemfazie, czyli technice wzmacniania wyższych częstotliwości, aby poprawić stosunek sygnału do szumu (SNR). Dokonuje się tego w prosty sposób z udziałem filtrów RC, o stałej czasowej różnej dla regionów świata; u nas stała czasowa wynosi 50 mikrosekund. Oba sygnały będące sumą i różnicą L i R wędrują następnie do modulatora FM, z tym, że sygnał różnicowy poddawany jest dodatkowemu zabiegowi w modulatorze DSB-SC (Double-Sideband Suppressed-Carrier). Wskutek tego powstaje sygnał modulowany amplitudowo, ale ze stłumioną (usuniętą) nośną, która nosi nazwę pilota. Pozostają tylko dwie wstęgi boczne (górna i dolna) na niesłyszalnej dla ucha ludzkiego części pasma. Istotna jest tutaj funkcja pilota - sygnału o stałej i stabilnej częstotliwości, którego wytworzenie wymaga zastosowania rezonatora kwarcowego, o czym będzie więcej w dalszej części. Sens tego wszystkiego jest dobrze ukazany na wykresie widmowym (rysunek b), w postaci trzech komponentów. Począwszy od początku wykresu mamy widmo sygnału akustycznego, będącego sumą L i R. Korzystają z niego odbiorniki FM w trybie mono. Następnie, na częstotliwości 19 kHz jest widoczny pik w postaci sygnału pilota. Dalej na prawo widoczne są dwie wstęgi boczne leżące symetrycznie względem f=38 kHz, z których korzystają odbiorniki stereo. Bardzo istotna jest tutaj "strzałka" na częstotliwości 19 kHz, dzięki której modulator DSB-SC jest w stanie wytworzyć dwie wstęgi boczne potrzebne do uzyskania przekazu stereo. Przechodząc do praktyki mamy układ BA1404, którego blokowy schemat wewnętrzny wygląda tak: Porównując oba rysunki, można rozpoznać każdy z bloków funkcjonalnych począwszy od wejść kanałów L i R, poprzez multiplekser, który zawiera modulator DSB, sumatory, generator podnośnej 38 kHz, kończąc na modulatorze FM. Więcej szczegółów można znaleźć w dokumentacji układu. Z istotniejszych parametrów to wyjątkowo niskie napięcie zasilania 1..2 V oraz pobierany prąd około 3 mA, co kwalifikuje go do zasilania bateryjnego (1x 1,5V lub NiMH 1,2V). Układ nadajnika zmontowałem na płytce z laminatu zaprojektowanej w KiCad i wyposażyłem go w złącza wejścia audio Jack 3,5 stereo, złącze zasilania DC, włącznik zasilania oraz diodę LED sygnalizującą podłączenie zasilania. Ponieważ założyłem możliwość zasilania szerokim zakresem napieć, zastosowałem liniowy stabilizator napięcia LM317, obniżający go do około 1,25 V. Przy tak małym prądzie mógłby wystarczyć stabilizator parametryczny na rezystorze i dwóch, trzech szeregowych diodach 1N4148, ale akurat mam dużo LM317 i umożliwia poeksperymentowanie z różnymi wartościami napięcia zasilania. Schemat układu prezentuję poniżej i oprócz obwodu zasilania jest to typowa aplikacja układu BA1404, którą można znaleźć w nocie katalogowej. Opis szczegółowy można podzielić na trzy sekcje: wejście, multiplekser, obwód radiowy (RF). Filtry górnoprzepustowe R1/C4 i R2/C5 pełnią funkcję preemfazy. Bez tych kondensatorów dźwięk w odbiorniku będzie pozbawiony wysokich tonów (stłumiony). Następnie sygnał audio trafia na wejścia (piny 1 i 18) poprzez kondensatory C6/C9 odcinające składową stałą. Koder stereo i generator sygnału pilota (Piny 13, 14, 16, 17) to "serce" układu, które odpowiada za stworzenie sygnału MPX (Multipleksowego). Potencjometr POT1 100k służy do ustalenia balansu pomiędzy kanałami prawym i lewym. Do pinów 5 i 6 podłączony jest rezonator kwarcowy 38 kHz, najistotniejszy element zewnętrzny tej sekcji. Dzięki niemu wbudowany oscylator wytwarza stabilną podnośną 38 kHz (dla sygnału L-R) oraz – po podzieleniu przez 2 – sygnału pilota 19 kHz. Uwaga: Bez tego kwarcu nadajnik będzie pracował, ale tylko w trybie mono. W multiplekserze następuje zmieszanie sygnału pilota 19 kHz z sygnałem różnicowym. Z dostępnością kwarcu o tak nietypowej częstotliwości bywa różnie, ale podobnie jak BA1404 jest do znalezienia na chińskich platformach sprzedażowych. Jest on w obudowie podobnej do znanego rezonatora "zegarkowego" 32768 Hz. W wyniku trudności ze zdobyciem tego rezonatora hobbyści stosowali czasem zamiast niego proste generatory RC, jaka była jego stabilność można się domyślić Na wyjściu sygnału MPX (Pin 14) pojawia się gotowy, złożony sygnał stereofoniczny (L+R, pilot 19 kHz oraz zmodulowany L-R). Sygnał MPX wędruje następnie z pinu 14 do pinu 12 (wejście modulatora) poprzez kondensator sprzęgający. Wartość tego kondensatora wpływa na separację kanałów – zbyt mała pojemność obetnie niskie częstotliwości, co pogorszy efekt stereo. Następnie sekcja Radiowa - Modulator FM i Oscylator (Piny 9, 10, 12). Tutaj sygnał mowy/muzyki zamieniany jest na falę radiową o wysokiej częstotliwości. Obwód LC (Piny 9 i 10) składa się z cewki L2 i kondensatora C21 (często trymera) stanowiących obwód rezonansowy. To one decydują o częstotliwości nadawania (np. 100 MHz). W swojej konstrukcji zrezygnowałem z trymera i zastosowałem cewkę i kondensator o nieregulowanych parametrach. Cewki są najbardziej kłopotliwym elementem, bo bez przyrządów i doświadczenia nie wiadomo jak się do nich zabrać ale tutaj sprawa jest wyjątkowo prosta - wystarczy kawałek drutu emaliowanego o średnicy 0,5 mm. Na średnicy około 5 mm nawinąłem 5 zwojów, i to wszystko. Z kondensatorem 10 pF dało to częstotliwość około 106 MHz. Obwód wyjściowy układu BA1404 posiada generator RF w układzie Collpitsa i posiada on niewielką moc wyjściową, wystarczającą jednak do zagłuszenia lokalnie ewentualnej stacji nadającej akurat na tej samej częstotliwości (spokojnie, wszystko legalnie, to "zagłuszanie" odbywa się w promieniu maks kilku metrów od anteny nadajnika). Do wyjścia obwodu RF (pin 7) poprzez C25 podłączona jest antena. Wystarczy kawałek drutu o długości ok. 75 cm dla pasma 100 MHz. Przykładowe elementy wykorzystane w projekcie do nabycia w Botland: LM317 Gniazdo DC Laminat jednostronny FR4 Jak widać, zaletą układu BA1404, pomimo że jest to układ radiowy analogowy, jest minimalna liczba elementów wymagana do jego uruchomienia. Z tej prostoty niestety wynika spora wada, jaką jest nieduża stabilność częstotliwości. Ponieważ w nadajniku użyty jest oscylator LC, każda zmiana temperatury lub dotknięcie cewki powoduje "płynięcie" stacji. Nowoczesne układy radiowe (jak te w smartfonach) używają syntezy PLL, która wytwarza częstotliwość cyfrowo. Efekty działania układu widoczne są na materiałach filmowych, które zamieszczam poniżej. Oprócz demonstracji samej transmisji FM, jest test stereo a także demonstracja lokalnego "zagłuszenia" stacji FM. Konfiguracja układu testowego: - część nadawcza: laptop (jako źródło audio) > nadajnik > antena - część odbiorcza: odbiornik FM stereo (cyfrowy) > wzmacniacz mocy stereo > głośniki stereo. Test stereo Demonstracja lokalnego "zagłuszenia" stacji (pomimo bardzo niskiej mocy układu) Demonstacja audio

Miałem opisać zupełnie inne urządzenie - cóż, w ostatniej chwili postanowiłem coś poprawić i wyskoczyło parę niedogodności. Ponieważ w międzyczasie udało mi się dokończyć mój odtwarzacz do książek - więc pozwolę sobie go przedstawić: oto Lekton. Dla tych którzy pamiętają poprzedną wersję: zrezygnowałem z określenia "czytak" z uwagi na istnienie komercyjnego produktu o tej nazwie, z którym nie mam zamiaru konkurować. Niech więc będzie (jak przystało na maniaka SF) Lekton... Zacząłem od przeanalizowania zalet i wad poprzedniego urządzenia (które zresztą uległo awarii, co prawda dość szybko usuniętej ale jednak). Na pierwszy rzut poszła konstrukcja. Niewątpliwie układ klawiatury był trafieniem w dziesiątkę: tylko dziewięć klawiszy, łatwych do odróżnienia bezwzrokowo, obsługujących najpotrzebniejsze funkcje... No i z zalet to tak praktycznie wszystko. Matrycowe podłączenie klawiatury praktycznie eliminowało możliwość odczytania więcej niż jednego klawisza jednocześnie. W dodatku stanowiąca całość z resztą obudowy klawiatura do jakiegokolwiek serwisowania wymagała rozebrania praktycznie całego urządzenia (a to mi się zdarzyło, bo wskutek upadku urwał mi się jeden z przewodów). Dalej: co prawda udało mi się zmieścić urządzenie w zakładanym rozmiarze paczki papierosów, ale okazało się to nieco bez sensu. Wewnątrz panował straszliwy ścisk, złożenie całości wymagało jakiejś potwornej ekwilibrystyki, rozmiar implikował niewygodne rozmieszczenie poszczególnych modułów których zresztą było za dużo. W dodatku użyty moduł WROVER co prawda miał wystarczającą ilość pamięci (16 MB flash, 8 MB PSRAM z czego praktycznie 4 MB do bezpośredniego użytku) ale konwerter UART/USB już się nie zmieścił i trzeba było użyć dedykowanego zewnętrznego konwertera. Poza tym stwierdziłem, że głośnik jest tu absolutnie niepotrzebny. Mogłem zamienić moduł MAX98357 na PCM5702A, w efekcie otrzymując możliwość zarówno odtwarzania w stereo (o tym potem), jak i podłączenia przycisku w słuchawkach (czego mi w poprzedniej wersji brakowało). Zahaczając nieco o program: Przede wszystkim założenie o trzymaniu wszystkiego w wewnętrznej pamięci flash modułu ESP32 wydawało się dobrym pomysłem - okazało się jednak, że miejsca nawet po kompresji jest trochę za mało. Co prawda teoretycznie obsługa przez interfejs WWW nie wymagała jakichś specjalnych dedykowanych aplikacji - jednak samo przygotowanie książki jej wymaga, co czyni ów pomysł niespecjalnie trafnym. Dlatego postanowiłem wrócić do pierwotnej koncepcji karty microSD. Dzięki temu mogłem ograniczyć wymagania co do pojemności pamięci flash do 8 MB (przy czym należało pamiętać, że ponad 4MB zajmuje partycja z głosem Mbroli), a tym samym użycie miniaturowej płytki XIAO S3. Tak więc postanowiłem nie opierać się na poprzednim projekcie. Ponieważ największym elementem był akumulator 5000 mAh - wewnętrzna szerokość wyszła mi 75mm. Pozostałe wymiary dopasowywałem na bieżąco w trakcie projektowania. Zacząłem od klawiatury. Postanowiłem zrobić z niej oddzielny moduł (zawierający również gniazdko słuchawkowe) po prostu wsuwany w odpowiednie szczeliny w obudowie. Jako że długość gniazda wyznaczała rozmiar modułu, nie musiałem bawić się w miniaturyzację. Na kawałku taniej płytki uniwersalnej umieściłem klawisze i wyłącznik, na drugiej (takiej porządniejszej) ekspander MCP23017 Wyszło to tak: Dzięki ekspanderowi mogłem podłączyć wszystkie klawisze oddzielnie oraz przycisk na słuchawkach. Oprócz scalaka są tak tylko dwa rezystory - jeden 10k jako pullup do resetu, drugi 3.3k do przysisku słuchawek. Całość łączy się pięcioma przewodami z główną płytką. Jako że z założenia konstrukcja miała być raczej prowizorycznym prototypem - nie bawiłem się w jakieś wymyślne płytki i miniaturyzacje. Znów kawałek uniwersalnej, na nim XIAO wetknięty w dwa żeńskie goldpiny (żeby można było później wyjąć) i dekoder I2S (co prawda wlutowany, ale pięć pinów wystarczy dmuchnąć hotairem). Dodatkowo rezystory dzielnika i kondensatorek do pomiaru stanu akumulatora - i prowizorka wyszła tak: Oddzielnie umieściłem moduł DS3231 (ten z EEPROM-em) i gniazdo karty microSD (miałem takie do Wemosa D1 Mini, wystarczyło dociągnąć jeden drucik żeby mieć wszystkie piny po jednej stronie): Docelowo miało to być umieszczone nad akumulatorem, czyli miejsca miałem dużo... I tu uwaga: mimo że starałem się zrobić to z gotowych modułów, jednego nie mogłem przeskoczyć: pamięci FRAM. Postanowiłem po prostu przylutować ją "na plecach" EEPROM-u moduły zegarka, zwierając linie adresowe do masy. W ten sposób miałem tam dwie pamięci: EEPROM na adresie 0x57 i FRAM na 0x50. Obudowa po umieszczeniu w niej akumulatora (widać, skąd takie a nie inne wymiary wygląda tak): A zmontowana całość razem z płytką główną i kłębowiskiem kabli: Teraz wystarczyło wydrukować górną część obudowy i urządzenie było gotowe do testów (przy okazji w zdjęciu zawarta jest informacja że nie jestem wielbłądem): W międzyczasie oczywiście powstawał program. Nie będę wnikał w szczegóły (kod w załączniku, każdy może obejrzeć), powiem tylko jakie są możliwości: Odtwarzanie audiobooków z możliwością przyspieszenia (pliki sonicFiler.cpp i sonicFilter.h w katalogu src są przystosowane do współpracy z popularną biblioteką ESP8266Audio) Odtwarzanie ebooków za pomocą syntezatora Mbrola Głosowe komunikaty (również generowane Mbrolą) Możliwość zrobienia zakładki (jednej na książkę) Autozakładka czyli możliwość zrobienia "redo" jeśli coś się pogubiłem w przewijaniu Możliwość przechowywania 511 książek (audio i ebook razem) z zapamiętywaniem ostatnio słuchanej książki oraz pozycji w każdej książce Zapis pozycji w pamięci FRAM co kilka sekund (audiobook) lub co zdanie (ebook) umożliwia powrót do ostatnio słuchanej pozycji nawet w przypadku nieoczekiwanego wyłączenia zasilania Ebooki podzielone na zestawy po max. 16 pozycji, ilość zestawów nieograniczona Przewijanie w trakcie odtwarzania jest możliwe (czasowe przy audio, zdanie/akapit przy ebookach) ale bez przeskoczenia granic pliku mp3 (audio) czy rozdziału (ebook), jast to możliwe tylko w trybie pauzy Podanie ogólnych lub szczegółowych informacji o bieżącej pozycji czytania Zegarek (godzina i minuta) oraz stan akumulatora (w procentach) Do wgrania audiobooka trzeba wyjąć kartę i przełożyć do czytnika. Za pomocą programu mkaudiobook mogę wgrać audio na kartę, z możliwą korektą (mono 65 kbps dla czytanych książek lub kopia dla słuchowisk stereo). Program przy okazji tworzy pliki informacyjne dla każdego pliku mp3 - nie jest to konieczne, Lekton potrafi sobie sam te pliki utworzyć, ale wtedy pierwsza próba odtworzenia rozpoczyna się od stworzenia owych plików, i ma się czas na zrobienie kawy. Co prawda nie przewiduję takiej sytuacji - ale pozostawiam sobie możliwość przegrania audiobooka z komputera na którym nie mogę uruchomić programu. Ebook (w odpowiednim formacie tekstowym, można go zrobić dowolnym edytorem tekstu w ciągu paru chwil z pliku txt ebooka) też może być przegrany bezpośrednio, ale wygodniejsze jest przegranie za pomocą dedykowaniej aplikacji. Aplikacja (Python3 i Gtk+ 3) umożliwia wygodne wgrywanie/usuwanie książek i robienie porządków na karcie poprzez połączenie do USB. Ogólnie jest tam tego trochę więcej, ale nie będę Was zanudzać szczegółami. Oczywiście jak najszybciej wziąłem się do testowania. Już następnego dnia wyskoczył problem: czy ja to coś wyłączyłem czy może leży sobie i podgryza akumulator? Mógłbym oczywiście dodać jakieś ledy ale w porę się opamiętałem: przecież na dekoderze I2S świeci sobie na czerwono śliczna dioda, wystarzy dodać okienko przez które będzie ją widać. Drugi problem był raczej natury usability: identyczne przyciski utrudniały szybkie znalesienie właściwego. Tak więc przycisk START zrobiłem nieco większy i wyczuwalny pod palcem, przy okazji poprawiłem suwak wyłącznika (na zdjęciu wydrukowane żółtym filamentem), dorobiłem okienka nad diodą I2S i przy okazji nad kontrolką ładowania XIAO - i wyszło to tak: Teraz mogłem wziąć się do dłuższych testów. Jak zwykle wyskoczyły jakeś drobne poprawki w programie, ale to było do przewidzenia i poprawiałem na bieżąco. I pewnie bym to w takiej postaci pozostawił, gdyby nie dwie sprawy: po pierwsze urządzenie było jednak nieco za duże, po drugie nie wziąłem pod uwagę drobiazgu - mianowicie naładowanie do pełna akumulatora za pomocą rachitycznej ładowareczki XIAO trwałoby jakiś tydzień... Ponieważ nie miałem jakiegoś porządnego modułu z gniazdem microSD, a nie bardzo miałem ochotę na lutowanie jakiegoś milimetrowego rastra (cóż, oczy już nie te co kiedyś) poszukałem trochę po sieci i znalazłem coś co wydawało mi się idealne do moich celów: produkcji Adafruit płytka z gniazdem, którą montuje się pod płytką XIAO. Trochę musiałem poczekać, bo botlandowe "kilka dni" zmieniło się w dwa tygodnie, ale wreszcie zamówiłem, przyszła... I po rozpakowaniu myślałem że mnie coś strzeli. Nauczka na przyszłość: zanim coś zamówisz obejrzyj sobie duże zdjęcie i nie chrzań, że się nie chce okularów szukać. Okazało się, że jakiś geniusz z Adafruit nie bardzo chyba wiedział jak się obchodzić z chińskimi wynalazkami. Gniazdo jest na płytce umieszczone tak, że kartę trzeba włożyć centralnie na płytce (trochę by to było niewygodne ale ujdzie), to jeszcze od tyłu (nie od strony gniazda USB na XIAO). Po prostu nie zauważyłem, że gniazdo na płytce nie jest umieszczone tak jak myślałem (czyli z przodu przy krawędzi) ale dokładnie odwrotnie! Czyli mój piękny projekt PCB mogłem wyrzucić do kosza i zacząłem się zastanawiać, co z tym fantem zrobić. W desperacji chwyciłem nożyce do laminatu, przyciąłem płytkę tak że mogłaby się zmieścić na PCB... i udało się! Teraz już mi sie nie chciało siadać do projektowania. Przed nosem leżała sobie porządna płytka uniwersalna 70x50 mm, akurat mieściły się obok siebie S3 i to nieszczęsne gniazdko. Rezystorki i kondensator w wersji SMD poszły na spód płytki (na szczęście 0805 bardzo ładnie pasują do rozstawu pól lutowniczych na płytce), parę połączeń kynarem - i gotowe! Mogłem zmniejszyć obudowę do jakichś rozsądnych rozmiarów! Wewnątrz wygląda to tak: Jak widać, cała elektronika zmieściła się nad akumulatorem, co pozwoliło mi na zmniejszenie długości obudowy. Dodałem jeszcze otwór przez który mogę się dostać do wtyczki akumulatora (zrobiłem sobie kiedyś taką uniwersalną ładowarkę do LiPo, przy 1A powinno się przez noc naładować), wydrukowane z polipropylenu zaślepki (wolałbym żeby jakieś paprochy z kieszeni nie dostały się do wnętrza), drugie okienko na drugą diodę XIAO (sygnalizuje stan urządzenia STOP/PAUZA/PLAY) - i w efekcie wygląda to tak: Tym razem kilkudniowe intensywne testy wykazały, że urządzenie w tej wersji jest wygodne i spełnia wszystkie moje oczekiwania. Na zakończenie kilka słów o załączonym pliku Lekton.zip. W kodzie pozostawiłem wyłączone fragmenty. MSC nie udało mi się uruchomić (zresztą w pewnym momencie zrezygnowałem z uwagi na dziwaczne problemy z komunikacją serial w trybier TinyUSB/CDC). Plik wifi pozostawiłem bo jest dość uniwersalny, krótki i być może ktoś będzie potrzebować czegoś podobnego. Plik OpenSCAD-a jest raczej do pooglądania sobie, nie jest stuprocentowo kompletny ale raczej chciałem pokazać w jaki sposób można w tym programie stworzyć projekt w miarę skomplikowanej obudowy. Gdyby ktoś koniecznie chciał uruchomić to u siebie, należy z GitHuba zgrać plik espola_pl1_full.blob i wgrać go do ESP od adresu 0x36E000 (zgodnie z adresem w mbro8nof.csv). W razie jakichkolwiek pytań jestem do dyspozycji.

Cześć, Kilka dni temu zrobiłem sobie przełącznik audio. Na wejściu wpinam laptopa oraz komputer, a na wyjściu słuchawki i głośniki. Pomiędzy wejściem a wyjściem mam dwa przełączniki on-off-on 4PDT, pierwszy wybiera wejście (komputer, laptop), a drugi wyjście (słuchawki, głośniki). Ogólnie wszystko działa dobrze, ale przy pierwszym przełączeniu każdego dnia ze słuchawek lub głośników wydobywa się taki głośniejszy trzask. ChatGPT podpowiedział mi, że powinienem albo połączyć wszystkie masy albo połączyć L i R do masy dla stanu wyłączonego wyjściowego przełącznika, ale nie wiem czy mu ufać. Spięcie mas brzmi dość logicznie, ale nie jestem pewien czy masa z laptopa i komputera powinna być wspólna. Co zrobić, żeby nie było strzelania przy przełączaniu? Załączam schemat, nie jest najbardziej profesjonalny ale mam nadzieję, że czytelny. Oraz zdjęcie

Wstęp Tym razem z drugiej strony medalu... nieudany projekt, a raczej projekt, który tak daje w kość, że dalsza jego budowa jest odłożona do momentu, aż będę miał lepszy nastrój. Jako, że posiadam "klawiaturę" MPK Mini IV chciałem sobie zbudować syntezator, który może odtwarzać dźwięki, by nie musieć podłączać się do Abletona. Artykuł powstał we współpracy z firmą Botland. (Prawie) wszystkie pliki projektu można znaleźć też na GitHubie. Ostateczna forma urządzenia Na początek o MIDI MIDI to interfejs UART o dość nietypowym baud rate wynoszącym 32 500. Pierwszym napotkanym problemem było to, iż optotranzystory CNY17-3 nie mają dostatecznej szybkości i sygnał był całkowicie bezużyteczny. Jako, że większość instrumentów używa optotranzystorów 6N138 postanowiłem zajrzeć do noty i zobaczyłem, że posiadają na wyjściu układ Darlingtona. Dodając dodatkowy tranzystor na wyjściu CNY17-3 udało się uzyskać oczekiwany efekt. Zaprojektowałem płytkę wraz ze złączem TRS 3.5mm, aczkolwiek okazało się, że posiadane przeze mnie gniazda mają błędny symbol, a co za tym idzie są praktycznie bezużyteczne do tego celu. Więcej można poczytać tutaj. Wadliwa płytka PCB Szybko podmieniłem złącze 3.5mm na gniazdo XH2.54 i wykonałem drugą płytkę. Tym razem połączyłem ją z gniazdem TRRS 3.5mm zakupionym w Chinach, ale można też podobne dostać w kraju. Testy nowej płytki Jak widać druga wersja działała "bezproblemowo". O przewodach słów kilka Jako, że mój AKAI MPK Mini ma wyjście DIN 5-pin, a chciałem by syntezator używał złącza 3.5mm postanowiłem najzwyczajniej zakupić przewód ze znanego portalu na A, aczkolwiek trafiłem na taki, który miał nieprawidłowy pinout (okej, o ile byłoby to MIDI B to żaden problem, ale ten miał wyprowadzone piny 1, 4 i 2 ze złącza DIN, gdy MIDI używa pinów 2, 4 i 5... No cóż... odesłałem i kupiłem elementy (wtyki DIN (5P) oraz 3.5mm TRS (3P)) by zrobić sobie go samemu (wyszło taniej niż zaufany przewód ze sklepu audio). Połączenia w przewodzie i sam przewód... Jako samego przewodu użyłem dwużyłowego OMY 2x0.5mm, aczkolwiek dużo lepszym wyborem byłby przewód sterowniczy 2x0.5 z osłoną podłączoną do pinu 2 (SHIELD), który w moim przypadku był pominięty (brak odpowiedniego przewodu w szufladzie). Przy samym lutowaniu na szczęście przy lutowaniu obyło się bez problemów... za to niespodzianki czekały mnie chwilę później... Sam syntezator... Do budowy syntezatora użyłem Raspberry Pi Pico, wcześniej wspomianej płytki do optoizolacji MIDI, kodeka VS1053 od Adafruit oraz kilku płytek TRRS. Ustawiłem bootstrapping kodeka do trybu RT-MIDI (GP0: 0, GP1: 1) używając rezystorów 330R wlutowanych bezpośrednio w złącza płytki... Zasilanie kodeka podłączyłem do wyjścia regulatora 3.3V na Pico i okazało się, że kodek nie działa. Kod programu dla prototypu: /* * MIDI UART Pass-Through for Raspberry Pi Pico * * UART0: GP0 = TX, GP1 = RX @ 31250 baud (MIDI) * * Modes: * GP16 HIGH (default, pull-up): UART0 RX → UART0 TX pass-through * GP16 LOW (pin to GND): USB Serial → UART0 TX */ #define USBSERIAL_BAUD 115200 #define MIDI_BAUD 31250 #define MODE_PIN 16 // GP16 — internal pull-up; LOW = USB-to-MIDI mode #define RST_PIN 12 void setup() { // USB Serial (for USB-to-MIDI mode) Serial.begin(USBSERIAL_BAUD); pinMode(0, OUTPUT); pinMode(1, INPUT); // UART0: GP0 = TX, GP1 = RX // Serial1 maps to UART0 on Pico by default Serial1.setTX(0); Serial1.setRX(1); Serial1.begin(MIDI_BAUD); // Reset is needed (and has to be in high to operate) pinMode(RST_PIN, OUTPUT); digitalWrite(RST_PIN, LOW); delay(10); digitalWrite(RST_PIN, HIGH); delay(10); // Mode select pin with internal pull-up pinMode(MODE_PIN, INPUT_PULLUP); } void loop() { if (digitalRead(MODE_PIN) == HIGH) { // ── Mode A: UART RX → UART TX pass-through ────────────────────────────── // Forward every byte arriving on GP1 (RX) straight back out on GP0 (TX). // Useful for chaining MIDI devices or monitoring/relaying a MIDI stream. while (Serial1.available()) { Serial1.write(Serial1.read()); } } else { // ── Mode B: USB Serial → UART TX ──────────────────────────────────────── // Forward MIDI bytes arriving over USB (e.g. from a DAW or USB-MIDI // Forward every byte arriving on GP1 (RX) straight back out on GP0 (TX). // adapter driver) out to the hardware MIDI port on GP0. while (Serial.available()) { Serial1.write(Serial.read()); } while (Serial1.available()) { Serial1.write(Serial1.read()); } } } Urządzenie nie działało ani poprzez złącze Jack podłączone do UARTa, ani przez USB (oczywiście po podciągnięciu GP16 do masy)... Problemem było to, iż nie podłączyłem pinu RST, który jest oznaczony na odwrót (w rzeczywistości jest to NRST)... Okej, poprawiłem i dodałem fragment w kodzie programu... dalej nie działa. Tym razem problemem okazało się zasilanie kodeka... Zmieniając VCC na 5V z pinu VBUS kodek zaczął działać poprawnie i grał nuty klikane na pianinie. Dźwięk był nieco cichy, ale to urok braku wzmacniacza. Gorzej było jak chciałem przetestować inne instrumenty i okazało się, że jakimś cudem port COM przestał działać. Winowajca? Otóż kodek pobierający zasilanie z VBUS... po odłączeniu zasilania kodeka wszystko działało poprawnie, a urządzenie chciałem zasilać z USB, bo i tak ta magistrala byłaby używana do konfiguracji... W tym momencie stwierdziłem, że ten projekt zdecydowanie nie chce ze mną współpracować i trzeba go na chwilę odłożyć... Walka z wiatrakami Dłuższy czas szukałem przyczyny, a okazało się że znajduje się po innej stronie lutownicy... Port USB, do którego podłączyłem urządzenie nie dawał pełnego natężenia prądu. Gdy włożyłem przewód do portu, który zawsze daje minimum 0.9A wszystko nagle zaczęło działać poprawnie. Czasem te najprostsze rzeczy są najtrudniejsze. Gdy zacząłem testować komunikację po USB ta potrafiła cały czas wysyłać wartość 0xFF, która za to powodowała problemy z odczytywaniem pakietów danych po czym urządzenie wpadało w błąd i kodek się zawieszał. Rozwiązałem to usuwając przełącznik trybu (i tak MIDI powinno działać cały czas) oraz dodając weryfikację pakietów MIDI wysyłanych z poziomu USB. Rozwiązało to problem i urządzenie gra całkiem ładnie (pomiając, że jest ciche przez brak wzmacniacza). /* * MIDI UART Pass-Through for Raspberry Pi Pico * * UART0: GP0 = TX, GP1 = RX @ 31250 baud (MIDI) * * Both USB Serial and UART0 RX are forwarded to UART0 TX. * USB input is parsed and validated — System Reset (0xFF) is silently dropped. * UART RX is echoed back to USB Serial for monitoring. * VLSI chip is reset on startup via RST_PIN. */ #define MIDI_BAUD 31250 #define RST_PIN 12 // GP15 — adjust to your wiring // --------------------------------------------------------------------------- // MIDI parser — used for USB input only (UART is a trusted hardware source) // --------------------------------------------------------------------------- int midiMessageLength(uint8_t status) { if (status == 0xFF) return 1; // System Reset — handled as special case if (status == 0xF0) return -1; // SysEx — variable if (status >= 0xF0) { switch (status) { case 0xF1: return 2; // MIDI Time Code case 0xF2: return 3; // Song Position Pointer case 0xF3: return 2; // Song Select case 0xF6: return 1; // Tune Request case 0xF7: return 1; // End of SysEx case 0xF8: return 1; // Timing Clock case 0xFA: return 1; // Start case 0xFB: return 1; // Continue case 0xFC: return 1; // Stop case 0xFE: return 1; // Active Sensing default: return 0; // Unknown — discard } } switch (status & 0xF0) { case 0x80: return 3; // Note Off case 0x90: return 3; // Note On case 0xA0: return 3; // Poly Aftertouch case 0xB0: return 3; // Control Change case 0xC0: return 2; // Program Change case 0xD0: return 2; // Channel Aftertouch case 0xE0: return 3; // Pitch Bend default: return 0; // Unknown — discard } } // Parser state for USB input static uint8_t usbBuf[3]; static int usbBufLen = 0; static int usbExpected = 0; static bool usbInSysEx = false; void processUsbByte(uint8_t b) { // ── Real-Time messages ───────────────────────────────────────────────────── // Single byte, can appear anywhere. System Reset (0xFF) is dropped. if (b >= 0xF8) { if (b != 0xFF) { Serial1.write(b); Serial.write(b); // Echo to USB } return; } // ── End of SysEx ────────────────────────────────────────────────────────── if (b == 0xF7) { if (usbInSysEx) { Serial1.write(b); Serial.write(b); usbInSysEx = false; } usbBufLen = 0; usbExpected = 0; return; } // ── Start of SysEx ──────────────────────────────────────────────────────── if (b == 0xF0) { usbInSysEx = true; usbBufLen = 0; usbExpected = 0; Serial1.write(b); Serial.write(b); return; } // ── SysEx data bytes ────────────────────────────────────────────────────── if (usbInSysEx) { if (b < 0x80) { Serial1.write(b); Serial.write(b); } return; } // ── Status byte ─────────────────────────────────────────────────────────── if (b >= 0x80) { usbBufLen = 0; usbExpected = midiMessageLength(b); if (usbExpected == 0) return; usbBuf[usbBufLen++] = b; if (usbExpected == 1) { Serial1.write(b); Serial.write(b); usbBufLen = 0; usbExpected = 0; } return; } // ── Data byte ───────────────────────────────────────────────────────────── if (usbExpected == 0) return; // Orphaned data — discard usbBuf[usbBufLen++] = b; if (usbBufLen >= usbExpected) { Serial1.write(usbBuf, usbBufLen); Serial.write(usbBuf, usbBufLen); // Echo complete message to USB usbBufLen = 0; usbExpected = 0; } } // --------------------------------------------------------------------------- void setup() { Serial.begin(MIDI_BAUD); // USB Serial Serial1.setTX(0); // GP0 Serial1.setRX(1); // GP1 Serial1.begin(MIDI_BAUD); // VLSI reset — hold LOW briefly then release HIGH to operate pinMode(RST_PIN, OUTPUT); digitalWrite(RST_PIN, LOW); delay(10); digitalWrite(RST_PIN, HIGH); delay(10); } void loop() { // UART RX → UART TX (trusted hardware source, pass straight through) // Also echo to USB so the host can monitor incoming MIDI traffic while (Serial1.available()) { uint8_t b = Serial1.read(); Serial1.write(b); Serial.write(b); } // USB → UART TX (untrusted, run through MIDI parser) // Validated bytes are echoed back to USB inside processUsbByte() while (Serial.available()) { processUsbByte((uint8_t)Serial.read()); } } Kod programu był w pełni wygenerowany przez model Claude Sonnet 4.6 Extended bazując na opisie wyprowadzeń i założeniach projektowych. Jest to prosty skrypt kopiujący dane z wejść portów szeregowych na ich wyjścia (włącznie z kopiowaniem krzyżowym), który też uwzględnia rozmiar pakietu USB. Mogą w nim jeszcze wystąpić problemy, gdy USB zareaguje w połowie komendy otrzymanej z kontrolera MIDI, aczkolwiek jest to dość mało prawdopodobne (zadaniem USB jest głównie konfiguracja kanału/ów i instrumentu/ów). Obudowa i ostatnie poprawki Upchane bebechy urządzenia Ostatnim zadaniem jakie pozostało było zaprojektowanie obudowy i wepchanie bebechów. Mocowanie chińskich wejść audio już miałem opanowane - wystarczy dać im dwa panele po bokach i jeden dokręcany śrubką z tyłu. Pod spodem umieścić podstawę, która ma wycięcie pod pinami, by wygodnie wyprowadzić przewody i gotowe. Reszta komponentów została włożona do obudowy luzem (po owinięciu taśmą izolacyjną, bo nikt nie lubi zwarć)... Czy można zaprojektować obudowę z mocowaniami? Tak. Czy warto? Raczej nie, bo to zajmuje dość sporo czasu, a może okazać się, że któryś przewód jest za krótki Czasem najprostsze rozwiązania są najlepsze (zawsze mogę potraktować elementy klejem na gorąco, by nie latały). Pliki STL oraz plik 3MF dla Bambulab X1C są dostępne tutaj: Syntezator STL.zip Python - programy do kontroli Programy kontrolujące interfejs Oprócz zwykłego działania jako pianino postanowiłem poprosić Claude o wygenerowanie programów do kontroli urządzenia jako interfejsu USB MIDI (do odtwarzania plików .mid) oraz programu konfiguracyjnego by móc łatwo zmieniać instrumenty czy poziom głośności. Poradził sobie całkiem dobrze (program do odtwarzania plików wymagał drobnej poprawki w kwestii tego, iż pliki MIDI zawierają odstęp czasowy od poprzedniego dźwięku, a nie od początku klipu). Oba programy są dostępne na GitHubie (link na początku artykułu). Co by się jeszcze przydało? Opcjonalnie można przestawić ustawienia portu USB z CDC na MIDI, by widziały go wszystkie profesjonalne programy, ale osobiście wolę CDC

Dzisiaj na razue krótko. Potrzebny był program, który umożliwi testowanie różnych kodeków audio. Zadanie testera to: odsłuchanie fragmentu tekstu po przejściu przez kodek i porównanie go z oryginalnym tekstem (audio i txt). Klasa phosgen służy do generowania zdań, składających się ze słów nie mających żadnego znaczenia, ale zgodnych z polską fonetyką (unika niejednoznaczności): #!/usr/bin/env python3 import random class phosgen(object): vopal = ['i','ia','ią','ie','ię','io','iu'] vobeg = ['a','e','o','u','i'] vonor = ['a','e','o','u','y','ą','ę'] vonoj = ['a','e','o','u','ą','ę'] voall = vonor + vopal # przed samogłoską cobeg = ['b','c','d','f','g','ch','j','k','l','m','n','p','r','s','t', 'w','z','ż','dz','sz','cz'] # samogłoska nie może być zmiękczająca conop = ['j','r','sz','cz','ś','ć','ń','ź','ż','dż','dź'] # spółgłoski bezdźwięczne cosil = ['c','f','k','p','cz','sz','ś','ć','t'] # spółgłoski po bezdźwięcznej rozpoczynające sylabę coasil = ['c','f','k','p','t','cz','sz'] # spółgłoski po dźwięcznej rozpoczynające sylabę coavoc = ['b','d','g','ch','l','m','n','r','w','z','ż','dz'] # spółgłoski kończące cofin = cobeg + ['ś','ć','ń','dź','dż'] # spółgłoski obojętne colon = ['ch','j','l','m','n','ń','r'] # spółgłoski kończące zdanie cofsil = cosil + colon # po nich nie może być z conz = ['dż','dź','dz','r','d'] def selsyl(self): kl = random.choice([3,4,5,6]) self.sensyl=random.choices([1,2,3,4],weights=[1,4,2,1],k=kl) if self.sensyl[-1] == 1: self.sensyl[-1] = random.choices([2,3,4],weights=[4,2,1],k=1)[0] self.starter = None self.sentence=[] for n,ls in enumerate(self.sensyl): self.sentence.append(self.genword(ls,n == len(self.sensyl) - 1)) return ' '.join(self.sentence) def choset(self, a,b=None): while True: c=random.choice(a) if c != b and not ((c in self.__class__.conz and b == 'z')): return c def gensyl(self, snum, final): syl=[] if random.random() < 0.4 and snum == 0: syl.append(random.choice(self.vobeg)) else: if self.starter is None or self.starter in self.__class__.colon: znak = self.choset(self.__class__.cobeg,self.starter) elif self.starter in self.__class__.cosil: znak = self.choset(self.__class__.coasil,self.starter) else: znak = self.choset(self.__class__.coavoc, self.starter) syl.append(znak) if znak == 'j': syl.append(self.choset(self.__class__.vonoj)) elif znak in self.__class__.conop: syl.append(self.choset(self.__class__.vonor)) else: syl.append(self.choset(self.__class__.voall)) self.starter = None if random.random() < 0.5: if final: self.starter = self.choset(self.__class__.cofsil) else: self.starter = random.choice(self.__class__.cofin) syl.append(self.starter) return ''.join(syl) def genword(self,ls,a): wrd = [] for i in range(ls): wrd.append(self.gensyl(i,a and i == ls - 1)) return ''.join(wrd) if __name__ == '__main__': p=phosgen() print(p.selsyl()) Co prawda podstawowym zastosowaniem jest zsyntetyzowanie wyniku działania i ocena zrozumiałości (dlatego wyrazy nie mają sensu, aby nie by…ło miejsca na jakieś domysły), ale może służyć do różnych celów - może ktoś coś wymyśli? Przykładowe teksty wygenerowany przez phosgen: piawecz kę żotia adniądz chyciuj wygwięc kiasze żeżąf ozwiącho cząnu Właściwy program jest co prawda przeznaczony dla Linuksa (test codec2 + RHVoice ) ale pewnie dałoby się coś podobnego stworzyć dla innych systemów/syntezatorów/kodeków: #!/usr/bin/env python from phosgen import phosgen import os,subprocess, random class phtest(phosgen): # folder z c2dec i c2enc c2path = os.path.join(os.environ ['HOME'],'codec2/build_linux/src') def __init__(self): self.voice = 'michal' self.sprate = 75 self.comma=True # ustaw bitrate self.bitrate='1300' # odkomentuj jeśli chcesz powtarzalnych wyników # i zamień 123 na jakąś liczbę int #random.seed(123) def runsgl(self,basepath): txt = self.selsyl() if self.comma: txt = txt.replace(' ',', ') ftx = basepath+'.txt' open(ftx,'w').write(txt+'\n') wav1 = basepath+'_orig.wav' wav2 = basepath+'_eff.wav' p1=subprocess.Popen(['RHVoice-test', '-p', self.voice, '-r', str(self.sprate), '-o', wav1],stdin=subprocess.PIPE) p1.communicate(txt.encode('utf-8')) p2=subprocess.Popen(['sox',wav1,'-t','raw','-r','8000','-'], stdin = p1.stdout, stdout=subprocess.PIPE) p3=subprocess.Popen([os.path.join(self.__class__.c2path, 'c2enc'),self.bitrate,'-','-'], stdin = p2.stdout, stdout=subprocess.PIPE) p4=subprocess.Popen([os.path.join(self.__class__.c2path, 'c2dec'),self.bitrate,'-','-'], stdin = p3.stdout, stdout=subprocess.PIPE) p5=subprocess.Popen(['sox','-t','raw','-b','16','-e','signed-integer', '-c','1','-r','8000','-','-t','wav',wav2], stdin=p4.stdout) o=p5.communicate()[0] p2.wait() p3.wait() p5.wait() print("Tekst:", ftx,'Synteza:', wav1, 'Efekt:',wav2) c=phtest() c.runsgl('a1') Jeśli komuś się przyda - bardzo dobrze. W załączniku m.in. efekty działania w postaci plików wav: pltest.zip

Wpadłem ostatnio znowu w fazę robienia rekwizytów (czasem mi się to zdarza). Oczywiście nie wszystkie mają coś wspólnego z elektroniką (bateryjki z przetwornicą, wyłącznikiem i 7 ledami nie uważam za szczyt osiągnięć współczesnej elektroniki), ale np. opisywana ostatnio kuchenka już tak. I w tej "fazie" powstał kolejny rekwizyt - ale najpierw kilka słów wprowadzenia. Otóż występująca w bajce postać (Pan Niedźwiedź) to taki gadgeciaż. Wszystko ma składane (krzesełka, stolik, nawet filiżanki do herbaty), dlaczego nie miałby słuchać swojej ulubionej muzyki z jakiegoś składanego sprzętu? Na początku jakoś nie miałem pomysłu co to by miał być za sprzęt aż do chwili, gdy w szufladzie w kuchni zobaczyłem silikonowy lejek. I wtedy mnie olśniło: przecież z tego wyjdzie super patefon! Jako że wszystkie dekoracje i rekwizyty w spektaklu to jakaś forma różnych tekturowych pudełek, wziąłem jakieś pudełko po chińskim filamencie, przyłożyłem do tego lejek... powstała tak absurdalna konstrukcja że stwierdziłem, że muszę to zrobić! Przeszukanie moich rupieci zaowocowało kilkoma elementami: ESP32 Lite (chciałem mieć zasilanie z baterii, ale o tym potem), mały wzmacniaczyk z potencjometrem na PAM8403 (kiedyś kupiony w Botlandzie ale ślad po nim w sklepie zaginął) no i oczywiście mały głośnik. Jako że klika urządzeń na takim zestawie już kiedyś zrobiłem, zabrałem się do pisania prostego programu... No i się zaciąłem. Okazało się, że najnowsze wersje boardu Arduino IDE oraz mojej ulubionej biblioteki ESP8266Audio nie przewidują działania takiego urządzenia. Nie bo nie, i koniec. Próby jakiegokolwiek zmuszenia tego do pracy owocowały wywaleniem jakiegoś mało zrozumiałego błędu i resetem ESP. Na szczęście miałem zarówno starą wersję biblioteki (taką sprzed trzech lat) jak i możliwość przełączenia boardu na wersję 2.x mój ESP wydał z siebie jakiś sensowny dźwięk, postanowiłem więc że nie będę wnikał w powody owego niedziałania i zastosuję po prostu te wersje. Patefon jak to patefon - musi być nakręcany, zdarta płyta ma szumieć i trzeszczeć no i oczywiście przeskakiwać. Czyli sekwencja działań ma być taka: Po włączeniu zasilania patefon czeka Po pokręceniu korbką (czemu ma towarzyszyć odgłos nakręcania) uruchamia się "płyta". Po kilku sekundach płyta się zacina Stuknięcie w obudowę ma spowodować, że igła przeskakuje dalej i patefon gra już bez przeszkód (zwrotka w pętli aż do wyłączenia). Jednocześnie dioda powinna pokazywać stan baterii (pali się - bateria nowa, miga - bateria zużyta). Tak więc schemat połączeń patefonu wygląda mniej więcej tak: I od razu pierwsza uwaga: wzmacniacz ma oczywiście potencjometr z wyłącznikiem, ale służy on do załączenia zasilania wyłącznie do tego wzmacniacza. Trezeba więc zasilanie do reszty układu pobrać zza wyłącznika, jak na poniższym zdjęciu: Główną płytkę wykonałem na bazie płytki uniwersalnej. Z lenistwa po prostu wlutowałem goldpiny od ESP32 do płytki - raczej nie przewiduję demontażu, a w razie czego zawsze można dmuchnąć hotairem. Wlutowane są tylko potrzebne piny. Jak widać na płytce oprócz ESP jest niewiele. Potencjometr służy do wstępnego ustalenia maksymalnej głośności, a wszystko jest spięte moimi ulubionymi złączami. Jeśli chodzi o zasilanie wykorzystałem fakt, że ta wersja modułu ESP32 pozwala na zasilanie z akumulatora. Tak więc połączyłem to tak jak na schemacie powyżej: dioda Schottky'ego zapobiega próbom ładowania baterii przy podłączonym USB (raczej by tego nie przeżyły) a jednocześnie pozwala na prawidłowe filtrowanie napięcia przez kondensator (próby uruchamiania urządzenia bez niego powodowały dość silne zakłócenia w głośniczku, a przy tym ESP okazjonalnie się resetował). Napięcie zasilające podłączone jest do wyprowadzenia BAT+ (pin nie jest wyprowadzony, w pierwszych próbach użyłem po prostu odpowiedniej wtyczki, w docelowym układnie nie miało to większego sensu więc przewód zasilający został po prostu przylutowany do wyprowadzenia z tyłu gniazda). No i kwestia korbki. Długo kombinowałem nad mechanicznym układem (jakieś zębatki z zapadkami które by ładnie trzeszczały, ale jak zrobić żeby patefon zaczął grać?) - potem zdałem sobie sprawę że przecież równie dobrze trzeszczeć może głośniczek, korbka ma napędzać najtańszy enkoder a program ma po prostu wykryć kiedy korbką się kręci (trzeszczy) a kiedy przestaje (gra). Proste, tanie i raczej mało awaryjne. Ostatnim elementem (oprócz diody sygnalizującej włączenie i stan baterii) jest czujnik stuknięcia. Początkowo chciałem użyć MPU6050 ale szkoda mi było użycia go wyłącznie jako akcelerometru, lepiej sprawdził się tu ADXL345. Wszystkie elementy połączone w (działającą) całość przedstawiają się tak: Teraz przyszła kolej na włożenie wszystkiego do pudełka, na razie bez montowania tuby. Ponieważ pudełko było w jednym miejscu lekko uszkodzone - zamaskowałem to tabliczką producenta na tylnej ściance. Skąd nazwa "His Slave's Voice" - to już pozostawiam domyślności czytelnika I jeszcze jedno: jeśli ktoś się uważnie przyjrzy zdjęciu może mieć wrażenie, że część terytorium naszego pięknego kraju (konkretniej Kobierzyce) znajduje się w Chinach... Zamontowanie "tuby" i przyklejenie koszyka na baterie zakończyło pracę nad konstrukcją elektroniczno - mechaniczną. Po złożeniu wysięgnika tuby wygląda to tak (przednia pokrywka jest otwarta - widać, że można w łatwy sposób wymienić baterie): Kilka słów o programie: Jak wspomniałem - użyłem starszej wersji boardu i biblioteki. Prawdopodobnie dałoby się to zrobić na najnowszych wersjach ale po prostu nie chciało mi się kombinować. Problem wystąpił wyłącznie wtedy, gdy chciałem w bibliotece ESP8266Audio użyć wbudowanego DAC jako wyjścia dźwięku. Dla tak prostej aplikacji nie cjhciało mi się kombinować. Dźwięk działa w oddzielnym tasku na rdzeniu 0 - ponieważ nie ma tu WiFi.BT, ma cały rdzeń do dyspozycji. Teoretycznie można by było rozbić na taski wszystkie elementy (akcelerometr, korbka, bateria) ale równie dobrze pracują w pojedynczej pętli. Komunikacja między poszczególnymi sekcjami programu odbywa się poprzez zmienne globalne - w tym przypadku nie trzeba było używać jakichś konstrukcji typu kolejka, semafor czy mutex, krótkie spojrzenie na kod powinno wyjaśnić wszystko. No i na zakończenie ciekawostka: przewidziałem możliwość uszkodzenia akcelerometru (patrz kod). Po zmontowaniu okazało się że akcelerometr nie działa, a zabezpieczenie doskonale zdało egzamin (płyta zacięła się 5 razy i pojechała dalej). Przyczyna była prosta: udało mi się przewiercić taśmę łączącą akcelerometr z główną płytką Tak wygląda patefon gotowy do pracy. Poniżej filmik (bałem się czy automaty YT nie uznają fragmentu "starego niedźwiedzia" za naruszenie praw autorskich, ale jakoś to przepuściły: Dźwięk powstał przy użyciu Audacity (montaż) i sox (niestety, Audacity nie chciał mi wygenerować pliku raw 16 khz 8-bit unsigned co nie powinno dziwić, bo nie do tego służy). Wynikowy plik raw został przekształcony na dane w pliku .h prostym programem w Pythonie: #!/usr/bin/env python3 muza=open('px1.raw','rb').read() print("static const uint8_t muza1[]={") pams=[] lem=len(muza) while len(muza) > 0: partia=muza[:16] muza=muza[16:] parl=list(partia) for n,a in enumerate(parl): #korekta wartości, oryginalne były za ciche a=((a-128) * 3) + 128 if a < 0: a=0 elif a > 255: a=255; parl[n]=a parl=','.join(list("%d" % x for x in parl)) pams.append(parl) print(',\n'.join(pams)) print('};') print ("static const int muza1len = %d;" % lem) #wartości 631808 i 767760 to numery sampli z Audacity przed resamplingiem print ("static const int muza1rpt = %d;" % int((lem *631808)/ 767760)) No i oczywiście kod całości w załączniku: Patefon.zip Zapraszam do Teatru

Hej, Przychodzę do Was z dość nietypową sprawą, dużo rozglądałem się po forum, mega fajne projekty. Ostatnio złapałem niezłą zajawkę na elektrotechnikę. Zainteresował mnie pewien filmik, który mocno mnie nakręcił, żeby coś takiego odtworzyć, poniżej link: Ale problem polega na tym, że nie do końca wiem czym to spiąć, żeby po naciśnięciu przycisku (Self reset) jednokrotny, kontroler (Proszę o poradę jaki) otrzyma sygnał i następnie odtworzy muzykę i wyłączy światło 1 (Stałe) i załączy światło 2 (lampa dyskotekowa) po czym pogra np. 30 sekund i wróci do stanu początkowego. Co myślicie, że mógłbym tutaj użyć ? Rozważałem Arduino, tylko jakie ? Dziękuje z góry za pomoc i pozdrawiam.

Chciałbym przerobić słuchawki przewodowe na BT i wsadzić im akumulatorek. Czy są jakieś moduły Bluetooth (najlepiej 5.0 lub nowsze) takie że jak połączę telefon przez BT to na tel wyświetli się poziom baterii słuchawek? Bo wszystkie słuchawki i głośniki BT które testowałem to wspierały. Na tel w ustawieniach BT wyświetla się poziom baterii podłączonych słuchawek.

Witam. Realizuję projekt matrycy mikrofonów z wykorzystaniem mikrofonów MEMS ICS-52000 oraz mikrokontrolera, który służy do zbierania danych z mikrofonu w celu dalszej analizy dźwięku np. w MATLAB'ie. Mam problem z komunikacją z mikrofonami. Mikrofony ICS-52000 mają wyjście TDM i mam takich mikrofonów połączonych w łańcuch zgodnie z dokumentacją (zdjęcie poniżej). Celem jest pobranie danych z mikrofonów i zapisanie ich na dysku. Póki co mam gotową konstrukcję i próbuję pisać program, który pobierze dane z każdego mikrofonu. Moje pytanie brzmi: W jaki sposób zrealizować mogę komunikację TDM (Time Division Multiplexing)? Nie ma na ten temat za wiele materiałów. To co udało mi się znaleźć to zastosowanie interfejsu SAI (Serial Audio Interface) i próbowałem ten interfejs wykorzystać jednak podłączając tylko jeden mikrofon w celu jego stestowania nie działało to tak jak powinny. Próbowałem pobrać dane przez HAl_SAI_Receive_DMA() i w funkcji callback void HAL_SAI_RxCpltCallback(SAI_HandleTypeDef *hsai) przypisać wartość do zmiennej, jednak nie działało to. Szczerze to nie ma zbyt wielu przykładów zastosowania tego interfejsu do rejestracji dźwięku, a z dokumentacji co udało mi się wyczytać to SAI wspiera TDM. Konfiguracja interfejsu SAI Mode: Master Konfiguracja zegara: Po włączeniu SAI w tej konfiguracji mam 3 piny: SAI1_SD_A - wyjście danych SAI1_SCK_A - zegar SAI1_FS_A - frame select (word select) Czy zegar jaki podaje na wyjścia mikrofonów równy jest wartości zegara SAI1 (24MHz)? Czy częstotliwośc SAI1_FS_A równa jest częstotliwości audio (48kHz), czy musze ten pin obsługiwać w jakiś sposób? Według dokumentacji mikrofony są synchronizowane przez sygnał WS, więc mikrofony dzielące ten sam zegar będą samplowane synchronicznie.

Hej. Mam amplituner Beomaster 1100 typ 2609. Stary, duński sprzęt ale nadal fajny. Mam problem z jasnością świecenia dwóch żarówek, które z jednej strony świecą jako POWER ale też "podpowiadają" czy kręcić pokrętłem w lewo czy w prawy gdy szukam fali FM. Sterują tym dwa tranzystory. Nie mogę dojść co tu nie gra. Radio nie działało w ogóle ale naprawiłem. Uwalony był rezystor. Wymieniłem też rezystory mocy R19 i R24. Serwisówka podaje że mają być 3W a były wlutowane 2W. Z jednego to się kopciło gdy FM złapało stereo. Wylutowałem tranzystory IC2 i IC3 i wyglądają na dobre. Tester urządzeń elektronicznych rozpoznaje je dobrze. Jedynie co mnie dziwi to dlaczego między B a C mam spadek napięcia 0.6V a między B a E 1.2V? Tranzystory to MPSA13. Bang-Olufsen-Beomaster_1100-Service-Manual.pdf strona 22, dział 8-1. Wcześniejszy schemat dotyczy innego typu amplitunera.

Cześć, przeprowadzam akwizycję dźwięku z 4 mikrofonów MP34DT01-M przy użyciu interfejsu SAI oraz biblioteki pdm2pcm na STM32H743. 1. Moje pierwsze pytanie dotyczy typów zmiennych użytych w buforach PDM i PCM. Dane z 4 mikrofonów zapisuję w 32-bitowych slotach (po 8 bitów na mikrofon) w każdej ramce. Obecnie wygląda to u mnie tak: #define PDM_buffer_size 4096*4*6 //szóstka dobrana eksperymentalnie #define PCM_buffer_size 4096*4 // równy output_samples_number uint32_t PDM_buffer[PDM_buffer_size]; //bufor wejściowy PDM uint16_t PCM_buffer[PCM_buffer_size]; //bufor wyjściowy PCM HAL_SAI_Receive_DMA(&hsai_BlockA1, (uint8_t*)PDM_buffer, PDM_buffer_size); //rozpoczęcie akwizycji PDM_Filter(&(((uint8_t*)PDM_buffer)[0]), &(((uint16_t*)PCM_buffer)[0]), &PDM1_filter_handler); //konwersja PDM na PCM mikrofon A PDM_Filter(&(((uint8_t*)PDM_buffer)[1]), &(((uint16_t*)PCM_buffer)[1]), &PDM2_filter_handler); //konwersja PDM na PCM mikrofon B PDM_Filter(&(((uint8_t*)PDM_buffer)[2]), &(((uint16_t*)PCM_buffer)[2]), &PDM3_filter_handler); //konwersja PDM na PCM mikrofon C PDM_Filter(&(((uint8_t*)PDM_buffer)[3]), &(((uint16_t*)PCM_buffer)[3]), &PDM4_filter_handler); //konwersja PDM na PCM mikrofon D Jednak deklaracja HAL_SAI_Receive_DMA wygląda następująco: HAL_StatusTypeDef HAL_SAI_Receive_DMA(SAI_HandleTypeDef *hsai, uint8_t *pData, uint16_t Size) Z jednej strony wskaźnik jest 8-bitowy, a rozmiar bufora 16-bitowy, a mój jest 32-bitowy. Proszę o info, czy mam to dobrze. 2. Druga kwestia dotyczy rozmiaru użytych buforów. O ile PCM_buffer jest dość oczywisty i równy wartości output_samples_number (the number of samples by request) pomnożonej przez 4 mikrofony, o tyle z PDM_buffer mam już kłopot. Wartość dobrałem eksperymentalnie, aż zadziałało, natomiast nie mam pojęcia, dlaczego z tą szóstką już działa, a np. z czwórką nie. Korzystam z decimation ratio równym 64. 3. Zgodnie z RM0433 str. 2254 dwie pierwsze ramki (zielona pętla) są nieprawidłowe. I o ile dla mikrofonu A mi się to sprawdza, o tyle dla pozostałych 3 mikrofonów pojawia się jeszcze jeden moment, w którym wartości są nieprawidłowe (na czerwono w załączonym pliku). (Ten cały pierwszy przebieg 1-4096 pomijam w zapisie, więc to nie jest dla mnie problem, choć nie wiem, dlaczego tak dziwnie wygląda.) Dodatkowo załączam wykres z wszystkich 4 mikrofonów, który w zasadzie powinien być jedną (pogrubioną) sinusoidą. Na tym wykresie kolejne wartości to odpowiednio próbki: A1,B1,C1,D1, A2,B2,C2,D2, A3,B3,C3,D3... Widać, że na początku każdego cyklu akwizycji (4*4096 próbek) następuje jakby przesunięcie w fazie. Na pierwszym wykresie zresztą też te nieprawidłowe wartości w czerwonej pętli wyglądają jak ucięta sinusoida i rozpoczęcie kolejnej w niewłaściwym miejscu. Proszę o wszelkie pomysły i podpowiedzi, co mogę mieć źle, jaka jest przyczyna błędu lub jak jej zapobiec. Na razie nie załączam kodu, ale jest on dość prosty i w czasie pojedynczego cyklu (4*4096) nie dzieje się nic poza akwizycją i konwersją.

Witam, Posiadam dwa mikrokontrolery z rodziny STM32. Pierwszy na płytce Nucleo-64 STM32F103RB, drugi na płytce Waveshare CoreH7XXI STM32H743IIT6. Postawiłem sobie za cel zbudować przetwornik cyfrowo analogowy R2R w oparciu o mikrokontroler. Wiem, że można wykorzystać do tego FPGA, ale ja postanowiłem całość oprzeć o mikrokontroler - cele naukowe i rozwojowe. IDE z którego korzystam, to STM32CubeIde. Z racji tego, że nie mam na co dzień do czynienia z mikrokontrolerami, a traktuję to jako hobby, to z góry przepraszam, jeśli popełniam jakieś rażące błędy, lub posiadam braki w wiedzy, ale dopiero się uczę. Skonfigurowałem USB na płytce Nucleo, jako USB Device, przyłączyłem middleware USB_DEVICE, klasa Audio Device Class, ustawiłem parametr częstotliwości na 48000 sampli/s, RCC HSE ustawiony na Crystal/Ceramic Resonator. Zegary skonfigurowane na korzystanie z kwarcu i PLL, USB taktowane 48MHz. Wlutowałem kwarc 8MHz i dwa kondensatory 30pF (takie akurat miałem pod ręką), wlutowałem rezystor 1k5 (1448Ω) pomiędzy 3.3V a pin USB D+ skompilowałem projekt, wgrałem na płytkę. Zrobiłem sobie około 40cm przewód z taśmy 4 żyłowej z jednej strony zakończony wtykiem USB, z drugiej wtykami goldpin. Podłączyłem D+, D- i GND, zasilanie pobieram z USB od programatora (przy czym przestawiałem też zworkę na E5V i całość zachowuje się tak samo). Podłączam mikrokontroler pod USB - urządzenie znalezione, poprawnie zainstalowane, widnieje jako STM32 Audio Class https://imgur.com/nBjyhkV. Inicjalizacja urządzenia się powiodła, wszystko wygląda dobrze - https://imgur.com/1LDmdm7. Na oscyloskopie kwarc pokazuje stabilne 8.00MHz. I teraz się zaczynają schody. Uruchamiam audacity, częstotliwość projektu ustawiam na 48KHz (choć to bez znaczenia, na każdej jest ten sam problem), generuję falę prostokątną 1KHz, wybieram moje urządzenie i klikam play. Oto, co się dzieje w snifferze - https://imgur.com/JjXmSkf. Proszę zwrócić uwagę na czasy - pierwsze dwa pakiety URB_FUNCTION_SELECT_INTERFACE wykonują się bardzo szybko. PC wysyła do uC żądanie i otrzymuje odpowiedź w ciągu 2ms - to jest moment kliknięcia play. Następnie mamy pakiety transferu danych, których jest mało, ze względu na to, że bardzo szybko kliknąłem stop. I tutaj zaczyna się sedno problemu. Kliknięcie stop ponownie powoduje żądanie URB_FUNCTION_SELECT_INTERFACE, które od PC do uC idzie od razu, ale w drugą stronę całość się zamraża na równo 5 sekund (+czasami kilka-kilkanaście ms, co widać w różnicach czasowych). Kliknięcie play i ponownie 5 sekund zwłoki i później lecą dane. Stop - znów 5 sekund i tak w kółko. Odpięcie USB i ponowne jego podpięcie daje jednorazowy szybki play, a potem sytuacja się powtarza. Wygląda to tak, jakby mikrokontroler przez 5 sekund próbował coś robić (tylko co?) a potem przechodził do właściwej pracy. Dodatkowo nie jestem w stanie poprawnie debugować pracy USB na tym mikrokontrolerze. Debuger poprawnie zatrzymuje się na pierwszej linii kodu, następnie klikam resume, urządzenie się pojawia. Gdy natomiast klikam play w audacity, dostaję komunikat "Błąd otwierania urządzenia dźwiękowego". Pakiet URB_FUNCTION_SELECT_INTERFACE (odpowiedź od uC) zwraca status 0xc0000011 https://imgur.com/EzQhRPh. I teraz, żeby było ciekawiej, powtarzam dokładnie tą samą procedurę na płytce z STM32H743IIT6 i wszystko działa tak, jak powinno, play i stop działa zawsze i od razu. Dlaczego zatem nie użyję H7 do USB? Ponieważ chcę zrzucić operacje pobierania danych z komputera i wstępną obróbkę na jeden cpu, a odtwarzanie, precyzyjny timer 48KHz i kierowanie danych na GPIO na drugi procesor (tutaj też są cele naukowe i rozwojowe - chcę spróbować różnych podejść i zrobić to na dwóch procesorach, mogąc jednocześnie obserwować komunikację między nimi). Czy ktoś się spotkał z takim problemem? Być może jest to kwestia tego, że CubeMX coś źle generuje, ale niestety nie jestem jeszcze aż tak biegły, żeby ogarnąć całą bibliotekę USB i potrzebuję wsparcia od osób bardziej doświadczonych :) Pozdrawiam, Mateusz

Witam! Widziałem, że na Forum pojawił się już wzmacniacz lampowy to i swój zrobiłem. PCB zrobiłem metodą termotransferu z tego projektu: http://skarabo.net/sid-21-se.htm Mam zastosowane lampy 6N2P-EW i 2x6P14P-EW, do tego gotowe( nie chciało mi się robić PCB) moduły z oczkami 6E2 czyli chińskimi klonami EM84/87. Transformatory głośnikowe pochodzą z zezłomowanych odbiorników wschodnioniemieckich, trafa identyczne choć mocowanie inne. Są to transformatory, które pracowały z EL84 i głośnikiem 4Ω, jest to układ z odczepem do kompensacji tętnień zasilania, napięcie anodowe idzie na odczep, jeden koniec uzwojenia na anodę lampy 6P14P, drugi, przez rezystor 1kΩ 5W(osobny dla każdego kanału) na wspólny kondensator 47uF i z niego zasilany jest stopień wstępny na 6N2P. Zasilacz to transformator Sizei TE84/148, uzwojenia 250 i 20V połączone w przeciwfazie(mam 250V w gniazdkach), dalej rezystor drutowy z obejmą do regulacji, prostownik, 2 kondensatory 100uF 450V, rezystor 510Ω i kondensator 100uF, napięcie anodowe ustawiłem obejmą na 253V. Żarzenie idzie na wzmacniacz przez rezystor 0,47Ω 10W i 2,2Ω 5W dla oczek, są dwie gałęzie. Wszystkie obwody są zabezpieczone bezpiecznikami: 0,5A sieć, 4A żarzenie, 150mA anodowe, nic się nie przepala. Sygnał sterujący dla oczek magicznych jest brany z wtórnych uzwojeń transformatorów głośnikowych, same trafa zabezpieczone rezystorami 33Ω 5W, równolegle do gniazd głośnikowych. W środku spagetthi ale tak zawsze robiłem( robię dla siebie, nie na zarobek). Obudowa powstała ze sklejki- nie mam możliwości obróbki metalu a zlecić w lockdownie to bym się nie doczekał w tym roku. Zdjęcia z testów na stole, zasilacz anodowy to stary, blisko 40 letni grat ale daje radę, Zhaoxin, którego używałem do żarzenia już wymiękał, praw fizyki nie da się oszukać. Są to zdjęcia stare, wzmacniacz doczekał się wlotu powietrza, tandetny, chiński potencjometr który przerywa będzie po niedzieli wymieniony na Alps Blue 2x50kΩ, jest zamówiona płytka do niego. Wzmacniacz wczoraj doczekał się prowadzenia masy, bo trochę jeszcze brumi, muszę uziemić jeden koniec uzwojenia żarzenia i wywalić tandetne przewody sygnałowe, konstrukcja jest cały czas ulepszana choć gra bardzo ładnie, mimo skromnych 5W na kanał, głośnik na zdjęciu to Grundig z 1969 roku, mam dwa takie, kiedyś kupiłem we Flensburgu( mam tam rodzinę) Chcę zrobić definitywny porządek z buczeniem, choć nie jest źle, jak każde stare radio z lat 50-60-tych, wzmacniacze estradowe też buczały, podobnie wszystkie Polskie konstrukcje. Brzmienie jest CUDOWNE!!!! Piękne, aksamitne, niemęczące w przeciwieństwie do klasy D, która ma brzmienie ostre i agresywne. Przepraszam za takie a nie inne wykonanie, raz że nie mam czym zrobić, dwa to koronawirus męczy cholernie, nic się nie chce. Płytka polakierowana lakierem PVB( przy lampach i przebicie i przepalenie laminatu bardzo łatwo) Koszty: Trafa głośnikowe ze strychu- 0zł Laminat i elementy bierne- około 40zł Podstawki lampowe, trafo sieciowe, mostek prostowniczy, 6N2P- około 243zł Lampy końcowe NOS- 55zł sztuka Oczka 6E2- 130zł Potencjometr Alps -60zł Gniazda i oprawki- 40zł Razem: 623zł, obudowy nie liczyłem I tak nieźle jak na wzmacniacz lampowy, to jest sprzęt audiofilski a ten kosztuje krocie( to nie jest kolejny knot na LM3886 czy innym TDA7294, jakimi zapchany jest internet i który gra nieciekawie i bez wyrazu, bez charakteru. Teraz właśnie go słucham i choć noc jakoś nie chce go wyłączyć,

Cześć wszystkim, potrzebuję zbudować audio switcha takiego jak na znalezionym schemacie lecz nie potrafię dobrać odpowiedni przełącznik obrotowy i w tej sprawie właśnie pisze do was tu na forum.

Witam, rozpoczynam naukę elektroniki od zdobywania podstaw i budowy syntezatora modularnego sterowanego napięciem (bardzo fajna baza wiedzy, zwłaszcza podstaw a temat mnie interesuje). Do zasilania musiałem zbudować prosty zasilacz symetryczny +/-12VDC zasilany gniazdkowym zasilaczem transformatorowym. Układ dość gruntownie sprawdziłem przed podłączeniem i mam na nim napięcia +11,7V oraz -12V. Prostowanie jednopołówkowe może się wydawać kiepskim rozwiązaniem jednak jest to dość standardowy projekt do tego zastosowania, na bazie: http://musicfromouterspace.com/index.php?MAINTAB=SYNTHDIY&VPW=1358&VPH=652 Wszystko wydawało się być dobrze jednak mam problem podczas prototypownia pierwszego oscylatora na bazie przerzutnika Schmitta w którym użyłem WO TL074 jako bufor na wyjściu przerzutnika. Kiedy piny zasilające WO są podłączone do masy i +12V wszystko działa dobrze lecz kiedy podłączam go do szyn +/- 12V słyszę tylko zakłócenia. Chcę rozwiązać problem zanim pójdę dalej z układem 1. Coś jest nie tak z moim zasilaniem? 2. Może być to wina samego TL074? Kupiłem je w Chinach i sprawdzałem kilka z podobnym efektem. Pisze głównie z nadzieją, że będzie to oczywiste rozwiązanie jednak jak podejrzewam, wina leży gdzieś po mojej stronie ale już nie mam pomysłu gdzie. Oscylator w obecnej formie (jak rozwiążę obecny problem rozwijam dalej): Na CV jest podawane napięcie 0-5V z klawiatury/sekwencera - układ ma w przyszłości pracowac w standardzie 1V/oktawę. Załączam nagranie różnicy dźwięku podczas zasilania V- na TL074 na masie a potem na -12V. Nagranie może być z tych głośniejszych więc proszę mieć to na uwadze. https://drive.google.com/file/d/1Aj22gcSi09Wipek-1tJJ2HbsDH03-eiC/view?usp=sharing Postarajcie się nie osiwieć przez schematy -pierwszy był pomocniczy w prostym programie którego użyłem do przeniesienia układu zasilania na veroboard a drugi z racji braku czasu nabazgrałem na szybko. Pobrałem KiCAD jednak jakoś brakuje mi czasu, żeby przyzwyczaić się do jego trochę dziwnego workflow.

Witam w moim pierwszym poście na forum i proszę o wyrozumiałość i brak fachowego języka. Mój pierwszy ale nie ostatni projekt to mini centrum muzyczne oparte na Raspberry Pi 0 WH oraz JustBoom Amp Zero. Podejrzewam że płytki Rpi nie muszę przedstawiać natomiast do drugiej płytki wrzucam link: JustBoom Amp Zero Jest to w sumie gotowiec jak klocki wsadzić jedno w drugie i działa ale... Pierwszym problemem jest to że nie wiadomo czy płytka Amp będzie dostępna. Drugim to zasilacz. Producent posiada w sprzedaży dydykowany zasilacz ale trochę drogo wychodzi więc może ktoś się zna i poleci coś innego. Drugą płytką którą biorę pod uwagę jest HiFiBerry MiniAmp. Tutaj niestety obawiam się słabego dźwięku na głośnikach które mam. Ostatnią opcją którą rozważam jest Pirate Audio Headphone i do tego głośniki 2.1 komputerowe. Proszę o pomoc w znalezieniu zasilacza. Oraz o wypowiedź który z przedstawionych zestawów będzie najlepszy. Kilka odpowiedzi na pytania które mogą się pojawić. Dlaczego Pi 0? Mikołaj mi włożył do buta, chyba byłem grzeczny. Wiem że są tańsze rozwiązania, które załatwiły by wszystkie problemy które mam, ale podoba mi się możliwość zarządzania takim centrum przez aplikację w telefonie, przez zwykłą przeglądarkę nawet. Obsługa dysku NAS znajdującego się w sieci domowej. Oraz możliwość słuchania radia z internetu.

Witam serdecznie! Przychodzę do Was z pytaniem czy jest opcja aby stary mikser audio podłączyć do komputera przez Arduino? Na jednym ze zdjęć jest przedstawiony mikser a na drugim wszystkie wyjścia/wejścia z/do niego. Z góry dziękuję wszystkim za pomoc!

Po stworzeniu głośnika Bluetooth opartego o wzmacniacz 3W przyszła pora na coś mocniejszego. Celem, jaki chciałem osiągnąć było zwiększenie mocy głośnika i zachowanie jego mobilności. Udało się to osiągnąć ponad 10-krotnie. Głośnik Bodzio (bo tak został nazwany :P) ma moc 35W. Nazwa nie jest przypadkowa, ma nawiązywać do jego drewnianej obudowy, więc przyjął przydomek po sklepie z meblami. Najciekawsze jest w nim to, że został zrobiony z kolumny znalezionej na ulicy Przygotowanie Schemat budowy głośnika Bluetooth nie był mi obcy, gdyż podobny projekt już kiedyś robiłem. Pierwszą rzeczą, jaką trzeba było zrobić to dobór wzmacniacza. Kolumna ma jeden głośnik wysokotonowy i jeden niskotonowy więc wystarczy tutaj wzmacniacz mono. Znalazłem odpowiedni na allegro o mocy 35W. Niestety w wyrzuconej kolumnie nie działał głośnik niskotonowy, więc trzeba było również dokupić odpowiedni, pamiętając, aby jego moc była większa niż wzmacniacza. Wszystkie elementy są wypisane poniżej: Lista elementów: LM2940 Buck LDO (do zasilania Bluetooth) [6zł] Step Up LM2587 (do ładowania akumulatorów) [5zł] BMS 3S Li-ion Akumulatorki 18650 6 szt. [24zł] Wzmacniacz mono 35W audio TDA8932BT klasa D Złącze jack 3,5mm [5zł] Bluetooth USB audio stereo [13zł] Głośnik niskotonowy (basowy) 4Ω Głośnik wysokotonowy 4Ω Kondensatory: 22uF; 2,2uF Rezystory: 1kΩ ; 10kΩ LED czerwona i zielona Złącze uUSB Potencjometr 50kΩ logarytmiczny [5zł] Przełączniki 2 szt. Jak zwykle najpierw zabrałem się za rozrysowanie schematu oraz przemyślenie pozycji takich elementów jak potencjometr do regulacji głośności, przełączniki, wejście jack, itp. Praca Za układ zasilania odpowiada 6 sztuk akumulatorków 18650 z odzysku. Są połączone w pakiet 3S po dwie sztuki, dla zwiększenia napięcia oraz pojemności. Pojemność pojedynczego ogniwa wynosi ok. 2000mAh co daje w sumie akumulator o napięciu 12V i pojemności 4000mAh. Gdybyśmy chcieli taki kupić nowe akumulatorki do takiego pakietu to koszt wyniósłby ok. 45 zł. Proces ładowania i rozładowywania kontroluje BMS. Ważnym założeniem jest ładowanie głośnika z zasilacza 5V przez µUSB, gdyż na imprezie czy, gdziekolwiek poza domem ciężko o zasilanie 12V, a noszenie zasilacza zawsze przy sobie jest uciążliwe i zmniejsza mobilność głośnika, dlatego zdecydowałem się na ładowarkę, jaką mają wszyscy. Można było co prawda umieścić zasilacz sieciowy 12V wewnątrz obudowy, ale trzeba by było kombinować, gdzie ukryć przewód do zasilania, więc ładowanie go przez µUSB było najwygodniejszym sposobem. Napięcie z 5V jest podnoszone dość wydajnym przekształtnikiem Boost zwiększającym napięcie do 12,6V po to, aby pojedyncze ogniwo było naładowane do 4,2V oraz wydajność ładowania był na tyle duża, aby można było ładować i słuchać muzyki jednocześnie. Do linii 5V idącej z zasilacza dodana została LED koloru czerwonego, informująca o tym, że głośnik jest ładowany. Centralnym punktem schematu jest wzmacniacz, do którego schodzi się większość elementów. Sygnał dochodzi przez potencjometr do regulacji głośności oraz przełącznik SW2 do zmiany pochodzenia sygnału (BT lub jack). Wszystkie masy oczywiście są wspólne i połączone. Za zasilanie modułu Bluetooth odpowiada przetwornica Step Down LM2940, która redukuje napięcie do 5V. Nie jest ona w żaden sposób połączona z linią zasilania. Napięcie ładowania, a zasilania elementów 5V pomimo tej samej wartości odpowiada za zupełnie inne rzeczy i połączenie ich razem spowodowałoby niepotrzebne zamieszanie w układzie. Moduł Bluetooth został podłączony przez SW3 do zasilania i włącza się dopiero w momencie zmiany pochodzenia sygnału. Na wyjściu wzmacniacza znajduję się głośnik niskotonowy odpowiadający za bass oraz wysokotonowy z filtrem górnoprzepustowym opartym o kondensator 2,2 µF. Wybrałem ten rodzaj filtru, aby uniknąć stosowania rezystora mocy, przez który przechodziłby sygnał do głośnika niskotonowego w przypadku filtra dolnoprzepustowego. W prawej dolnej części schematu znajduję się jeszcze jeden układ. Łatwo można się domyślić co to jest, ale na razie nie będę zdradzał więcej szczegółów. Zostanie on omówiony, gdy całość (część, za którą odpowiedzialny jest ten układ) zostanie skończona. Lutowanie i składanie obudowy Gdy większość elementów została skompletowana, przyszedł czas w połączenie wszystkiego w całość i sprawdzenie, czy działa . Okazało się, że głośnik gra perfekcyjnie i ma naprawdę dużą moc. Kiedy całość była jeszcze prototypem można było się pobawić np. filtrem górnoprzepustowym, a dokładniej doborem kondensatora. Metodą prób doszedłem do wniosku, że wartość 2,2 µF jest najlepsza. Ze wzoru na częstotliwość graniczną filtru: f=1/2ΠRC wychodzi około 18kHz. Jednak w praktyce (nie wiem dlaczego) ta wartość jest mniejsza. Układ zasilania Układ ten został dokładnie opisany w przypadku omawiania schematu, wiec tutaj zamieszczę tylko kilka zdjęć. Co do samego łączenia elementów to zlutowane jest tak jak widać na obrazku na dole wpisu, wszystkie ogniwa złączone są taśmą izolacyjna, a całość przyklejone na klej na gorąco w rogu obudowy. Lutowanie płyty głównej Schemat PCB jeśli można go tak nazwać został zrobiony symbolicznie, gdyż montaż elementów jest robiony na oko na dużej płytce uniwersalnej. Najważniejsze w tym schemacie są linie łączenia modułów ze sobą. We wszystkich układach dolutowane uprzednio przewody zostały zastąpione goldpinami, dzięki którym można wlutować moduł w płytkę. Wszystkie złącza zostały podpisane. Został jeszcze problem, jak zamontować płytkę w środku obudowy. Po kilku próbach udało wykombinować mi się coś takiego. Śruba przyklejona do tulei dystansowej, które z kolei zostały przyklejone na klej dwuskładnikowy (klej na gorąco nie trzymał mocno) do obudowy głośnika. Taki montaż ma swój plus, gdyż bardzo łatwo jest wyjąć płytkę z głośnika w celu naprawy lub modernizacji. Montaż elementów w obudowie Za tą część powinniśmy się zabrać, zanim cokolwiek zamontujemy lub przykleimy w obudowie, gdyż będzie tutaj trochę wiercenia/cięcia co może doprowadzić do przypadkowego uszkodzenia zamontowanych elementów . Zabieramy się za wywiercenie otworów pod potencjometr, LED'y i przełączniki. Niestety ciężko mi powiedzieć jakim wiertłem wierciłem jaką dziurę, bo nigdzie tego nie zapisałem, więc trzeba dobrać odpowiednią samemu. To samo robimy z otworami na złącze jack i gniazdo ładowania. Kiedy już mamy wszystkie otwory, oczyszczamy głośnik z zabrudzeń, gdyż będziemy teraz wszystko przyklejać/przykręcać. Zamiast gniazda µUSB montowanego do obudowy użyłem takiego przewodu, ponieważ to było jedyne gniazdo, jakie miałem, które dało się wmontować. Cena gniazd montowanych na obudowę jest dość droga, więc nie kupowałem go. Zostało jeszcze przymocować głośniki do przedniego panelu. Głośnik niskotonowy został kupiony specjalnie pod otwór po poprzedniku, aby nie bawić się w powiększanie dziury. Natomiast głośnik wysokotonowy został zabrany z jakiejś starej kolumny, która kiedyś dostałem do rozbiórki. W przypadku pierwszego nie było żadnych problemów z montażem. Głośnik pasował idealnie w otwór i miał miejsce na przekręcenie go wkrętami. Z mniejszym głośniczkiem było więcej zabawy. Nie chciałem go wklejać, ponieważ w przyszłości będzie on zastąpiony innym, lepszym zamiennikiem, więc musiał być on również wkręcany. Trzeba było wywiercić w metalowej ramce otaczającej go, dziury na wkręty. Całe szczęście w otwór pod nim mieścił się na styk, więc nie trzeba było nic przerabiać w obudowie Składanie obudowy w całość Zadanie niby proste, a okazało się najtrudniejsze w całym projekcie. Wcześniej głośnik był klejony, ja natomiast nie chciałem tego robić, gdyż, potrzebuje mieć dostęp do wnętrzności, aby móc go rozwijać i modyfikować. Gdyby obudowa była projektowana przez mnie od zera to pewnie nie byłoby problemu, ponieważ zostałoby to przemyślane jeszcze w fazie planowania. Pierwszym pomysłem było wmontowanie zawiasu (takiego jak w drzwiczkach od szafki) oraz zamknięcia na kluczyk. Chciałem, aby wszystko było ukryte wewnątrz i nie psuło wyglądu głośnika, stąd decyzja o takich rozwiązaniach. Niestety po kupieniu, okazało się, że montaż ich będzie nie lada wyzwaniem. Znalezienie miejsca na zawias wewnątrz obudowy okazało się praktycznie niemożliwe. Podobnie z zamknięciem na kluczyk, trzeba by było dużo pozmieniać, a na końcu i tak by wyszło paskudnie. Tak więc ten pomysł został odrzucony. Stwierdziłem, że nie ma co kombinować i przykręcę po prostu go na śruby. Mimo prostoty nawet to rozwiązanie przysporzyło problemów. Założenie o niewidoczności mocowań wymagało ukrycia śrub pod osłonką. Nie chce się tutaj już rozpisywać, gdyż liczba podejść była dość duża, więc omówię tylko końcowe rozwiązanie. Na dole panel z głośnikami trzyma się na dwóch śrubach M5 specjalnie uciętych na długość, aby pasowały do osłonki, która od dołu trzyma się właśnie na nich. Natomiast od góry jest jedna śruba na środku, która wkręca się do nagwintowanego uprzednio kątownika. Nie dało się rozwiązać tego tak jak u dołu, ponieważ po bokach są diody i przyciski, a najkrótszy kątownik, jaki znalazłem nachodził na nie. Dodatkowo trzeba było przyciąć górę metalowej otoczki głośnika wysokotonowego, gdyż przeszkadzała ona we wkręceniu śruby. Uchwyt - projekt 3D Specjalnie na potrzebę tego głośnika zaprojektowałem uchwyt do noszenia do druku 3D. Jest on dostępny na thingiverse. Dwa wymogi, jakie miała spełnić to: nie psuć designu głośnika, czyli po prostu być w miarę ładna, oraz być składana. Z tymi wytycznymi i zarysem w wyobraźni zabrałem się za projektowanie. O ile sama rączka poszła dość gładko, to głowiłem się trochę jak ukryć mocowania, aby nie rzucały się w oczy. Wymyśliłem chyba dość ciekawą rzecz, a mianowicie przykręcamy dwa małe elementy, w które później wkładamy bolce od rączki (na których się obraca) i na samą górę jeszcze zaślepki, które maskują to wszystko. Myślę, że całość nie wygląda najgorzej, jest elegancka i zajmuje mało miejsca. Design Na koniec zostawiłem zaprojektowane naklejki na głośnik opisujące poszczególne funkcje. Naklejkę zaprojektowałem na wymiar dzięki uprzednio zrobionemu zdjęciu centralnie z góry z linijką w tle. Pozwoliło to odwzorować dokładne wymiary w programie Inkspace. Plik przygotowany do druku znajduje się w repozytorium (najlepiej na jakimś śliskim papierze, wtedy jakość jest znacznie lepsza). Po wydrukowaniu całość trzeba jeszcze powycinać. Naklejkę widoczną u góry głośnika najpierw obrysowałem cyrklem, a potem wyciąłem według linii ołówka. Całość została przyklejona na taśmę dwustronną i trzyma się bardzo dobrze. Podsumowanie: Jestem bardzo zadowolony z części elektronicznej tego głośnika. Została zbudowana profesjonalnie i nie było z nią żadnych problemów. Całość znajduje się na płytce, która jest zdejmowalna co ułatwia modernizacje. Nic nie jest łączone w pająka, a wszystkie przewody idą do płyty głównej i są podpisane, także podłączenie wszystkiego to zaledwie chwila. Jakość dźwięku jest bardzo dobra. Z głośnikami takich marek jak JBL (mowa tu o głośnikach o podobnej mocy) nie ma co konkurować, gdyż jakość elementów plus membrany pasywne tworzą nieskazitelną barwę dźwięku, ale wygrywa z nimi na pewno pod względem ceny, która jakby nie patrzeć jest prawie 10 razy mniejsza (55 zł). Natomiast z głośnikami niższych półek jak najbardziej konkuruje Wygląd w mojej opinii jest bardzo dobry. Naklejki i rączka są jak najbardziej użyteczne i pasują stylowo do całości. Jedyna rzecz konieczna do wymiany to głośnik wysokotonowy, gdyż ten, który aktualnie się znajduje pochodzi z odzysku i słuchać, że nie jest w najlepszej kondycji. Przy następnych projektach proces montażu przemyśleć na samym początku jeszcze w fazie planowanie, gdyż rozmieszczenie elementów ma potem wpływ na to, w jaki sposób całość będzie zmontowana i oszczędzi nam sporo czasu. Plany na przyszłość: Wymiana głośnika wysokotonowego Membrany pasywne, aby wzmocnić jakość dźwięku oraz zasłonić dziury z tyłu Włączanie na wodę Źródła i linki: Najnowsza wersja projektu do pobrania pod tym linkiem. Są tam wszystkie pliki niezbędne do wykonania głośnika samodzielnie. Repozytorium na GitHub https://www.ti.com/lit/ds/symlink/lm2940c.pdf https://pl.wikipedia.org/wiki/Zwrotnica_głośnikowa https://pl.wikipedia.org/wiki/Filtr_górnoprzepustowy http://kaczanowski.org/elektronika/kolumna/dwa.htm https://www.youtube.com/watch?v=H17oSRbnjnU Zapraszam również do wpisu na moim blogu

Witam wszystkich, Realizuje właśnie projekt, którego celem jest generowanie tonu o zadanej częstotliwości i określonym poziomie głośności. Do tego wykorzystuje przetwornik dac CS43L22 znajdujący się na płytce a jako wyjście złącze jack. Poniżej mój kod odpowiadający za stworzenie dyskretnego sinusa: void Build_sin(float F_Out) { float sample_dt = F_Out/F_SAMPLE; uint16_t sample_N = F_SAMPLE/F_Out; float sin_val; for(uint16_t i=0; i<sample_N; i++) { sin_val = sinf(2*PI*sample_dt*i); dataI2S[i*2] = (sin_val ); //prawy tor dataI2S[i*2 + 1] =(sin_val ); //lewy tor } Na wyjście przekazuję go za pomocą HAL_I2S_Transmit_DMA w następujący sposób: HAL_I2S_Transmit_DMA(&hi2s3, (uint16_t *)dataI2S, sample_N*2); Regulację głośności realizuję za pomocą funkcji SetVolume która wygląda w następujący sposób: void CS43_SetVolume(uint8_t volume) { int8_t tempVol = volume - 50; tempVol = tempVol*(127/50); uint8_t myVolume = (uint8_t )tempVol; DataReg[1] = myVolume; write_register(PASSTHROUGH_VOLUME_A,&DataReg[1]); write_register(PASSTHROUGH_VOLUME_B,&DataReg[1]); DataReg[1] = VOLUME_CONVERT_D(volume); write_register(CS43L22_REG_MASTER_A_VOL,&DataReg[1]); write_register(CS43L22_REG_MASTER_B_VOL,&DataReg[1]); } Macro VOLUME_CONVERT_D(vol) wygląda tak: (((volume) > 100)? 24:((uint8_t)((((volume) * 48) / 100) - 24))) Moje pytania są następujące: 1) W jaki sposób przekłada się poziom sygnału, stworzonego w funkcji Build_sin(), podawany na wyjście przetwornika na poziom głośności uzyskany w słuchawkach? 2) Czy w przypadku zmiany Master volume z powiedzmy 0 dB na -3 dB otrzymam na wyjściu sygnał audio pomniejszony o 3 dB względem wcześniejszego? Z góry dziękuje za odpowiedź i pozdrawiam

Cześć, Zaczynam właśnie naukę programowania STM32 i chciałbym zrobić odtwarzacz audio. Posiadam płytkę STM32F411E-Disco, która jest wyposażona w DAC CS43L22. Planowałem wykorzystać interfejs I2C. Ze schematu układu odczytałem PB6 jako linie zegara i PB9 jako linie danych. Skonfigurowałem linie w programie STM32CubeMX. Znalazłem w dokumentacji adres urządzenia: 10010100 = 0x94(Write); 10010101 = 0x95(Read). Korzystam z bibliotek HAL, więc ustawiłem rejestr adresu CS43L22_ADDRESS (0x4A << 1). Następnie w pętli wykonuję: HAL_I2C_Mem_Write(&hi2c1, CS43L22_ADDRESS,CS43L22_REG_BEEP, 1, &beep,1,100); CS43L22_REG_BEEP to 0x1C na podstawie dokumentacji &beep jest wskaźnikiem na CS43L22_BEEP 0x74, które wg. dokumentacji powinno dawać na wyjściu dźwięk 1kHz trwający 1,5s. Niestety tak się nie dzieje. Bardzo proszę o pomoc. W którym miejscu popełniłem błąd? Z góry dziękuje za pomoc i wyrozumiałość. Pozdrawiam CS43L22_datasheet.pdf

Witam. Jakie są sposoby na połączenie Raspbery Pi z Arduino? I czy jest taka możliwość np. kontrolowania Arduino z Rasppbery , lub np. wykorzystania Raspbery jako monitora Arduino czy coś jak "serwera" kilku Arduino, I jeśli można jak to zrobić.

Za chwilę mnie coś strzeli... Program najprostszy chyba z możliwych (bez żadnych bibliotek): #include <Arduino.h> #include <i2s_reg.h> #include <i2s.h> int g_samrate = 8000; uint32_t last_micro_call; uint32_t idle_micros = 100000; void init_audio() { i2s_begin(); i2s_set_rate(g_samrate); last_micro_call = micros(); } void put_sample(int16_t sample) { uint32_t usample; usample = sample & 0x0000ffff; usample |= usample << 16; if (micros() - last_micro_call > idle_micros) { last_micro_call = micros(); yield(); } // wersja 1 najprostsza - działa źle i2s_write_sample(usample); /* // wersja 2 - to samo while (i2s_is_full()) { delay(1); last_micro_call = micros(); }*/ /* // wersja 3 - to samo while (!i2s_write_sample_nb(usample)) { delay(1); last_micro_call = micros(); }*/ } void finalize_audio() { for (int i=0; i<1000 && !i2s_is_full(); i++) i2s_write_sample_nb(0); i2s_end(); } void setup(void) { } void loop(void) { int i; init_audio(); for (i=0;i<4000;i++) { float a = i * (3.141592/10); int16_t s = sin(a) * 4096; put_sample(s); } finalize_audio(); delay(500); } Efekt działania: co prawda pika sobie bardzo ładnie, ale mniej więcej połowa (całkowicie losowo) "piknięć" jest głośniejsza i zniekształcona - tak jakby wejściowa próbka przesunęła się o bit w lewo. Miałem podobny efekt kiedyś gdy próbowałem coś zrobić z TDA1543 ale uznałem, że to pewnie wina połączeń na paszczatej płytce stykowej albo 8kHz to dla niego za mało... Co ciekawsze - podobny program, ale używający hacku PWM działa ślicznie... Ktoś coś... jakieś pomysły? Bo mi się skończyły Po sprawdzeniu: zamiana na bibliotekę ESP8266Audio i użycie AudioOutputI2S nic nie zmienia.

Witam jest to mój pierwszy projekt na forbocie, więc proszę o wyrozumiałość :). Pokażę wam jak zrobiłem swój wzmacniacz do głośnika bez dużej ilości kondensatorów a właściwie ogranicza się tylko do dwóch. A więc zaczynamy, oto co będziecie potrzebować: -Kondensatora elektrolitycznego 1000uF - Kondensatora 10uF -Potencjometru 10k x2 -Wzmacniacza LM386 A więc to jest wszystko co potrzebujecie, aby zrobić wzmacniacz. Do całego głośnika trzeba wyposażyć się w obudowę oraz głośniki i gniazdo Jack. Połączenia: Zamieszczę tutaj zdjęcie połączeń na płytce stykowej, ponieważ nikt by nie zrozumiał mojego rozpisania. Zamalowalem na nim elementy, których nie użyłem. Na dodatek dołączam zdjęcia gotowego głośnika... A tutaj gotowa obudowa: Jakość obudowy nie powala ale to w końcu diy... Dla tych co chcą zrobić wzmacniacz z przwdopodobnke lepsza jakością dźwięku to zamieszczam schemat: