COOKIES

This site may be using cookies to melk you with your own data. I, ben0bi, am not the owner of this web service and I also do not maintain their servers. But the EU and the owner of this service think, that the user (me) has the responsibility to inform the consumer (you), that this website uses cookies. Again: I, ben0bi, NEVER use cookies. I am not responsible for the setup of this web service. I just present some information here and do not intend to spy on you for whatever reason ever. But (also again), I do not host this website nor do I maintain any servers related to this website nor do I benefit from using the cookies maintained from this service. I hereby give the responsibility for using cookies on blogspot back to the owners of blogspot.

Sonntag, 21. Mai 2017

DIY: Emulator Teil 2: Setup Basisgerüst (JavaScript)

Im vorigen Artikel (Part 1) haben wir uns damit befasst, was ein Emulator ist. Nun kommen wir zum Programmieren selbst.

Wir brauchen für unser Grundgerüst verschiedene JavaScript-Bibliotheken.

  • jQuery -> Vereinfacht viele Dinge.
  • PixiJS -> Die Grafikbibliothek.
  • RUNPIXI -> Diese Bibliothek habe ich geschrieben, um PixiJS ganz einfach zu initialisieren.

Ich werde diese Bibliotheken nicht herunterladen, sondern einen direkten Link dazu angeben. Somit hat man erstens immer die aktuelle Version und zweitens wird Zeit gespart, wenn andere (fremde) Webseiten denselben Link benutzen. Der Browser hat die Datei dann schon im Cache gespeichert.

Ordnerstruktur

Generieren wir erst mal die generelle Ordnerstruktur und die ersten Dateien:

  • ./  --> Das ist das root/Basis-Verzeichnis.
  • js/  --> enthält alle JavaScript-Dateien.
  • css/ --> enthält alle CSS-Dateien.

[weitere werden folgen]

Ich benutze immer diese Ordnerstruktur für meine Web-Projekte, du kannst natürlich auch eine andere Struktur anlegen.

Nun legen wir ein paar verschiedene Dateien an:

  • ./index.html
  • ./css/base.css

css/base.css

Die Datei css/base.css enthält die grundlegenden Layout-Einstellungen:

html, body
{
width: 100%;
max-width: 100%;
height: 100%;
min-height: 100%;
overflow-x: hidden;
overflow-y: hidden;
}

div, html, body
{
padding: 0;
margin: 0;
}

#wrapper
{
position: absolute;
top: 0px;
left: 0px;
width: 100%;
height: 100%;
}

#pixiscreen
{
position: relative;
margin: 0 auto;
max-height: 100%;
min-height: 100%;
}

Der BODY und HTML Bereich wird auf die Fenstergrösse angepasst. Mit overflow-x: hidden wird alles versteckt, was breiter als das Fenster ist. Dasselbe wird mit der Höhe gemacht. Irgendwie ist das Div beim Chrome immer 0.2 Pixel grösser als das Fenster oder so, was zur Folge hatte, dass Scrollbalken auftauchten, welche dann sowieso noch ein bisschen mehr vom Fenster verdeckt haben. Overflow bräuchte es nicht, wenn das div zum Beispiel 99% Grösse hätte, doch ich will einen randlosen Bildschirm.

Das Padding- und Margin-Attribut wird auf 0 gesetzt, damit kein Rand übrig bleibt. Der #wrapper muss eine absolute Position haben, damit der #pixiscreen mit Margin horizontal zentriert werden kann. Dies hier nur zur Sicherheit, da der Pixi-Screen sowieso das ganze Fenster ausfüllt.

index.html

In die index.html kommt erstmal das HTML-Grundgerüst:

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8" />
<title>EmulatroniX</title>
<link rel="stylesheet" type="text/css" href="css/base.css">
</head>
<body>
<div id="wrapper">
<div id="pixiscreen"></div>
</div>

<script src="https://code.jquery.com/jquery-3.2.1.min.js" integrity="sha256-hwg4gsxgFZhOsEEamdOYGBf13FyQuiTwlAQgxVSNgt4=" crossorigin="anonymous"></script>
<script src="https://pixijs.download/v4.5.2/pixi.min.js"></script>
<script src="http://cdn.rawgit.com/ben0bi/RUNPIXI.js/v0.6.4/RUNPIXI/RUNPIXI.js"></script>

<script>
function mainLoop() {}

$(document).ready(function()
{
RUNPIXI.initialize('pixiscreen', mainLoop);
console.log("Ready.");
});
</script>
</body>
</html>


Mit dem DOCTYPE-Tag wird dem Browser mitgeteilt, dass wir HTML 5 benutzen.
Das Meta-Tag stellt das Characterset auf UTF-8. Somit ist immer klar das gleiche Characterset definiert. Die CSS-Dateien werden im Header eingebunden, da sie vom Browser gebraucht werden, um das Layout aufzubauen. Die JavaScript-Dateien werden jedoch am Ende des Bodys hereingeladen, so dass das Layout im Aufbau nicht blockiert wird.

Das #pixiscreen-div ist im #wrapper-div, damit man es horizontal zentrieren kann.

jQuery ist eine Bibliothek, um viele Sachen in JS zu vereinfachen.
Den jQuery-Link bekommt man hier in dieser Form.

PixiJS ist eine JavaScript 2D-Graphikbibliothek, welche auf Geschwindigkeit ausgelegt ist.
Sie benutzt wenn möglich WebGL, ansonsten wird die DOM-Struktur benutzt.
Hierin werden wir die Textur erstellen, auf welcher dann der Bildschirm des Emulators gerendert wird (sogenannte RTT-Technik: Render-To-Texture - wobei hier nicht wirklich eine Szene auf die Textur gerendert wird, sondern nur die Pixel der Textur "direkt" ausgetauscht/verändert werden).
Den Link zu Pixi habe ich selbst aus den Releases von PixiJS herausgesucht.

Schliesslich ist RUNPIXI.js eine kleine Bibliothek, welche ich geschrieben habe, um den Initialisierungsprozess von PixiJS zu vereinfachen. Man braucht nun nur noch ein Kommando auszuführen, nämlich RUNPIXI.initialize(DOMContainerID, loopFunction), alles Andere macht RUNPIXI.

Wenn die Fenstergrösse geändert wird, merkt RUNPIXI das und passt automatisch den Pixi-Renderer an.

Schliesslich wird der Pixi-Bildschirm in dem kleinen Script am Ende initialisiert. Dazu muss es eine mainLoop-Funktion haben, welche nach jedem Frame aufgerufen wird. Diese benutzen wir gerade noch nicht. Man beachte, dass beim Namen des pixiscreens in der Initialisierungsfunktion kein # davor steht: RUNPIXI verzichtet auf jQuery.

Du kannst dem Pixiscreen deine eigene Hingergrundfarbe geben oder ihn sogar transparent machen, indem du die Farbe in der Initialisierungsfunktion als Parameter angibst. Die Farbe kann hexadezimal so angegeben werden: 0xRRGGBB wobei R für Rot, G für Grün und B für Blau steht.

RUNPIXI.initialize('pixiscreen', mainLoop, 0x111133); <-- Schönes dunkles Blau.
RUNPIXI.initialize('pixiscreen', mainLoop, 'transparent'); <-- Transparent. Man sieht nur, was du auch zeichnest.

Fertig!

Wenn du nun die Index.hmtl-Datei im Browser öffnest, sollte dein gesamter Browserbildschirm türkisblau sein (ausser du hast eine andere Farbe angegeben). Damit haben wir die Basis-(Graphik-)Engine initialisiert - das war ja noch ganz einfach. :)

Ich werde für jeden Part/Artikel auf GitHub ein Release vom jeweils aktuellen Master machen.

Das ist das Release für diesen Artikel:
https://github.com/ben0bi/EmulatroniX/releases/tag/Blog_Series_Part_2

Weiter gehts mit [Bitte warten, komplett neuer Aufbau] DIY: Emulator Teil 2.1: Der Emulator Bildschirm.


Samstag, 20. Mai 2017

DIY: Emulator Teil 1: Research

Dies ist eine deutsche Neuauflage meiner How-To-Make-An-Emulator-Serie, Teil 1.
Im originalen (englischen) Artikel ist ein ziemliches Chaos, da ich mich nicht wirklich für eine Entwicklungsumgebung entscheiden konnte. Nun habe ich JavaScript gewählt und werde auch dabei bleiben.

In diesem Artikel betreiben wir erstmal ein bisschen Forschung.

[EDIT]: Ich bin ein autodidaktischer Programmierer und habe Spass daran, Dinge selbst herauszufinden oder nachzuprogrammieren (Theorie zu Praxis, nicht einfach Code kopieren ;) ). Ich habe erst mal ein bisschen komplexere Artikel geschrieben um die Grafik aufzubauen. Das wurden dann schon ein paar Artikel, und bei diesen habe ich alles "selbst erfunden". Beim Emulator-Code selbst werde ich höchstwahrscheinlich einfach die zuunterst verlinkten Artikel ins Deutsche übersetzen.

Da schon nur der Grafikaufbau in mehrere Artikel ausgeartet ist, werde ich versuchen, eine etwas andere Nummerierung zu bewerkstelligen:

[EDIT] Ich habe nun das ganze Chaos aus den veröffentlichten Artikeln heraus genommen.
Grund: Es war in jeder Version zu langsam auf Standard-Laptops. Ich versuche dies nun mit Shadern zu bewerkstelligen. Bitte warten...

Mit Nummern versehen sind die Artikel, welche sich mit dem Aufbau des Grundgerüstes befassen, welches "extern" benötigt wird um den Emulator ("intern") anzuzeigen und zu bedienen. Die Grafik und das Basisgerüst werden in Teil 2 und allen zugehörigen Artikeln abgehandelt, also Teil 2.1_12.1_22.1_3, sowie Anpassungen 1 und Demo 1.

Mit Buchstaben versehen sind die Artikel, welche sich mit dem jeweiligen Emulator selbst befassen,
zum Beispiel [TODO] Gameboy A: Die CPU, Gameboy B: ...

Du findest alle Artikel zu dieser Serie auf dieser Seite.

Was ist ein Emulator?

Ein Emulator ist eine Software, welche eine bestimmte Hardware A auf einer anderen Hardware B simuliert, so dass man die Software, welche für Hardware A konzipiert wurde, auch auf System/Hardware B laufen lassen kann.

Die geläufigsten Emulatoren sind Konsolen-Emulatoren, welche zum Beispiel den Super-Nintendo auf einem PC emulieren. Es gibt aber auch für jegliche andere Hardware Emulatoren. Von einfachsten Chips bis zu den grössten Superrechnern kann man alles emulieren - wenn man genug (Rechen-)Zeit hat.




Ich habe einst einen Sega Master System Emulator, den ein Freund geschrieben hat, mit einer besseren graphischen Ausgabe beschert. Seine Software hat das Bild direkt in einem ganz kleinen Fensterchen auf dem Bildschirm ausgegeben. Ich habe dann eine 3D-Bibliothek mit einem Texturrenderer benutzt, um zu skalieren und verschiedene Filter darüber zu legen.
Leider habe ich den Sourcecode verloren.

Hier ist der Emulator für deine Befreudigung:
SMSEmu (homeserver) (direkter Download)
SMSEmu (OneDrive)

Dieser englische Artikel bietet gute Grundlagen.
http://fms.komkon.org/EMUL8/HOWTO.html

Zuerst möchte ich das Sega Master System emulieren, doch zuallererst muss eine Basis-Engine geschrieben werden mit der Grafikausgabe und weiterem. Die Grafik wird in Part 2 herbeiprogrammiert.

Diese ROMs (Spielkassetten-Dateien) sind für das Sega Master System. Sie dürfen jedoch nicht mit deinem Produkt ausgeliefert werden. Das wäre illegal. Ich biete sie hier nur an, damit man etwas zum testen des Codes hat.
SMSRoms.zip (homeserver) (direkter Download)
SMSRoms.zip (OneDrive)

Theoretische Überlegungen

Mein Ziel ist immer noch ein Multi-Purpose-(Konsolen-)Emulator, welcher aufgrund des geladenen ROMs entscheidet, welche Hardware dafür vorgesehen ist, und diese dann emuliert. Du könntest dann ROMs von jeder unterstützten Plattform in den selben Ordner kopieren und einfach das Spiel spielen, ohne dich um die Plattform-Auswahl kümmern zu müssen.

Der Emulator liefert ein Array mit Pixeldaten, die dann dargestellt werden können wie wir uns es wünschen. Somit ist es eigentlich egal, welche Engine man benutzt. Hauptsache man kann damit irgendwie Pixel rendern. Nachdem ich nun einige Zeit PixiJS benutzt habe, will ich es mal damit versuchen. Damit kann man wirklich schöne Sachen machen.

Fakten sammeln

Um einen Emulator zu bauen, muss man natürlich die zu emulierende Hardware kennen. Dazu gibt es meistens Dokumente, die aufzeigen, wie sie funktioniert. Dann muss man diese Hardware in Software nachbauen.

Ich möchte das Sega Master System (SMS) zuerst machen. Der oben genannte Freund gab mir dazu diesen Link, wovon er das oberste Dokument empfahl, welches er selbst gebraucht hat.


Dieses Dokument hier gibt mehr Informationen als alle anderen:

Der Gameboy wäre jedoch hier besser geeignet, da jemand schon einen JS GameBoy-Emulator geschrieben hat: 

Ich werde mich vorerst nach diesem Tutorial richten.

Doch darum kümmern wir uns, wenn die Grund-Engine steht.

Anders als im oben verlinkten Artikel, werden wir zuerst die Grund-Engine bereit stellen, in der dann alle Emulatoren ausgeführt werden können. Dies wird dort "erst" ab Kapitel 5 [gar nicht(?)] abgehandelt und ich möchte dir nicht die Entscheidung der Wahl deiner zu emulierenden Hardware abnehmen, nur weil das Grundgerüst erst "später" gemacht wird.

Im Grundgerüst wird der Bildschirm aufgebaut und gezeichnet, sowie der Sound ausgegeben.

[edit 2019] Ehm sorry aber ehm.. ich nehm trotzdem Unity und C# weil man jetzt endlich (gratis) auf der Textur herum zeichnen kann, also...

Oder direkt mit: [TODO] Gameboy A: Die CPU

Dienstag, 9. Mai 2017

Mickey Rubbish


Ein Rubber Ducky als Maus getarnt.

WARNUNG: Dieser Artikel dient informativen Zwecken. Der Autor weist jegliche Haftung von sich.
Der Autor warnt vor dem Gebrauch eines solchen Gerätes. Es können schwere Schäden verursacht werden durch den falschen Gebrauch solcher Geräte. Deshalb ist oben im Bild auch ein "Warnschild" angebracht. Dieser Artikel dient der Aufklärung.

Dies ist ein erweiterter, deutscher Artikel von diesem Originalartikel. Danke dafür an tim.

Als ich den Begriff "Rubber Ducky" in der Serie "Mr. Robot" gehört habe, wollte ich unbedingt auch so ein Ding haben. Schon nur des Namens wegen.

Die Hardware

Ich habe mir also gleich ein RasPi Zero bestellt (meins hat kein WLAN), und einen USB-Stecker dran gelötet.

Hier ist das Wiring-Bild. Für dieses Projekt interessiert nur der untere Teil. Man beachte, dass man hier den male-Stecker von hinten sieht, also vom Gerät aus.
Freundlichst geklaut von hier.

Dann wusste ich erst nicht, was ich für eine Hülle machen soll und mit welchem Material. Ich habe noch eine alte Kabelmaus gefunden und dachte, das ist doch die perfekte Tarnung.

Beim USB-Kabel von der Maus musste ich erst herausfinden, welche Farbe denn nun was bedeutet. (Ich konnte es mir schon denken...)

Deshalb habe ich den USB-Stecker am Pi weggeschnitten und eine Pin-Steckerverbindung an das Restkabel gelötet. So konnte ich alle Kombinationen austesten.



Rot ist +5V, Schwarz ist GND, Grün ist D+ und Weiss ist D-.

Bei meiner Konfiguration sind also folgende Farbkombinationen vorhanden:

USB-PinRasPiMauskabelFunktion
1OrangeRot+5V
2GrauWeissData-
3BlauGrünData+
4BraunSchwarzGND

Ich musste die Platine von der Maus herausnehmen. Der Zero hätte sonst nicht reingepasst.
Desweiteren musste ich an der Seite einiges wegfräsen und einen der Pfosten für das Mausrad entfernen. Zum Glück keinen tragenden Pfosten, die Aufmachung des Rades ist auf der anderen Seite.

Das Mausrad selbst musste auch halbiert werden.


Den unteren Plastik mit der Optik wollte ich auch drin lassen, darum habe ich ihn flacher gemacht. Das war jedoch im Endeffekt nicht nötig. Der RasPi Zero hatte nun schön Platz und ein erster Test war erfolgreich.



Ich wollte das Erlebnis noch akkurater gestalten und habe die LED von der Maus von unten her an die Pins 1 und 6 vom RasPi Zero gelötet. Also den ersten Pin links oben und den dritten Pin rechts oben bei den GPIO-Pins. (3.3 V und GND). Die Halterung von der LED fixiert die Optik auf der Maus und die Optik fixiert ihrerseits den RasPi als Gesamtes. Sobald man "die Maus" einsteckt, leuchtet nun die LED auch.



Wie schon bemerkt müsste man an der Optik nichts weg fräsen. Dank der Halterung für die LED ragt nun auch der Kartenslot schön heraus, so dass man die Karte ganz einfach wechseln kann, wenn der Deckel entfernt wurde.


Schliesslich noch das Mausrad drauf gepappt...


Und so sieht es am Ende aus...total unauffällig.



Die Software

Das Duckberry-Image habe ich mit dem USB Image Tool auf die MikroSD-Karte gebrannt.

Dann muss man die payload.dd-Datei auf der Karte bearbeiten.

Ich habe erst mal den mitgelieferten payload getestet und bin schon da auf die ersten Probleme getroffen: Das OS schreibt mit der englischen UK-Tastatur, wir haben hier jedoch die Schweizer Tastatur. Ich hatte keine Lust, das gesamte OS neu zu kompilieren, nur um die Keymap zu wechseln - welche dann auch wieder nur individuell für mich stimmen würde.

Also habe ich folgenden Payload geschrieben (abgekürzt):

DELAY 500
GUI r
STRING notepad
ENTER
DELAY 1000
STRING abcdefghijklmnopqrstuvwxyz
ENTER
STRING ABCDEFGHIJKLMNOPQRSTUVWXYZ
ENTER
STRING 1234567890
ENTER
STRING Sonderzeichen
ENTER
STRING 1 +
ENTER
STRING 2 "
ENTER
STRING 3 *
ENTER
STRING 4 ç
ENTER
STRING 5 %
ENTER
STRING 6 &
ENTER
STRING 7 /
ENTER
STRING 8 (
ENTER
STRING 9 )
ENTER
STRING 10 =
ENTER
STRING 11 ?
ENTER
STRING 12 `
ENTER
REM und so weiter .... mit allen Sonderzeichen, äöüéèà, Klammern etc.
STRING 25 \
STRING 26 #

Dies liess ich dann auf meinem Laptop laufen, welches mir schön Notepad geöffnet und alle Sonderzeichen mit einer Nummer versehen dort reingeschrieben hat. Anhand der Nummerierung konnte ich dann herausfinden, wie der Youtube-Link aufgebaut sein muss: www.zoutube.com#watch_v)dQw4w9WgXcQ oder so. So hab ich das dann in den Standard-Payload hineingeschrieben und schon ging es.

Ich hoffe das hilft auf deinem Weg der Besserung. Viel Spass!

Dienstag, 2. Mai 2017

Bordcomputer + Halterung für Fahrrad

Für mein neues Fahrrad wollte ich einen Bordcomputer, welcher navigieren und Musik abspielen kann. Deshalb habe ich mich für ein kleines Tablet entschieden, anstatt für ein TomTom und einen Mp3-Player.

Ich habe mir ein Samsung 7-Zoll Tablet gekauft. WARNUNG: Es lässt sich NUR mit dem mitgelieferten Adapter aufladen. Das Ziel war, Solarpanels zu benutzen, doch das geht nicht. Mit anderen Adaptern gehts auch nicht. Deshalb gibts hier auch keinen Produktlink.

Nun gut, ich bin ja nicht ewigs unterwegs, ich muss einfach wissen, wo eine bestimmte Strasse in der Stadt ist oder so. Das Strom-Problem habe ich auch erst "zu spät" entdeckt, nachdem ich die Halterung schon gebaut hatte.

Die Software

Das Ziel der Übung ist ein OFFLINE Bordcomputer, da ein WLAN sehr selten in der freien Natur (benutzbar) anzutreffen ist, und dieses Händyzeug kann ich sowieso nicht ausstehen. Es muss also offline funktionieren. Deshalb gabs auch gleich eine 32GB microSD-Karte dazu, damit all die Daten unten auch offline verfügbar sind.

Musik

Musik kann man sich bequem mit dem Kabel vom PC herüberladen.
Der Music-Player von Samsung reicht völlig. Dieser war jedoch noch nicht vor-installiert.

Navigation

Hier ist die App "MapFactor Navigator" mein Favorit. Diese ist gratis und man kann sich alle Karten herunterladen. Ich habe alle Karten ausser Amerika (Kontinent), da ich nicht vor habe, mich oder mein Fahrrad dort hin zu bewegen. Und Züri West hat auch schon gesagt: "Amerika gits nid."

Damit der Navigator auch gratis bleibt, muss man am Anfang die zweite Kartenoption wählen: OpenStreetMap-Daten anstatt Google-Daten. Dann kann man irgendwo in ein Menü und sich all die Karten auswählen, die man halt so haben will. Einige (Länder) haben recht viele Daten und sind in Bezirke aufgeteilt (zB. Frankreich, Deutschland), andere sind jedoch nur ein paar Kb gross (meist östliche Länder)

Es dauert eine Weile, bis alle Karten heruntergeladen sind....aber dann hat man sie.

Mehr brauchts nicht. Ich hab noch die Google-Uhr (sehr bequem mit "Ok, Google, stelle Timer auf X Minuten" (nur mit Netz)) und Fallout Shelter installiert, welches man offline spielen kann.

Die Halterung

Dazu habe ich eine hübsche Tabakbox genommen und diese bearbeitet.
Das Tablet passt knapp rein, wenn man am Rand ein bisschen Material weg fräst.


Erst wollte ich eigentlich den ganzen Screen zeigen, doch ich dachte "Warum nicht mal ein runder Bildschirm? Die wichtigsten Infos sieht man ja eh meistens in der Mitte...vor allem beim Navigieren."

Ich habe mich dazu entschieden, ein Bullauge in den Deckel zu machen.

Das runde Loch im Deckel habe ich von innen heraus ausgeschnitten und "gleichmässig" erweitert.
Dieses wurde später noch ein bisschen vergrössert.

Das Plexiglas habe ich auf den rechteckigen Innenraum zugeschnitten. Somit ist es immer "richtig" fixiert für die Schraubenlöcher.

Mit dem Zirkel habe ich die 6 Löcher für die Schrauben markiert, dann das Plexi reingelegt und durch alles hindurch gebohrt. Merke: Lieber aufeinanderlegen anstatt ausmessen! ;)


Die Schrauben, Muttern und Unterlagsscheiben habe ich mit Goldspray gefärbt.

Schliesslich habe ich noch die Buttons "herausgezogen": Ich habe 3 Löcher in die Seite gebohrt und
dann die Schrauben mit den Federn herein gemacht. Mit diesen Schrauben kann man den Screen an- und ausschalten und die Lautstärke regulieren, ohne dass man den Deckel öffnen muss. Die Federn müssen (für diese Schraubenlänge, welche gerade verfügbar war) sehr kurz sein: 2 Windungen reichen schon.


Und hier nun, das aktuelle Endprodukt mit laufendem Navigationssystem.


Ich möchte noch so einen typischen Bullaugen-Metallring auf den Deckel machen, weiss jedoch nicht, wie ich die runde Kante innen hin bekommen soll....

Die Halterung für das Fahrrad kommt, wenn das Fahrrad da ist. Dazu will ich einfach unten noch ein paar Löcher bohren, an welche man dann die "richtige" Halterung dran machen kann.

Samstag, 4. März 2017

Programmierung eines brandneuen ATmega328p mit Arduino UNO

Programmer auf Karton

Programmer auf PCB


Originaler Artikel (englisch)

Einführung

In diesem Artikel erkläre ich, wie ich meine brandneuen ATmega328p-Chips mit meinem Arduino UNO (Rev. 1 oder 2) programmiert habe. Die Informationen sind zwar im Web (englisch) verfügbar, doch es dauerte eine Weile, um Alles zusammmen zu bringen. Hier wird nun alles erklärt, vom Aufbau des Test-Boards bis zum hochladen eines Arduino-Programms auf den Chip.

Ich habe einen Arduino UNO, welcher mit einem ATmega328p-Chip bestückt ist. Ich dachte,  OK, dann bestellen wir mal ein paar von denen. Hier war einfach die Kostenfrage entscheidend: Ein Arduino kostet so um die 30 CHF, der Chip selbst aber "nur" um die 5 CHF.

Hier ist das Pin-Diagramm des ATmega328p nachdem der Arduino-Bootloader auf den Chip geladen wurde:


Man beachte hier die runde Kerbe links. Diese ist auf jedem Chip dieser Bauart, sowie auch auf den Halterungen dazu. Sie zeigt an, in welche Richtung der Chip eingelegt werden muss (Kerbe zu Kerbe).

Liste der benötigten Teile

Im Gegensatz zum Originalartikel werde ich hier einen Link zu jedem Bauteil angeben.
Diese Links werden meist auf ELV.de verweisen, um möglichst nur eine Bestellung machen zu müssen.

Du brauchst die folgenden Dinge:

+ Einen Computer. ;)
+ 1x Arduino UNO (oder Duemilanove oder so, probier es aus.)
+ 1x ATmega328 chip, DIP 28, brandneu, ohne bootloader oder so darauf.
+ Ein Experimentierboard (oder Karton oder PCB und ein Lötkolben ;) )
+ Verbinder-Kabel (Link als Beispiel)
+ 1x 10k Ohm Widerstand (Link als Beispiel)

Diese Dinge habe ich desweiteren gebraucht. Ich weiss nicht, wie man auf den internen Timer (8MHz) programmiert, denn ich wollte unbedingt die volle Leistung herausholen...weiss Gott, warum:

+ 1x 16Mhz Quarz Schwingkreis
+ 2x 22pF Kondensatoren (ACHTUNG: Der Quarz oben hat eine maximale Last von 18pF, der Wert hier ist aus dem Originalartikel und ich habe keine Ahnung, wie ich darauf gekommen bin.)
+ Optional noch 1x On/Off Schalter, um den externen Oszillator aus zu schalten.

Zuletzt die LEDs. Sie werden nicht unbedingt gebraucht, können aber bei der Entdeckung von Fehlern behilflich sein:

+ 1x Blaue LED, welche den Herzschlag des Host-Arduinos repräsentiert.
+ 1x Grüne LED, welche leuchtet, wenn die Software erfolgreich auf den Chip übertragen wurde.
+ 1x Rote LED, welche bei einem Fehler aufleuchtet.
+ 1x Gelbe LED, welche zum Testen des Chips (Blink-Sketch) benutzt wird.
+ 4x 100 Ohm Widerstände.
(Die Links dienen als Beispiel)

Alle Teile da? Dann fangen wir mal an...

Arduino IDE

Um den Arduino und den Chip zu programmieren, benutzen wir die Arduino IDE. Es muss mindestens Version 1.0.1 sein, oder auch tiefer als 1.0.0, doch mit Version 1.0.0 lief der serielle Port mit 9600baud, auch wenn man 19200baud angegeben hat. Die aktuelle Version ist 1.8.x, das sollte also kein Problem sein.

Du findest die neueste Version hier:

Neuerdings gibt es auch eine Online (Web-)Version der Software, doch ich weiss nicht ob und wie das funktioniert.

Den Arduino aufsetzen

Bitte entferne alle Verbindungen zu deinem Arduino um Software darauf hoch zu laden. Dies dient der Sicherheit der Chips (Sowohl des Hosts als auch des Clients.) Um das einfacher zu machen, laden wir die Software schon jetzt auf den Arduino. (Auf die Arduino-Platine, nicht auf den ATmega328-Chip, welchen wir programmieren wollen.) Wenn die Software erst mal installiert ist, brauchen wir daran nichts mehr zu ändern.

Wir brauchen diesen Sketch: ArduinoISP2c.zip (auf meinem Onedrive-Account aber nicht von mir.)

+ Öffne die IDE und verbinde den UNO mit dem Computer.
+ Lade den ArduinoISP2c-Sketch in die IDE.
+ Wähle den richtigen Port im Tools-Menü aus.
+ Drücke nun auf "Upload" und warte bis es fertig ist.

+ Um nun den Chip auf dem Experimentierboard zu programmieren, müssen wir einen anderen Programmer auswählen. Gehe nach Tools->Programmer und wähle "Arduino as ISP" aus. Prüfe das doppelt und dreifach nach, sonst überschreibst du deinen UNO!!

(Im Originalartikel steht: JETZT den Sketch hochladen, und danach den Arduino mit dem Experimentierboard verbinden - das ist unlogisch und ich erwähne es hier nur, falls etwas schief gehen sollte.)

+ Verbinde nun den Arduino mit dem Experimentierboard (Siehe unten)

Dies ist der Schaltplan für das Experimentierboard mit einem verbundenen Arduino:

Und so sieht es auf dem Board selbst aus:

Hier ist nun noch ein Schaltplan, um einen Programmer zu bauen, sowie ein Bild des Platinenentwurfes. Es ist genau das selbe wie oben, nur dass hier die Verbindungen zum Arduino durch eigene Pins ersetzt wurden. (Hier Female, man kann aber auch Males benutzen.)


Nachdem wir nun unser Board verbunden oder unseren Programmer gebaut und verbunden haben, können wir endlich mit dem lustigen Zeug beginnen.

Alle benötigten Dateien findest du auf dem GitHub-Repository zu diesem Artikel:
http://github.com/ben0bi/BATmegaProgrammer

Zuerst mal AVR, dude..

AVRDUDE ist ein Kommandozeilen-Tool, welches mit der Arduino IDE mitgeliefert wird. Da ich es nicht finden konnte, habe ich es separat noch einmal heruntergeladen. Mit diesem Tool werden wir die "Fuses" setzen, welche man mit "Jumpern" oder den ganz kleinen Schaltern vergleichen könnte, welche es früher auf Mainboards gegeben hat...nur, dass die Fuses in Software "verbaut" sind und nicht in der Hardware. ;)

Mit den Fuses stellen wir ein, dass der Chip mit dem externen Oszillator-Quarz laufen soll anstatt mit dem internen.

Wenn du andere Vorlieben hast, kannst du mit diesem Tool die Werte der Fuses kalkulieren:
http://www.engbedded.com/fusecalc

AVRdude ist wie schon beschrieben ein Kommandozeilen-Tool und muss mit einigen Parametern gestartet werden. Wir werden die folgenden Parameter benutzen:

-c: Wähle den Programmer aus. Wir werden hier avrisp benutzen.
-p: Der chip, welcher programmiert werden soll. Hier m328p.
-P: Der Geräte-Port des Arduinos. Es ist com3 auf meinem Windows-Computer.
-b: Die Baud-Rate, welche benutzt werden soll. Wir brauchen 19200 baud.
-U: Führe einen Befehl auf dem Chip (und nicht auf dem Arduino) aus.
-u: Muss mitgegeben werden, wenn man die Fuses setzt. Sagt einfach: JA, ich WILL WIRKLICH die Fuses setzen.

Ok. Erstmal prüfen wir, ob der Chip bereit ist:
avrdude -c avrisp -p m328p -P com3 -b 19200
So etwas wie "All OK sollte nun in der Konsole aufpoppen.

Wenn alles OK ist, werden wir nun die Fuses setzen. Ich weiss nicht genau, was all die Werte genau tun, ich weiss einfach, dass es funktioniert. Ich musste den Wert für die Low-Fuses selbst herausfinden, doch die anderen Werte bekam ich von einer anderen Website (siehe oben).

Erstens wird der Chip auf den externen 16MHz Oszillator vorbereitet, desweiteren wird auch das Lock-Byte auf 0x0F gesetzt (warum auch immer) und ein paar andere Sachen.
avrdude -b 19200 -c avrisp -p m328p -P com3 -U efuse:w:0x05:m -U hfuse:w:0xD2:m -U lfuse:w:0xFF:m -U lock:w:0x0F:m -u

Das ist alles. Um die Fuses zu prüfen, kann dieser Befehl benutzt werden:
avrdude -b 19200 -c avrisp -p m328p -P com3 -U hfuse:r:fusehigh.txt:s -U lfuse:r:fuselow.txt:s -F

Damit werden die Werte der gegebenen Fuses (hier: hfuse und lfuse) in die jeweilige Textdatei geschrieben (hier fuselow.txt und fusehigh.txt).

Den Bootloader brennen

Nun, da alle Fuses gesetzt sind, der Chip OK ist und den externen Quartz benutzt, und der Programmer der Arduino IDE auf "Arduino as ISP" gesetzt ist (!!!), können wir den Bootloader auf den Chip auf dem Experimentierboard brennen.

Wähle einfach Tools->Burn Bootloader in der IDE und warte ein bisschen. Wenn nichts schief gegangen ist, solltest du nun Arduino-Sketches auf den Chip laden können.


Der letzte Test

Lade nun den Blink-Sketch über File->Examples->01. Basics->Blink in der IDE und ändere den Output-Pin (13) auf 8.

Lade den Sketch auf den Chip über Sketch->Upload via Programmer in der IDE. Prüfe aber erst, ob der Programmer immer noch auf "Arduino as ISP" gestellt ist!

Die gelbe LED auf dem Experimentierboard sollte nun blinken.

Ich hoffe, das hilft.

Dienstag, 3. Januar 2017

microSD-Card Holder for Metal Swatch.

So, you have this cool Swatch-watch and don't know how to move that mechanical stuff to the next millenium? You ever wanted to be a spy or something? Then this is for you...


This is a spy-style microSD-card holder for the "Swatch Sistem Boreal YIS401G" and other watches with the same metal wrist, created on TinkerCAD.com and printed with a Dremel 3D-printer.
(Don't worry, the link for the TinkerCAD model is at the bottom of this post.)


First I wanted to make a round inner part which can be turned to open it. But this would not fit in.
So I made a "cheap and dirty" rectangular inner part which...is better than I thought.

The microSD-card locks the inner part from falling out. But it does fall out easily if it is "unlocked".


The outer part fits into the latch of the metal wrist, it can be "clicked in"...
After some trial-and-error 3D-prints I had the right end product, which properly "locks" and "unlocks" and fits into place at all. 




As you can see here, it does not fit exactly when you wear the watch. But there is no less comfort for me, and it is almost invisible. If I had used 3dMax or such, that would be no problem to fix. ;)

Back: Almost invisible
Front + Seen from the hand to the head.
 And here's some sWatch-Porn:


I hope you like it. Here is the TinkerCad-model.

Please like, comment and share. Thanks for your attention.

Mittwoch, 12. Oktober 2016

The Green Lantern: Computerized Glowing Bedside Table

This is a little project I made "out of nothing".

I had a standard wooden crate left, which I already used as bedside table.

Buy it here (Switzerland): Buy Wooden Crate

I have a cheap laptop (Packard Bell, 13 or 15 inches(?)) which fits EXACTLY into the crate. The crate is 37cm broad, that you know it.

Only the screen needs to be turned from the inside to the outside.

The keyboard and the touchpad are non functional anymore. I thought, ok, now I can turn the screen to the outside without a big loss. If it is gone, it's gone. But it works...

Here is how you get the screen off. Just turn it and fiddle it back on.
https://www.youtube.com/watch?v=IqNpRGFgg0Q

STOP at 3.50! Don't pull out the cable! Just turn it 180degrees viewed from the top, not from the side, else the screen is mounted upside down.



You then need to adjust the cover a little bit with the dremel, so that you can use the back side on the inside and the front side on the outside. I removed the camera, I don't need it. The cover will not fit exactly (on the side), but it will cover as mostly as good as in the original configuration. You can even put the screws for the cover back on (with this model, at least).




Then I got some nails and a metal plate from an old computer housing. The plate is the ground for the laptop to stand on. I measured how heigh the screen is, and then hit the nails into the crate, where the laptop should stand. Then I put the plate in, on that the laptop, and hit some other nails on top of the laptop to fix it. Now it cannot "flip" out of the box.

The laptop fits so exactly, that on the front side I can put in the power cable and on the "back" side (of the box) there is room for the audio cable, exactly so, that the laptop will be fixed from moving to the front/back. On the other side of the box, I had to drill a hole to get at least one USB-port free, which I used for the external keyboard.

Holding nails and perfect fitting cables.
(The hole is from a previous setup and...I cannot remove a hole ;) )
I had to buy an external keyboard with a touchpad which is smaller than 37cm: Logitech K400 plus. The "plus" is for the additional sound keys, which are essential for this project. I will make a holder for it, but I don't know yet, how.

The laptop has a loooong cable which does look ugly if it is "just in the box". Luckily, our local jewelry store keeps the jewelry boxes from Fossil (http://fossil.com), which I get from time to time for free. I already built two RasPis into such boxes, they are very nice.

I had a box left where the cable just fits in. I made two holes for the cable on the side, two holes for the screws in the back and another hole into the top side to fix it with a screw when it is assembled.



Then I made a light into the box. Just a standard light fixed on a tobbacco box and with a switch, no big deal. To not press the (functioning ;) ) keys, I fixed the light on a cardboard which fits exactly in the box, cut out a tiny bit for the cable and put it over the laptop.

I put in some standard white A4 paper into the inside of the box to cover the free spaces.
It was way to bright.  I thought the screen on the front side would swallow the light, but it doesn't.


Luckily (again), I had an old duvet cover left in a nice green color.

I moved all the stuff out of the box and used a staple gun to put the fabric inside. The cable box was then assembled to the box again with the fabric between. WARNING: Use an "industrial" staple gun (for wood), not a standard bureau staple gun. I needed about 20 staples until ONE got in right, for every one. Later I borrowed the right staple gun from a friend...



The fabric must cover all the holes on the top of the box. The light will shine through the smallest hole, so cover it. ;)

(I show the image of the light just here and not above, because there is no image with the light and no fabric.)

I made a front cover out of fabric for behind the screen, built in 3 (three) magnets on each side and stapled the top side to the top (inside) of the box. I used some metal pins (standard bureau pins) in the box for the magnets to hold on.



A friend got me a flat USB-hub with a flat cable. I got rid of the plastic housing and made a cigarillo-box housing for it. Just put the hub between some paper to shield it from the housing metal.
That  is the only thing which I glued to the box.


At the very end, I needed to attach some wheels. I turn that thing every now and then, it needs wheels...a wheel is Fr. 6.50 at Schwab Eisenwaren (my local metalware store), a little bit expensive but worth it.



Last but not least, there is a standard power strip. I cut the cable to make the hole in the fabric as small as possible, and connected it again together on the outside of the box.

The laptop should have WiFi but no Bluetooth is needed because the audio cable fixes the laptop on the box anyway. So, why not use it? (This model does not have BT, either.)

[EDIT: 2016-11-11]: Some key was pressed all the time from the broken keyboard. I ripped the whole thing off. Luckily, the power button has its own cable. I glued it to the side of the box.

The button is the small metal thingy above the cable strip.
The big glowing thingy is just the power LED.
I thought about putting a hi-fi system under the laptop, but this is something for another time.

I use it for:
+ Putting stuff on it.
+ Listening to music (Spotify, Youtube)
+ Watching TV with a decent background light. (On a real TV, not this little screen.)
+ Playing Endless Sky and Minecraft Classic on my own server "Super Ben0bi World".
+ Da Interweb, google and stuff... ;)
+ Zonk out with a decent background light and decent background music. ;)

I hope you like it. I hope you build your own one. Look how it glows...


I cannot live without it anymore. :)
Screen turns off after 2 minutes and the computer goes to sleep after 2 hours. I need long to fall asleep...


Update, Version 1.1

December 2016 (Written: 1.1.2017)

I really use that thing. Did not think about that. :) In fact, I love it, it is the second most used computer in my home.

I added some stuff. There is now an "internal" USB-extender with some cables for smartphones and stuff, and a card reader, which is also "internal". I exchanged the bulb for a LED-bulb because this will not break so fast. On the top is now a layer of transparent black plastic foil to cover the internals from...coffee. ;)

Also, I found a wonderful LoFi-System (It's not Hi, you know, it's cheap.), which fits EXACTLY into the box. It is a "SilverCrest SMBC 30 A1", and "can" Bluetooth, 1xAUX, FM-Radio, CD and USB. It is also delivered with a remote. Can say nothing for just 99CHF. Other stores would only sell the front plate for 99.-... XD

On the product photos, the LED-display is "cheap-red" but in original it is in "soft-nice-orange" and can be dimmed in 4 steps inclusive turnig it off.

Photos:

The card reader is fixed with fabric on the side.

The Fossil-box is not gone, it is now under the music box

The internal USB is connected to the external one on the bottom side.




Thanks for your attention. Please like. Please comment. Please follow this channel....wait, this is not youtube nor facebook...lucky me... :)