Vánoční hvězda
Před 30 lety jsem postavila blikající vánoční hvězdu z trojice samoblikajících LED v serii s paralelně spojenými dalšími LED, což vytvářelo efekt náhodného blikání, dvě samoblikající LED neblikají se stejnou periodou, navíc pochopitelně rozblikají ve svém rytmu vše, co je s nimi v serii. Po mnoha letech už byla původní hvězda poněkud „unapetytlich“, prach a jiné nečistoty pochopitelně vykonají svoje, to i v případě, že je ta věc používána toliko o Vánocích, navíc původní myšlenka se samoblikajícími LED už byla poněkud zastaralá (byť tehdy byly samoblikající LED novinkou, to bylo po revoluci takto prakticky se vším). Do toho mi ono blikání připadalo poněkud divoké, možná je to věkem (tehdy jsem byla mladá a progresivní, kdežto dnes jsem nad hrobem), možná něčím jiným, prostě přišel čas na redesign.
Rozhodla jsem se pro malý jednočipový systém ATtiny13 (konstrukce vznikla v roce 2019, ovšem nikdy k ní nevznikl psaný návod, video s návodem bylo z youtube smazáno protože porušovalo pravidla pro komunitu, zdrojáky z githubu odešly společně s mým účtem, bojkotuji vše, co vyžaduje dvoufaktorovou autentizaci, neb je to rovnák na ohýbák, který nikdy neměl vzniknout, prostě to nikde není, navíc již brzy budou Vánoce, no a tu ATtiny13 ještě stále seženete, byť už nestojí 7Kč, neb Atmel byl koupen Microchipem, no a ti zabili všechno co se u Atmelu povedlo, takže je to doprodej) a softwarové PWM pro řízení jasu řetězů LED, ten jednočip prostě nemá tři D/A převodníky a potřebuji tu věc udržet jednoduchou. Současně je ale třeba řídit proud jednotlivými řetězy LED různých barev, které jsou spojeny do serie, tudíž na nich bude neodhadnutelné napětí. Pokud se rozhodnete dělat hvězdu stejně jako já, bude vám stačit 10V na řetěz, čili 15V v napájení. Zapojení je svým způsobem hybridní. Pokud LED svítí maximálním svitem, je na gate Q1/Q2/Q3 přivedeno +5V z výstupního portu jednočipu, napětí U(GS) je víceméně konstantní, čili úbytek na R1/R2/R3 zvýšený o U(GS) bude v tomto případě odpovídat přivedeným +5V. Konstantní napětí na rezistoru znamená i konstantní proud, čili tranzistor se v tomto případě chová jako zdroj konstantního proudu. Pokud bude v gate Q1/Q2/Q3 0V, tranzistor se prostě zavře a příslušný řetěz LED zhasne. No a pozvolný přechod mezi oběma těmito stavy zajistí softwarově generované PWM. Různobarevné LED je třeba vybírat tak, aby měly při stejném proudu přibližně stejný jas, čili to chce určitou práci s katalogem. Mně se toto úplně nepodařilo u žluté, která svítí víc než by měla. Použila jsem ji dočasně (protože mne tlačily Vánoce) s tím, že ji následně vyměním za jiný typ, který momentálně nebyl skladem. Nedošlo k tomu, protože zvolený typ už nikdy následně nebyl skladem, nicméně není to zase „tak strašné“, čili nemusíte být při výběru moc přesní. Celé zapojení obsahuje ještě „fialovou“ LED zadního podsvitu, který se mění v závislosti na jasu ostatních LED tak, aby utvářel pocit „modré oblohy“ promítané na bílou zeď za hvězdou. Tady je použita jediná LED s proudem omezeným pomocí seriového rezistoru R4. Procesor běží na interním RC oscilátoru (nic v obvodu nevyžaduje přesné časování), čili zbytek je už toliko napěťový stabilizátor v katalogovém zapojení (ano, C3 by nově měl být 1μF, některé součástky napříč časem mění parametry aniž by měnily označení).
1. Firmware
Firmware je napsán v programovacím jazyce C. Pokud se ptáte na Arduino a jejich IDE, pak podpora pro ATtiny13 sice je, ale proti přímému programovaní v C nepřináší žádné výhody (to ostatně platí pro celé Arduino). Pokud už musíte používat nějaké „prostředí“, doporučuji spíše něco příčetného, jako je kupříkladu platformio, ale u takto jednoduchého systému to prostě nedává smysl.
/******************************************
* Vánoční hvězda / ATTINY13
* 2019 Nikita Lieselotte Bretschneider
* ( nikita.bretschneider<at>gmx.de )
******************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#define OUT1 PB0 // First LED chain, can be changed
#define OUT2 PB1 // Second LED chain, can be changed
#define OUT3 PB2 // Third LED chain, can be changed
#define OUTB PB4 // Blue backlight, can be changed
#define PERIOD1 170
#define PERIOD2 230
#define PERIOD3 150
#define OUT_STATE_1 1
#define OUT_STATE_2 2
#define OUT_STATE_3 3
unsigned char PWM1 = 3;
unsigned char PWM2 = 3;
unsigned char PWM3 = 3;
unsigned char PWMB = 0x7F;
unsigned char pwm_cnt = 0;
unsigned char PERIOD1_cnt = 0;
unsigned char PERIOD2_cnt = 0;
unsigned char PERIOD3_cnt = 0;
unsigned char OUT_STATE = 0;
int main( void)
{
DDRB |= _BV( OUT1)|_BV( OUT2)|_BV( OUT3)|_BV( OUTB); // Set as output
TCCR0B |= (1<<CS00);
TCCR0B &= ~((1<<CS01) | (1<<CS02));
TIMSK0 |= (1<<TOIE0);
sei();
while( 1)
{
_delay_ms( 20);
PERIOD1_cnt++; PERIOD2_cnt++; PERIOD3_cnt++;
if ( PERIOD1 < PERIOD1_cnt) {
PERIOD1_cnt = 0;
OUT_STATE ^= _BV( OUT_STATE_1);
}
if ( PERIOD2 < PERIOD2_cnt) {
PERIOD2_cnt = 0;
OUT_STATE ^= _BV( OUT_STATE_2);
}
if ( PERIOD3 < PERIOD3_cnt) {
PERIOD3_cnt = 0;
OUT_STATE ^= _BV( OUT_STATE_3);
}
if (( OUT_STATE & _BV( OUT_STATE_1)) && ( 0x1A > PWM1)) PWM1++;
if (( OUT_STATE & _BV( OUT_STATE_2)) && ( 0x1A > PWM2)) PWM2++;
if (( OUT_STATE & _BV( OUT_STATE_3)) && ( 0x1A > PWM3)) PWM3++;
if ((!( OUT_STATE & _BV( OUT_STATE_1))) && ( 0x00 < PWM1)) PWM1--;
if ((!( OUT_STATE & _BV( OUT_STATE_2))) && ( 0x00 < PWM2)) PWM2--;
if ((!( OUT_STATE & _BV( OUT_STATE_3))) && ( 0x00 < PWM3)) PWM3--;
PWMB = 2 + (( PWM1)>>2) + (( PWM2)>>2) + (( PWM3)>>2);
}
}
ISR( TIM0_OVF_vect)
{
pwm_cnt++;
pwm_cnt &= 0x1F;
if( pwm_cnt >= PWM1) { PORTB &= ~_BV( OUT1); } else { PORTB |= _BV( OUT1);}
if( pwm_cnt >= PWM2) { PORTB &= ~_BV( OUT2); } else { PORTB |= _BV( OUT2);}
if( pwm_cnt >= PWM3) { PORTB &= ~_BV( OUT3); } else { PORTB |= _BV( OUT3);}
if( pwm_cnt >= PWMB) { PORTB &= ~_BV( OUTB); } else { PORTB |= _BV( OUTB);}
}
1.1. Přiřazení GPIO
Nejprve definujeme přiřazení k jednotlivým GPIO. ATtiny13 tady představuje určitou zvláštnost, dostupné GPIO tvoří toliko PORTB, což u systému s osmivývodovým pouzdrem není nečekané. Z toho plyne, že výstupy budou vždy na portu B, takže tento fakt nemusíte nikde definovat. Pokud by to tak nebylo, bylo by třeba definovat pro každý GPIO dvě hodnoty — jedna by odkazovala na použitý port, druhá na použitý bit daného portu. Tady to tak není a proto si odpouštím i P_ a B_ prefixy a používám toliko OUT1, OUT2, OUT3 a OUTB pro tři řetězy LED a podsvit. Pokud tedy potřebujete z nějakého důvodu přeházet vývody, můžete tak učinit zde, nicméně snažila jsem se přiřadit vývody tak, aby se to snadno vyrábělo na bastltisku. Následuje definování použitých GPIO jako výstupních. Jelikož zase používáme toliko PORTB, provede se to jediným zápisem do registru DDRB. Podotýkám, že #define je definice a _BW je makro, takže hodnotu vkládanou přes OR (pomocí OR nastavujete bity do 1, pomocí AND zase do 0 a pomocí XOR je invertujete) do DDRB vypočítá preprocesor při kompilaci, tj. není počítána programem v jednočipu.
1.2. Proměnné
Nejprve se krátce zmíním o unsigned char. To je nejsnadnější způsob, jak v C definovat proměnnou o velikosti jednoho bytu aniž byste házeli vidle do zarovnání proměnných (což se nás tady netýká, neb jsme na čistě osmibitovém systému). Pochopitelně můžete použít uint8_t, což bude mít v tomto případě úplně stejný efekt (pokud se to pro ATtiny13 někdo obtěžoval definovat, padat do této králičí nory se mi prostě nechtělo). Proměnné PWM× nesou aktuální hodnotu jasu příslušného řetězu/LED. pwm_cnt je počítadlo používané v rutině softwarově generující PWM. Pokud namítnete, že bych namísto počítadla mohla dekrementovat PWM× přímo z rutiny generující PWM, pak samozřejmě máte pravdu, ale bylo by to paměťově náročnější. Já totiž potřebuji měnit jas postupně, čili rutina generující PWM by v takovém případě k PWM× musela přistupovat jako k read-only a tudíž by ho musela kopírovat. Kopie by zabrala 4 byty, kdežto počítadlo zabere toliko 1 byte (a to ještě ne kompletně, viz níže). PERIOD×_cnt jsou počítadla periody konkrétního řetězu. Každý z řetězů má svoji vlastní periodu definovanou pomocí PERIOD×. Tady vstupují do úvahy pouze tři řetězy, podsvit použije součet jejich jasů. OUT_STATE je proměnná obsahující logické hodnoty odpovídající stavu řetězu, tj. přechází-li ze tmy do světla, nebo obráceně. Použití logické proměnné by bylo paměťově neefektivní, protože pro uložení booleovské hodnoty se v takovém případě použije paměťové místo o velikosti šířky ALU procesoru, což je v tomto případě 8 bitů. Protože mám tři řetězy, potřebuji ukládat tři hodnoty, proto z osmibitového paměťového místa (menší se v osmibitovém systému adresovat nedá) použiji tři bity pro tři řetězy adresované pomocí OUT_STATE_×.
1.3. Softwarově generované PWM
Nejsnadnější způosb, jak toto realizovat, je použít přerušení a použít rutinu běžící na pozadí. Do tohoto by mi hodilo vidle Arduino, které pro sebe vždy použije přerušení od prvního časovače, kterým uklidňuje watchdog (¿chápe někdo proč, když watchdog se dá vypnout a pokud jej obsluhuji přerušením, stejně nezabere na seknutou hlavní smyčku programu?), bohužel ATtiny13 má jediný časovač, takže Arduino by mi ho zbytečně zabralo, čímž by mi vyrobilo problém aniž by to něco přineslo (to je mimochodem častý problém s Arduinem). Pro správnou činnost časovače je třeba nejprve nastavit všechny potřebné bity pro přerušení přetečením časovače a následně povolit přerušení — sei();. Přerušení samo si odchytíme pro naši rutinu pomocí ISR( TIM0_OVF_vect) neboli vektor přerušení vyvolaného přetečením časovače 0. Chová se to v podstatě jako jakákoliv jiná funkce, jen se nevolá z programu, ale volá ji událost tahající za přerušení, v tomto případě přetečení časovače. Důležité je, že výstup z takové funkce nevrací žádnou hodnotu (není čemu ji vrátit) a současně po dobu jejího běhu poněkud neběží program, který byl přerušen, takže by obsluha přerušení měla být pokud možno rychlá. V našem případě inkrementujeme pwm_cnt a současně zajistíme, aby jeho hodnota nepřekročila 31, což se zařídí pomocí &= 0x1F. Jistě, nepotřebujeme počítat do 255, PWM takové rozlišení nepotřebuje a celé by to bylo příliš pomalé. Pokud namítnete něco o if, pak by to samozřejmě použít šlo a nemusela bych použít limit v mocnině dvou, avšak výsledný kód by byl delší a tudíž by se i déle vykonával. Následuje nastavení jednotlivých GPIO v závislosti na porovnání pwm_cnt a PWM×. Pokud je PWM× menší nebo roven pwm_cnt je GPIO nahozen (a tudíž je na něm +5V), v opačném případě je shozen (a tudíž je na něm 0V). Tedy čím větší je hodnota PWM×, tím déle je výstup v hodnotě +5V na úkor doby v 0V, což je podstata PWM — měníme střídu signálu. Jak vidíte, hodnoty PWM× se toliko porovnávají, tudíž obsluha přerušení nemá jak rozbít funkci hlavní smyčky programu. Hlavní smyčka programu současně nesmí sahat na pwm_cnt aby nerozbila funkci generování PWM.
1.4. Hlavní smyčka programu
Hlavní smyčka programu začíná obligátním while( 1) (ano, je mnoho jiných způsobů, jak zajistit aby hlavní smyčka nekončila, některé jsou i efektivnější). Následuje _delay_ms( 20) což vloží 20ms pauzu. To je poměrně dlouhá doba a ano, narozdíl od implementace v Arduinu se tady nepoužívá časovač, přerušení a různé úsporné režimy procesoru, což je přesně to, co tady potřebuji, totiž potřebuji, aby mi stále fungovala obsluha přerušení a jediný časovač potřebuji opravdu pro něco jiného, než zanedbatelná úspora energie odebírané ze síťového zdroje (z toho by se Gréta v hrobě obrátila). Touto poměrně dlouhou pauzou se zajistí časování hlavní smyčky programu, které (narozdíl od generování PWM) už nemusí být moc přesné. Hlavní smyčka programu začíná inkrementací všech tří PERIOD×_cnt . Ano, dalo by se použít pole, které by se následně procházelo. Trvalo by to déle a použil by se další byte pro počítadlo procházející ono pole, proto je lépe toliko inkrementovat tři proměnné. Každá z period má svůj limiter, který ji resetuje. Protože potřebuji použít ideálně nesoudělná čísla, nepřichází řešení s &= do úvahy a došlo tedy na if. Existuje sice ještě jedno řešení s odečítáním, ale to je výhodné toliko má-li být aplikováno na nějaké větší pole a to navíc pouze na specifickém hardwaru, navíc my potřebujeme při přetečení počítadla udělat dvě věci — jednak nulovat počítadlo (to by šlo i jinak) a současně XORovat příslušný bit OUT_STATE. Přetečení počítadla tedy invertuje bit v OUT_STATE, což znamená, že PERIOD×_cnt ve skutečnosti počítá toliko do poloviny periody daného řetězu, což ale není problém. Nám jde o to, aby byly periody dostatečně různé na to, aby se příliš často nepotkávaly a tudíž vytvořily efekt náhodného rozsvěcení/zhasínání.
Následuje implementace vlastního rozsvěcení/zhášení. V závislosti na hodnotě OUT_STATE_× se PWM× buď inkrementují, nebo dekrementují, přičemž hodnoty jsou zastropovány z jedné strany nulou, z druhé strany hodnotou 0×1A — ano, nikdy to nesvítí naplno, prostě to naplno svítilo trochu moc, změnou těchto hodnot můžete změnit i rozsah rozsvěcení/zhasínání, takže kupříkladu můžete hvězdě zabránit v tom, aby zcela zhasla (ne, nelíbilo se mi to, zkoušela jsem to).
Posledním krokem je výpočet součtového jasu zadního podsvitu. U něj nechci aby zcela zhasnul, to nevypadá pěkně, proto k součtu přičítám dvě a následně přičítám čtvrtiny všech tří hodnot PWM1, PWM2 a PWM3. Ano, celočíselné dělení čtyřmi a posun o dva bity vpravo je totéž. Posun o bit vpravo je dělení dvěmi, přičemž ten odsunutý bit je současně zbytkem, posun o bit vlevo je zase násobení dvěmi — funguje to úplně stejně jako v desítkové soustavě, kdy připsáním nuly násobíte deseti, smazáním cifry nejvíce vpravo zase provedete celočíselné dělení deseti a ta odmazaná cifra je zbytkem, toto vám bude fungovat v jakékoliv číselné soustavě s jediným základem. Existují i číselné soustavy se dvěma (tzv. babylonská, používá základ 12 a 60, přičemž pro každý z nich používá odlišné cifry, do dnešní doby se zachovala toliko v určování času) a více základy. Desítková soustava je ve své podstatě dosti hloupá, komplikuje dělení na poloviny a třetiny, což je jeden z nejčastějších úkolů…to jsem trochu odbočila, ještěže je tu dost sexy chlapečků na které se mohu dívat…
2. Praktická realizace
Vlastní zapojení je, jak už jsem předeslala, na bastltisku. Je velice jednoduché, stabilizátor, pár kondenzátorů a rezistorů, jednočip (ten doporučuji osazovat do patice aby jej bylo možno případně přeprogramovat, na ISP opravdu není místo) tři tranzistory BS170 (můžete použít libovolný podobný). Rezistory a kondenzátory jsem použila v SMD 0805, protože je lze pájet do 100mils (2.54mm) rastru bastltisku tak, že padnou celkem přesně mezi dva vývody. Pro připojení LED řetězů a napájení jsem použila pinheader, na druhé straně jsem použila dupont konektor, takže desku je snadné z vlastní hvězdy vyjmout.
Jak vidíte, vlastní hvězdu jsem rýsovala na karton (tuším z krabice od bot), vystříhla a polepila žlutým papírem. Dnes bych to asi nakreslila v CADu, vytiskla a nalepila, ale já tehdy neměla snadno přístupnou tiskárnu, používala jsem RoboCopy v Tresce na rohu a prostě se mi tam nechtělo chodit (pak RoboCopy v zájmu pokroku zrušili a já si díky tomu musela koupit tiskárnu). Celá hvězda vychází z šestiúhelníka. Pokud nevíte jak narýsovat šestiúhelník, prozradím vám, že délka jeho strany je shodná s poloměrem kružnice jemu opsané. Ano, narýsujete kružnici, zvolíte na ní bod a dokud máte v kružítku chycený její poloměr, jedete střídavě na obě strany. Protože LED jsou vyskládané do dvou navzájem posunutých šestiúhelníků, doporučuji začít tím vnitřním (ale jak vidíte na mém kusu, nutné to není), následně dělit jeho strany (kružítkem prosím) a dotvořit zbytek. Totiž tam, kde nerýsujete, nemusíte mít papír, takže pokud začnete vnitřní kružnicí, máte méně odpadu (zvláště máte-li nějaký divně tvarovaný odstřižek), pokud začnete od té vnější, máte zase přesnější výsledek. LED jsou pochopitelně zase umístěny na kružnicích. Když tak nad tím přemýšlím, možná by bylo rychlejší nakreslit to v CADu než to popisovat. Polepení žlutým papírem je netriviální věc, především musíte najít kancelářské lepidlo, které nerozpustí karton, nezkrabatí papír a ideálně i drží. Díry na LED jsou vyraženy kancelářskou děrovačkou, ovšem musí se to udělat přesně. Pokud máte pocit, že tam není vidět a nikdy to nemůžete přesně trefit, pak sundejte zásobník na prostříhané kusy a ukáže se vám otvor, na jehož střed napozicujete střed díry a cvaknete. A ano, zásobník je potřeba sundávat opatrně, jinak z toho máte kolečka všude a už se jich nikdy nezbavíte. Vlastní LED jsou v otvoru zachyceny pomoci silikonové bužírky ze které jsou nastříhány úzká kolečka (podobný princip jako když ze staré duše z kola vyrábíte gumičky) a nataženy na pouzdro LED. Pochopitelně to nesmí být moc široké aby to nevypadalo šeredně, no a musíte také použít průhlednou silikonovou bužírku. Silikon se dá opravdu hodně roztáhnout, já na 5mm led natáhla 2mm bužírku. Nejsnadnější způsob je natáhnout bužírku na špičaté zahnuté kleště, ty potom rozevřete, čímž bužírku natáhnete, LED chytíte za hranu, posunováním dopředu/dozadu postupně bužírku navléknete, přidržíte pinzetou a vyndáte kleště. S první LED budete bojovat, ale s trochou cviku to jde docela snadno. Následně zahněte vývody LED, lakem na nehty si označte katodu (nebo anodu, to je jedno, ale na všech LED to musíte udělat stejně, jinak z toho pak zešílíte) a zastříhněte je na shodnou délku odpovídající vnitřku dupontu (v tento moment už podle délky vývodu nepoznáte katodu od anody, proto je potřeba si je označit před zastřižením). Vlastní propojení LED jsem provedla pomocí dvoupinového dupont konektoru (v GME se to z nepochopitelného důvodu jmenuje KONPC-SPK…asi Šumperk woe), pájet netřeba, duponty jsou lisovací. Jen upozorňuji, že na to musíte mít odpovídající kleště, nikoliv ty, co vám prodají v GME nebo v modelářských obchodech (oni tam nepochopili rozdíl mezi dupontem a D-SUB, ne, opravdu na to nejsou stejné kleště, ač oni vám budou tvrdit, že jsou). Jak LED rozdělíte barevně a která bude ve kterém ze tří řetězů je vaše věc, nicméně doporučuji rozdělit barvy víceméně rovnoměrně a současně přiřadit LED k jednotlivým okruhům alespoň pseudonáhodně. Dalším krokem je vyvázání kabelů, to jsem udělala režnou nití (dnes se jí říká kovářská…takže doufám, že v rámci pokroku máme pro změnu režné kladivo) a následně zalakovala bezbarvým šlakem na nehty…teda šlak vás trefí z toho vyvazování, na zalakování spíše použijte lak. Následně je třeba k některé z LED upevnit přívodní kabel na kterém hvězda současně i visí.
Pokud nemáte kleště na duponty (což příliš nepředpokládám, nicméně stát se to může), lze z vývodů LED umotat kulatými kleštěmi nikoliv draka (na to před vánocemi použijte spíš rum či svařák), ale cívku/dutinku, do které následně vložíte odizolovaný káblík a důkladně prolejete cínem. Stačí i jednoduché oko, nicméně materiál na pěknou špuličku na vývodu LED je. Definitivně to nepájejte k sobě průmyslováckým stylem, tj. licnu k vývodu a udělat bakuli. Nejen že to šeredně vypadá, ale většinou se to i rozpadne. Pochopitelně to následně musíte i zaizolovat, takže vás čeká blbnutí se smršťovačkami či silikonovými bužírkami. Prostě vývody LED pasují do dupontu a pokud ho použijete, ušetříte si tím spoustu práce, duponty následně pasují na pinheadery, což se zas běžně používá u arduina, prostě ty kleště se vyplatí.
3. Závěr
Vánoční hvězda z mého pohledu vypadá docela pěkně, nebliká až tak zběsile jako tomu bylo v případě samoblikajících LED. Vlastní provedení pochopitelně přizpůsobte vlastnímu vkusu. Využití jsou různá, v podstatě všude, kde máte pseudonáhodně blikající světla. Firmware se pochopitelně dá snadno upravovat. Jen bych trochu varovala na téma film, totiž PWM versus závěrka často končí aliasingem v časové oblasti, zvláště je-li vysoký framerate či malý úhel závěrky.
Pochopitelně jednotlivé řetězy se občas sejdou a potom svítí všechny LED, případně hvězda kompletně zhasne. To se prostě čas od času stát musí. Na fotkách vidíte jak hvězda vypadá pokud se sejdou v maximu. Jak to bliká bylo vidět ve videu, které bohužel vzalo za jeho (dá se dohledat mimo youtube, avšak s ohledem na youtube pokyny pro komunitu nesmím sdělit jak, youtube je infekční…nicméně řekněme, že jsem aktivní i na jiných platformách, tvořit na/pro youtube byl můj životní omyl, který bohužel má důsledky).
Update: Rozhodla jsem se použít z původního videa část, kde je ukázáno jak hvězda bliká. https://drive.google.com/file/d/19TAd33egdJ4XkEBAETwX-g57qdQLNgnu/view?usp=sharing To snad zatím žádná pravidla moštárny neporušuje. Doufám, že toho nebudu litovat. Je to odkaz na soubor na google drive s videem v h265. Dát sem odkaz na stejné video na Od.s../R.*le/whatever nemohu, protože tím bych odkázala i na svůj kanál a jelikož na tento blog vede odkaz ze zrušeného kanálu na youtube, vztahují se i na tento blog youtube pravidla pro komunitu a kdybych sem dala odkaz, ze kterého se dá dostat na nějaký můj kanál jinde, zase by se na něj vztahovala pravidla pro komunitu youtube (byť ta služba s youtube nemá nic společného). Ikdybych ten odkaz na tento blog na youtube smazala nic by to na té věci nezměnilo, protože na něj někdy v minulosti ukazoval a to bohužel stačí. Jestli z tohoto bude zase nějaký průšvih, tak už s veřejnou tvorbou definitivně končím, minimálně do momentu, než se toto celé upraví nějakým silným a jasným právním předpisem reálně vymahatelným v rámci EU, protože na chaos páchaný infekčními licencemi z youtube už opravdu nemám nervy.
Pro úplnost ještě dodávám, že „naprogramovaný procesor“ neprodávám, firmware je volně dostupný (pod GPL) jak v podobě zdrojového kódu, tak přeložené binárky — https://drive.google.com/file/d/1wGulIdwdD0uG1Tul4Kg3RyoxaZMnLeMW/view?usp=sharing, ATtiny13 jde naprogramovat dost čímkoliv, jako programátor může posloužit i Arduino. Teoreticky vzato mohu naprogramovat donesený procesor, nicméně lidí s programátory je po světě mnoho a určitě najdete nějakého, ke kterému to máte blíže než ke mně.
Komentáře
Okomentovat