Browse Source

Artikel zu Sparkduino (#15)

pull/16/head
Robert Jacob 3 weeks ago
parent
commit
919d3daa02

+ 288
- 0
content/projekt/sparkduino.md View File

@@ -0,0 +1,288 @@
---
title: Sparkduino
author: kresse
status: Fertig
difficulty: Einfach
time: 1 Stunde
date: 2019-11-12
image: /images/sparkduino/fertig.jpg
---

# Sparkduino und Co als Tastatureingabe

Projekt im November 2019

## Usecase "Leertasten-Klick-Fußschalter"

Da ich gerade Bass-Lernvideos auf der allgemein üblichen Videoplatform schaue,
und diese öfter mal spontan anhalten möchte, um etwas genauer zu sehen, hatte ich immer das Problem, nicht schnell genug vom Bass auf die Tastatur zu wechseln.

Dabei muss ja nur die Leertaste gedrückt werden.

Ein Fußschalter muss her.

Der war noch in der Bastelkiste, sonst können in Netz aus Fernost für 3-4 Euro schöne Metallfußschalter gefunden werden.

Wie bekommt man also den Schalter als Leertaste an einen
Computer angeschlossen?

Meine Lösung:

Verwendung eines Arduino kompatiblen Sparkduino(-Klons), der noch vor Ort war.

Außerdem habe ich für die Versuche noch
ein kleines Breadboard,
einige Dupont-Kabel und
einen 10 k Widerstand verwendet,

zum Fertigstellen noch:
Eine USB-Verlängerung und
2 kleine Packungen TicTac

# Der Start mit der Installation:

Erklärungen zum kleinen Freund gibt es unter: http://digistump.com/wiki/digispark

Ich habe unter Ubuntu Mate im Herbst 2019 die Arduino IDE (Version 1.8.8) verwendet,
diese gestartet und gleich die Belehrung übersprungen,
daß man schon auf Version 1.8.10 updaten kann...

Angenommen, die Arduino IDE an sich läuft, dann werden die
Sparkduino Installationsquellen unter Voreinstellungen

```
http://digistump.com/package_digistump_index.json
```

reinkopiert.

Beim nächsten Start jetzt das Board unter

Werkzeuge/Board/Boardverwalter

Digistump ...

einbinden.

Das Beispiel runterladen (Modifiziertes Blink),

```c
// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.
pinMode(0, OUTPUT); //LED on Model B
pinMode(1, OUTPUT); //LED on Model A
}

// the loop routine runs over and over again forever:
void loop() {
digitalWrite(0, HIGH); // turn the LED on (HIGH is the voltage level)
digitalWrite(1, HIGH);
delay(1000); // wait for a second
digitalWrite(0, LOW); // turn the LED off by making the voltage LOW
digitalWrite(1, LOW);
delay(1000); // wait for a second
}
```

und anschauen...
Dabei fällt schon auf, dass es verschiedene Versionen gibt:
Bei Version A ist die LED auf einen anderen PIN als bei Version B gemappt.

Also versucht, das Skript auf das Board übertragen ->

Geht nicht.

OK, warum nicht?

Richtiges Board ausgewählt ? Ja,

Richtigen Programmer ausgewählt ? Nein!

Programmer Micronucleus auswählen, kurz mal nachlesen ->

Aha, das Board erst einstecken, wenn der Programmer das sagt. Okay.

Gesagt, Getan, Geflasht.

Ein bisschen warten, juhu, es blinkt.

# Das Erste Skript:

{{< fluid_img alt="Versuchsaufbau" src="/images/sparkduino/versuchsaufbau.jpg" >}}

OK, jetzt das ganze mit Tastaturtreiber (1. Version):

```c
#include "DigiKeyboard.h"

int pushButton = 0;
int sensorValue = 0;

// the setup routine runs once when you press reset:
void setup() {
// initialize the digital pin as an output.

pinMode(1, OUTPUT); //LED on Model A
pinMode(pushButton,INPUT);

// calling the sendKeyStroke() function with 0 starts the script, it cancels the effect of all keys that are already being pressed at the time of execution to avoid conflicts
DigiKeyboard.sendKeyStroke(0);
}

// the loop routine runs over and over again forever:
void loop() {
sensorValue = digitalRead(pushButton); //Returns HIGH or LOW (true or false / 1 or 0).

if (sensorValue== HIGH) {
digitalWrite(1,HIGH);
DigiKeyboard.sendKeyStroke(KEY_SPACE); // schicke " " als Tastatur
DigiKeyboard.delay(150); // Tastaturentprellung
} else {
digitalWrite(1,LOW);
}
}
```

Cool, dazu gibt es reichlich im Netz,denn der Standard-Usecase des kleinen
Boards scheint zu sein, Texte in Windows-Rechner einzugeben und Unsinn
zu machen, aber gut, es geht auch alles andere.

Schon praktisch. Eben den Code zusammen geschustert.

Also Hochladen.
(Ging ja eben) ->

Eine kryptische Fehlermeldung erscheint!

Im Wiki nachgeschaut: http://digistump.com/wiki/digispark/tutorials/connecting

Aha, Jedes Betriebssystem hat seine Tücken. Neben Erläuterungen zu Windows und MAC gibt es auch eine extra Troubleshooting-Seite für Linux (sollte uns das zu denken geben?). Dort findet sich, das unter Ubuntoiden Systemen (Also auch mint und Co.) ein Rechte-Problem existiert, durch anlegen/einfügen von (mit Sudo)

```plain
/etc/udev/rules.d/49-micronucleus.rules
```

mit dem Inhalt:

```ini
# UDEV Rules for Micronucleus boards including the Digispark.
# This file must be placed at:
#
# /etc/udev/rules.d/49-micronucleus.rules (preferred location)
# or
# /lib/udev/rules.d/49-micronucleus.rules (req'd on some broken systems)
#
# After this file is copied, physically unplug and reconnect the board.
#
SUBSYSTEMS=="usb", ATTRS{idVendor}=="16d0", ATTRS{idProduct}=="0753", MODE:="0666"
KERNEL=="ttyACM*", ATTRS{idVendor}=="16d0", ATTRS{idProduct}=="0753", MODE:="0666", ENV{ID_MM_DEVICE_IGNORE}="1"
#
# If you share your linux system with other users, or just don't like the
# idea of write permission for everybody, you can replace MODE:="0666" with
# OWNER:="yourusername" to create the device owned by you, or with
# GROUP:="somegroupname" and mange access using standard unix groups.
```

kann das Problem aber gelöst werden.

So, jetzt aber....

Das Board raus und rein, und tatsächlich:

Das Flashen geht.

und ja, das Board ist empfindlich,
Auf P0 gefasst, die Kontroll-LED leuchtet.
Toll, der Eingang ist ja empfindlich.

Prima, ich stecke ein Kabel an P0 und mache nichts,
die Kontroll-LED leuchtet schon wieder.
Also scheint das System **zu** empfindlich,

Okay, Software umgeschrieben, Pull-UP 10 kOhm Widerstand auf 5V
gelötet, dann kann ich ja gegen GND sauber schalten.

{{< fluid_img alt="Schaltplan mit Pullup" src="/images/sparkduino/schaltplan.png" >}}

# Neues Skript (Version 2):

```c
#include "DigiKeyboard.h"

// DIGISTUMP etc ATTINY85 mit USB Anschluss
// P0 auf GND geschaltet gibt Leertaste

int pushButton = 0;
int sensorValue = 0;

void setup() {
// put your setup code here, to run once:


// initialize the digital pin as an output.
//pinMode(0, OUTPUT); //LED on Model B
pinMode(1, OUTPUT); //LED on Model A
pinMode(pushButton,INPUT);

// calling the sendKeyStroke() function with 0 starts the script, it cancels the effect of all keys that are already being pressed at the time of execution to avoid conflicts
DigiKeyboard.sendKeyStroke(0);

}

void loop() {
// put your main code here, to run repeatedly:
sensorValue = digitalRead(pushButton); //Returns HIGH or LOW (true or false / 1 or 0).

// Wenn P0 auf GND Geschaltet wird
if (sensorValue== LOW) {
digitalWrite(1,HIGH);
DigiKeyboard.sendKeyStroke(KEY_SPACE); //" "
DigiKeyboard.delay(250);
} else {
digitalWrite(1,LOW);
};
}
```

Das funktioniert sogar, leider kann ich jetzt das System nicht mehr gut in
den USB-Port stecken, weil die Pins bzw, der Widerstand am Laptop-Gehäuse
anschlagen..

Also Zwischenkabel dazu. Das funktioniert ganz gut, ausserdem bekomme ich jetzt
das Ganze gut in ein Gehäuse eingebaut.

Jetzt bin ich ja nicht der Gehäusebauer vor dem Herrn, aber eine TicTac-Dose erfüllt den Zweck. Kabeldurchmesser mit der Schieblehre bestimmt, mit Holzbohrer und Akkuschrauber vorsichtig (!) gebohrt. Der Weichplastik-Verschluss oben ist unproblematisch, der Boden ist auch anzubohren, bei vermehrtem Druck aber sehr spröde (zweite Packung TicTac in Reserve ?).

Auf der Weichplastik-Seite kann das Loch mit einem Messer eingeschnitten werden, damit das Kabel eingezogen werden kann.

Auf der anderen Seite habe ich noch eine 3,5 mm Buchse eingebaut.
In meinem Fall kommt ein alter Fußtaster eines (antiken) Diktiergeräts an das System.

Und:
Tatsächlich funktioniert das Ganze.

{{< fluid_img alt="Fertiges Projekt" src="/images/sparkduino/fertig.jpg" >}}

Fun Fact:
Damit kann man auch in Firefox auf einer Website nach unten blättern.

# Fazit:

Wer genau weiß, was er braucht ist klar im Vorteil.

{{< fluid_img alt="Größenvergleich" src="/images/sparkduino/groesse.jpg" >}}

Ja, ein Sparkduino/Digistump oder wie ein ATTiny85 mit USB heißt, kann als Tastatureingabe-Gerät eingesetzt werden. Der kleine Formfaktor hat Vorteile, auch wenn er letztlich (wie beim Gehäuse gesehen) vielleicht gar nicht alle ausspielen kann.

Man muss sich bewußt sein, das hier viele Zusatzschaltungen nicht verbaut sind, die von den "großen" Brüdern verwendet werden. Zum Teil sind Pins lt. Wiki nur dann benutzbar, wenn kein USB gleichzeitig gebraucht wird. Ein Pin ist nur 3,3 V tolerant. Nicht jeder Eingang hat von Hause aus Pull-Up Widerstände.

Die Ansteuerung ist also etwas tricky.

Auch die freie Platine direkt an Laptop oder PC ist nur bedingt dauertauglich, ein Gehäuse direkt am Anschluß oft nicht gut umzusetzen.

Als Alternative ist z. B. ein Arduino Pro Micro in Betracht zu ziehen, der auch eine Tastatur simulieren kann und deutlich mehr I/Os aufweist.

keep on hackin‘

kresse

BIN
static/images/sparkduino/fertig.jpg View File


BIN
static/images/sparkduino/groesse.jpg View File


BIN
static/images/sparkduino/schaltplan.png View File


BIN
static/images/sparkduino/versuchsaufbau.jpg View File


Loading…
Cancel
Save