Prototypen Archive - Seite 2 von 3 - FabMo

Ein GPIO Display am Raspberry konfigurieren und andere Sachen

19.05.2015 Marcus Klütmann Prototypen

Hier in Kurz einmal meinen Weg, wie ich die Software (Retropie) auf dem RaspberryPi mit dem Raspberry Display eingerichtet habe.

Retropie hier runterladen und auf eine SD Karte „brennen“ (z.B. mit Win32 Disk Imager)
http://blog.petrockblock.com/retropie/retropie-downloads/

Eine Manuelle Installation ist auch möglich
http://blog.petrockblock.com/2012/07/22/retropie-setup-an-initialization-script-for-retroarch-on-the-raspberry-pi/

Nach dem ersten Einloggen über SSH dann erst mal

sudo raspi-config

1	sudo raspi-config

ausführen und das Dateisystem auf die gesamte Speicherkarte ausweiten (Punkt 1). Dies ist besonders dann notwendig, wenn man das Komplettimage runtergeladen und auf die Speicherkarte „gebrannt“ hat. Wenn man schon dabei ist, kann man auch gleich die Internationalisierungsoptionen (Punkt 4) auswählen und z.B. das Tastaturlayout (change keyboard layout) einstellen.

Danach dann gleich ein

sudo dpkg-reconfigure console-setup

1	sudo dpkg-reconfigure console-setup

Hier wählt man im ersten Schritt “UTF-8” aus. Im zweiten Schritt “Guess optimal character set”; im dritten “Terminus” und im vierten und letzten Schritt “6×12 (framebuffer only).”. Diese Einstellung sorgt dafür, dass wir die Konsole im kleinen Display besser lesen können.

Jetzt updaten wir einmal das System mit folgenden Befehlen

sudo apt-get update
sudo apt-get install -y git dialog
cd
sudo rm -rf RetroPie-Setup
git clone git://github.com/petrockblog/RetroPie-Setup.git
cd RetroPie-Setup
chmod +x retropie_setup.sh
sudo ./retropie_setup.sh

sudo apt-get update

sudo apt-get install -y git dialog

sudo rm -rf RetroPie-Setup

git clone git://github.com/petrockblog/RetroPie-Setup.git

cd RetroPie-Setup

chmod +x retropie_setup.sh

sudo ./retropie_setup.sh

Damit sollte Retropie auf dem neusten Stand sein.

Bisher bleibt das über die GPIO Pins angeschlossene Display noch schwarz. Das wollen wir nun ändern.

wget -N https://github.com/watterott/RPi-Display/raw/master/rpi-display.sh
sudo /bin/bash rpi-display.sh 270

1 2	wget -N https://github.com/watterott/RPi-Display/raw/master/rpi-display.sh sudo /bin/bash rpi-display.sh 270

Es wird ein kleines Skript runtergeladen und dann ausgeführt. Beim Ausführen bekam ich die Meldung, dass kein „FBTFT“ gefunden wurde und ob ich das System updaten wolle. Dieses habe ich mit Ja beantwortet.

Nun muss man noch ein bisschen in der Bootconfig von RaspberryPi rumfummeln.

sudo nano /boot/config.txt

1	sudo nano /boot/config.txt

Folgende Zeilen sollen in der config.txt am Ende eingefügt werden.

dtoverlay=rpi-display,speed=80000000,rotate=270,fps=60

hdmi_force_hotplug=1
hdmi_cvt=320 240 60 1 0 0 0
hdmi_group=2
hdmi_mode=87

dtoverlay=rpi-display,speed=80000000,rotate=270,fps=60

hdmi_force_hotplug=1

hdmi_cvt=320 240 60 1 0 0 0

hdmi_group=2

hdmi_mode=87

Jetzt muss SPI noch aktiviert werden.

sudo nano /etc/modprobe.d/raspi-blacklist.conf

1	sudo nano /etc/modprobe.d/raspi-blacklist.conf

Hier muss die Zeile mit „blacklist spi-bcm2708“ auskommentiert werden (mit # ).

Wenn man nun die Kommandozeile auf dem Display sehen möchte, muss man in cmdline.txt noch etwas anfügen.

sudo nano /boot/cmdline.txt

1	sudo nano /boot/cmdline.txt

Einfach am Ende der langen Zeile noch dies hier anhängen:

fbcon=map:10 fbcon=font:VGA8x8 logo.nologo

1	fbcon=map:10 fbcon=font:VGA8x8 logo.nologo

Natürlich nicht vergessen, alle Änderungen zu speichern.

Nach einem Reboot ( sudo reboot), sollte die Kommandozeile im Display zu sehen sein. Sobald jedoch EmulationStation (die grafische Oberfläche des Emulators) startet, bleibt das kleine Display schwarz. Hier ist noch ein bisschen Arbeit nötig.

Folgende Befehle nacheinander in der Kommandozeile eingeben:

# git clone https://github.com/paul70078/rpi-fbcp.git
git clone https://github.com/tasanakorn/rpi-fbcp
mkdir -p rpi-fbcp/build
cd rpi-fbcp/build
cmake ..
make
sudo install fbcp /usr/local/bin/fbcp
cd ../..
rm -r -f rpi-fbcp

# git clone https://github.com/paul70078/rpi-fbcp.git

git clone https://github.com/tasanakorn/rpi-fbcp

mkdir -p rpi-fbcp/build

cd rpi-fbcp/build

cmake ..

make

sudo install fbcp /usr/local/bin/fbcp

cd ../..

rm -r -f rpi-fbcp

Nun ist der FrameBufferKopierer installiert. Einfach mal „fbcp&“ in die Konsole eingeben. Schon sollte auch der Emulator nun auf dem Display laufen. Leider muss man bei jedem Neustart fbcp& eingeben, was bei einem Gameboy-Clone ohne Tastatur nur schwer möglich ist.

Es wird einfach ein neues keines Skript angelegt mit

sudo nano /etc/init.d/RPi-Display

1	sudo nano /etc/init.d/RPi-Display

Inhalt des Skriptes ist

#!/bin/sh
### BEGIN INIT INFO
# Provides:          fbcp Framebuffercopy
# Required-Start:    
# Required-Stop:    
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Kurze Beschreibung
# Description:       Längere Bechreibung
### END INIT INFO
sudo fbcp &
# Actions
case "$1" in
    start)
        # START
        ;;
    stop)
        # STOP
        ;;
    restart)
        # RESTART
        ;;
esac

#!/bin/sh

### BEGIN INIT INFO

# Provides: fbcp Framebuffercopy

# Required-Start:

# Required-Stop:

# Default-Start: 2 3 4 5

# Default-Stop: 0 1 6

# Short-Description: Kurze Beschreibung

# Description: Längere Bechreibung

### END INIT INFO

sudo fbcp &

# Actions

case "$1" in

start)

# START

;;

stop)

# STOP

;;

restart)

# RESTART

;;

esac

Nun machen wir das neue Skript nach dem Speichern noch ausführbar mit

sudo chmod +x /etc/init.d/RPi-Display

1	sudo chmod +x /etc/init.d/RPi-Display

und fügen es der Gruppe und dem Besitzer „root“ zu

sudo chown root:root /etc/init.d/RPi-Display

1	sudo chown root:root /etc/init.d/RPi-Display

Damit unser kleines Skipt bei jedem Neustart ausgeführt wird, geben wir noch dieses in die Konsole ein

sudo update-rc.d RPi-Display defaults

1	sudo update-rc.d RPi-Display defaults

Nun sollte der Emulator auch bei jedem Neustart auf dem kleinen Display zu sehen sein.

Es kann sein, dass die Schrift im Emulator schwer zu lesen ist. Ein wenig Abhilfe könnte dies hier schaffen.

sudo nano /etc/emulationstation/themes/simple/simple.xml

1	sudo nano /etc/emulationstation/themes/simple/simple.xml

In dieser Datei runterscrollen bis zur „gamelist“ Sektion. Dort den Wert von „primaryColor“ auf 000000 ändern. Und dann noch die „fontSize“ von 0.03 auf 0.05 erhöhen.

Wer jetzt noch seine Buttons konfigurieren möchte, muss sich hier ein bisschen einlesen: https://learn.adafruit.com/retro-gaming-with-raspberry-pi/buttons Vermutlich muss das Programm „retrogame“ neu kompliert werden. Das ist aber nicht weiter schlimm und steht im eben genannten Link.

Nun noch die richtigen ROMs auf die Speicherkarte kopieren und schon kann der Spaß losgehen.

Wer nun noch einen kleinen WLAN Stick am Raspberry nutzen möchte, kann dies einfach machen. In „interfaces“ müssen nur die richtigen Daten eingetragen werden.

sudo nano /etc/network/interfaces

1	sudo nano /etc/network/interfaces

auto lo
iface lo inet loopback
iface eth0 inet dhcp
auto wlan0
allow-hotplug wlan0
iface wlan0 inet dhcp
wpa-ap-scan 1
wpa-scan-ssid 1
wpa-ssid "WLAN-NAME"
wpa-psk "WLAN-SCHLÜSSEL"

auto lo

iface lo inet loopback

iface eth0 inet dhcp

auto wlan0

allow-hotplug wlan0

iface wlan0 inet dhcp

wpa-ap-scan 1

wpa-scan-ssid 1

wpa-ssid "WLAN-NAME"

wpa-psk "WLAN-SCHLÜSSEL"

Bei meiner Bluetooth Tastatur hapert es noch ein wenig. Bisher schaffe ich es nicht, dass die Tastatur nach einem Neustart verwendet werden kann. Bisher habe ich folgendes versucht. http://elinux.org/RPi_Bluetooth_keyboard_setup

sudo apt-get install bluez python-gobject
hcitool scan
sudo echo 0000|sudo bluez-simple-agent hci0 AA:00:00:00:8A:F7
sudo bluez-test-device trusted AA:00:00:00:8A:F7 yes
sudo bluez-test-input connect AA:00:00:00:8A:F7 yes

sudo apt-get install bluez python-gobject

hcitool scan

sudo echo 0000|sudo bluez-simple-agent hci0 AA:00:00:00:8A:F7

sudo bluez-test-device trusted AA:00:00:00:8A:F7 yes

sudo bluez-test-input connect AA:00:00:00:8A:F7 yes

Den letzten Befehl muss ich immer erst manuell ausführen, damit die Bluetooth Tastatur verunden wird. Eigentlich sollte der vorletzte Befehl genau dieses erübrigen.

Hier noch unsortiert die Links, die ich bei der Einrichtung studiert habe:

http://www.forum-raspberrypi.de/Thread-gameboy-pi-a
http://www.forum-raspberrypi.de/Thread-bitte-um-hilfe-bei-display?page=3
https://github.com/notro/fbtft/wiki/Framebuffer-use#framebuffer-mirroring
https://learn.adafruit.com/running-opengl-based-games-and-emulators-on-adafruit-pitft-displays/adding-controls
http://seite360.de/2013/10/12/retroppie-schritt-fur-schritt-zur-retrogame-emulationstation-mit-dem-raspberry-pi/
https://github.com/watterott/RPi-Display/blob/master/docu/FAQ.md
http://elinux.org/RPiconfig

Make 3D printable Voronoi Patterns with Autodesk® Meshmixer

04.05.2015 Marcus Klütmann Prototypen

Gittermodelle mit Meshmixer erstellen.

Quelle: Make 3D printable Voronoi Patterns with Autodesk® Meshmixer

PiBoy Advanced remix #3DThursday #3DPrinting « Adafruit Industries – Makers, hackers, artists, designers and engineers!

30.04.2015 Marcus Klütmann Prototypen

Es mal wieder an der Zeit, an meinen ArcadePi zu basteln.

Da ich zuvor auch schon den GameBoy Nachbau fon Adafruit nachgebaut hatte, könnte ich auch mal das neue Modell testen.

Quelle: PiBoy Advanced remix #3DThursday #3DPrinting « Adafruit Industries – Makers, hackers, artists, designers and engineers!

You SLS – SLS 3D Drucker zum Nachbauen

29.04.2015 Marcus Klütmann Prototypen

Wer Lust und Zeit hat, kann sich seinen eigenen SLS 3D Drucker zusammenbauen. Lukas Hoppe hat angefangen dazu auf Instructables eine Anleitung zu schreiben.

You-SLS

18-year-old German student Lukas Hoppe has therefore spent the last year or so working on an open-source SLS 3D printer, and through a successful Indiegogo campaign, he now has the funds to complete and share his YOU-SLS machine.

Bei IndieGoGo hat Andreas auch eine Kampagne gestartet, um seine Maschine weiter zu verbessern, Einen 3D Drucker können die Unterstützer hierbei nicht erwerben. Es geht hier rein um Unterstützung bei der Entwicklung.

Insgesamt soll der SLS 3D Drucker an Material um die 2200 Euro kosten.

HPI forscht: Doktorandin Stefanie Müller beschleunigt 3D-Prototyping

27.04.2015 Marcus Klütmann Prototypen

Modelle in Wireframe umwandeln und dann materialsparend ausdrucken gibt es ja schon länger. Aber so wie es Stefanie Müller und Team vom HPI gemacht haben, ist e mir noch nicht unter die Augen gekommen.

Open / Close Clockwork Sign by Ikeda Yosuke – Homeli

26.04.2015 Marcus Klütmann Prototypen

Quelle: Open / Close Clockwork Sign by Ikeda Yosuke – Homeli

Sogar ohne 3D Drucker wäre das einfach herstellbar 🙂

Ein paar Testdrucke – Becher

12.02.2015 Marcus Klütmann Prototypen

Ich habe meine 0.8mm Düse für den 3D Drucker wieder eingebaut. Was kann man gut mit dieser Düse machen? Naja, auf Grund der dicken Wände lassen sich damit gut einwandige Modelle drucken.

Zuerst habe ich mit etwas ganz Einfachem angefangen. Ein Sechseck, das noch oben weiter wird. Mir war das dann zu langweilig.

Also habe ich hier und da ein bisschen am 3D Modell herumgezerrt und heraus kam dieses tassenähnlihce Gebilde. Der Zacken hinten hat mich an einen Henkel erinnert. Nur kann man diesen hier nicht wirklich anfassen, da sich der Zapfen nach oben verjüngt und die Finger daran abrutschen.

Gleich ein neuer Versuch. Der Henkel ist nun henkeliger geworden. Jedenfalls rutscht man nun nicht mehr daran ab.

Alle Becher sind 5 cm hoch und haben einen Grundduchmesser von ca 8 cm. Gedruckt wurden sie in PLA in 0,2 mm Schichthöhe… So wirklich einzelne Schichten im klassischen Sinne gibt es aber nicht. Der Vorteil von einwandingen Modellen ist, dass man diese auch spiralförmig von unten nach oben hochdrucken kann. Statt also nach einer Umrundung den Druckkopf um 0,2 mm anzuheben, wird nun kontinuierlich der Kopf angehoben, während der Druckkopf seine Kreise zieht. Dies zieht einen optischen Vorteil nach sich. Es entsteht keine Naht an der Stelle, wo der Kopf angehoben wird und eine neue Schicht entsteht.

Die Wandstärke liegt bei ungefähr 0,9 mm. Das gibt ein Objekt dieser Größe genügend Stabilität. Da eine Umrundung recht schnell abgefahren ist, hat das Material, gerade bei dieser Dicke, nicht genügend Zeit, abzukühlen und fest zu werden. Hier musste ich mit zwei Lüftern für einen ausreichenden kühlenden Luftstrom sorgen.

Was kann diese Düse nicht? Kleine Objekte drucken. Nicht nur weil die Düse zu groß wäre, denn dies spielt bei einem Kreis oder Viereck keine große Rolle, sondern weil viel Material aus der Düse herauskommt, das erst einmal abkühlen muss. Kleine Objekte können gar nicht langsam genug gedruckt werden, damit diese Wartezeit erreicht wird. Zudem überträgt die große Fläche der Düse auch sehr viel Wärme auf die darunter liegenden bereits verfestigten Schichten, so dass diese wieder weich werden.

Hier die STL Datei: http://community.shapedo.com/guin/simple_cup

Hundeblinklicht Version 6

02.02.2015 Marcus Klütmann Prototypen

Mit dem Programm für das Blinklicht bin ich soweit zufrieden. Das Gehäuse lässt aber weiterhin Platz für Verbesserungen. Vor allem die Größe soll reduziert werden. Dies ist mir über die verscheidenen Versionen auch schon sehr gut gelaungen. Gerade der Sprung vom Arduino Mino Pro zum ATtiny und verkleinertem Akku hat das Gehäuse sehr schrumpfen lassen.

Hundeblinklicht — Altes Gehäuse mit dem Arduino Mini und großem Akku.

Zuerst hatte ich einen Arduino Mini Pro als Hirn für das Blinklicht benutzt. Der Arduino war überdimensioniert für die einfache Blinkaufgabe und hat auch zu viel Energie verbraucht.

Ein kleiner ATtiny ist völlig ausreichend und lässt das Gehäuse als auch den Stromverbauch kleiner werden.

Durch den verkleinerten Stromverbraucht konnte auch der Akku stark verkleinert werden. Ich verwende nun einen 3,7V 110 mAH Lithium Akku. Im Blinkbetrieb hat dieser Akku ca 12 Stunden durchgehalten.

Viel kleiner bekomme ich das Gehäuse nun nicht mehr. Der hintere schmale Teil wird vom Akku ausgefüllt und vorne sitzen der ATiny mit den ganzen Kablen und auch der Taster.

Jetzt muss ich mir immer noch eine gute Möglichkeit einfallen lassen, das Gehäuse bequem am Hundegeschirr zu befestigen. Bisher klebe ich den Blinki einfach mit Tesafilm an oder klette ein Klettband herum.

Hundeblinklicht V5 – Nachtrag

21.01.2015 Marcus Klütmann Prototypen

Im letzten Code gab es ein paar Unstimmigkeiten. Beim Testen habe ich festgestellt, dass durch die Schaltung selbst im Power Down Modus immer noch etwas über 1 mA fließt. Der Grund dafür war ganz einfach. Statt in den Power Down Modus zu gehen, wurden einfach nur die LEDs ausgeschaltet. Von Außen macht das keinen Unterschied, aber der Stromverbraucht ist schon enorm unterschiedlich.

Den Code habe ich nun etwas geändert. Leider funktioniert mein Code nun nicht mehr mit dem ATTiny45. Statt dessen habe ich nun den ATTiny85 eingebaut. Der Stromverbrauch im Power Down Modus liegt nun bei 0,1 µA. Diesen Wert zeigt jedenfalls mein Messgerät an.

/*
  hundeblink
  @autor: Marcus Guin Kluetmann
 Für die Funktion des Buttons wurde das "Debounce" Beispiel 
  http://www.arduino.cc/en/Tutorial/Debounce
  created 21 November 2006
  by David A. Mellis
  modified 30 Aug 2011
  by Limor Fried
  modified 28 Dec 2012
  by Mike Walters
genutzt und angepasst.
Die Methode goToSleep wurde hier entliehen
    http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/
*/
#include <avr/sleep.h>
#include <avr/interrupt.h>
#define BODS 7                   //BOD Sleep bit in MCUCR
#define BODSE 2                  //BOD Sleep enable bit in MCUCR
 
uint8_t mcucr1, mcucr2;
int PWM1 = 0;  // PWM LED
int PWM2 = 1;  // PWM LED
int currentLED=0;
long lauflichtTimer;
int flashIntervall = 500; // Flash-Intervall
int flashdauer = 50;
int hell = 255; // Maximalhelligkeit der PWM LED
int dunkel = 2; // Minimalhelligkeit der PWM LED
int mittel = 5;// Mittlere Helligkeit nach dem Blitz für PWM LED
int buttonPin = 2;
int buttonState;             // the current reading from the input pin
int lastButtonState = LOW;   // the previous reading from the input pin
long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 250;    // the debounce time; increase if the output flickers
int ledState = 0;  

ISR(INT0_vect) {  
}
 
void goToSleep(void) {
    GIMSK |= _BV(INT0);                    //enable INT0
    MCUCR &= ~(_BV(ISC01) | _BV(ISC00));   //INT0 on low level
    ACSR |= _BV(ACD);                         //disable the analog comparator
    ADCSRA &= ~_BV(ADEN);                     //disable ADC
    set_sleep_mode(SLEEP_MODE_PWR_DOWN);
    sleep_enable();
    //turn off the brown-out detector.
    //must have an ATtiny45 or ATtiny85 rev C or later for software to be able to disable the BOD.
    //current while sleeping will be <0.5uA if BOD is disabled, <25uA if not.
    cli();
    mcucr1 = MCUCR | _BV(BODS) | _BV(BODSE);  //turn off the brown-out detector
    mcucr2 = mcucr1 & ~_BV(BODSE);
    MCUCR = mcucr1;
    MCUCR = mcucr2;
    sei();                         //ensure interrupts enabled so we can wake up again
    sleep_cpu();                   //go to sleep
    cli();                         //wake up here, disable interrupts
    GIMSK = 0x00;               //disable INT0
    sleep_disable();               
    sei();   //enable interrupts again (but INT0 is disabled from above)
}

 
void setup() {
  pinMode(buttonPin, INPUT_PULLUP); // interner PullUp Widerstand wird genutzt.
  pinMode(PWM1, OUTPUT);
  pinMode(PWM2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  lauflichtTimer = millis();
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
}
 
void loop() {
    // read the state of the switch into a local variable:
  int reading = digitalRead(buttonPin);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH),  and you've waited
  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (reading != lastButtonState) {
    // reset the debouncing timer
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != buttonState) {
      buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (buttonState == HIGH) {
        ledState++; // = !ledState;
        //if(ledState>3) ledState=0;
        //off(); // beim Statuswechsel werden alle LEDs ausgeschaltet.
      }
    }
  }

  // set the LED-Mode
  if (ledState==1) lauflicht();
  else if(ledState==2) dauerLicht();
  else if(ledState==3) { off();goToSleep();ledState=1;lauflicht();}
  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState:
  lastButtonState = reading; 
  
}

// Beim Umschalten zwischen den Modi sollen die LED alle abgeschaltet werden.
void off(){
  digitalWrite(PWM1, LOW);
  digitalWrite(PWM2, LOW);
}

// Nur eine LED soll im Dauerbetrieb schwach leuchten
void dauerLicht(){
  analogWrite(PWM2, mittel); 
  analogWrite(PWM1, mittel);  
}

// Lässt die LEDs in der Reihenfolge, die im Array angegeben ist, für "flashdauer" 
// mit der Intensität "hell" nacheinander aufleuchten.
// in der restlichen Zeit leuchten die LEDs mit der Intensität "dunkel"
void lauflicht() {
  long time = millis();
  int array[8] = {PWM1, PWM2}; 
  int anzahlLEDinArray = 2; // hier die Anzahl der Array-Elemente eintragen
  if(time-lauflichtTimer>currentLED*flashIntervall            && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){
    analogWrite(array[currentLED], hell);}
  if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){
    analogWrite(array[currentLED++], dunkel);}
  if(time-lauflichtTimer>anzahlLEDinArray*flashIntervall){lauflichtTimer=millis();currentLED=0;}  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

hundeblink

@autor: Marcus Guin Kluetmann

Für die Funktion des Buttons wurde das "Debounce" Beispiel

http://www.arduino.cc/en/Tutorial/Debounce

created 21 November 2006

by David A. Mellis

modified 30 Aug 2011

by Limor Fried

modified 28 Dec 2012

by Mike Walters

genutzt und angepasst.

Die Methode goToSleep wurde hier entliehen

http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/

#include <avr/sleep.h>

#include <avr/interrupt.h>

#define BODS 7 //BOD Sleep bit in MCUCR

#define BODSE 2 //BOD Sleep enable bit in MCUCR

uint8_t mcucr1, mcucr2;

int PWM1 = 0; // PWM LED

int PWM2 = 1; // PWM LED

int currentLED=0;

long lauflichtTimer;

int flashIntervall = 500; // Flash-Intervall

int flashdauer = 50;

int hell = 255; // Maximalhelligkeit der PWM LED

int dunkel = 2; // Minimalhelligkeit der PWM LED

int mittel = 5;// Mittlere Helligkeit nach dem Blitz für PWM LED

int buttonPin = 2;

int buttonState; // the current reading from the input pin

int lastButtonState = LOW; // the previous reading from the input pin

long lastDebounceTime = 0; // the last time the output pin was toggled

long debounceDelay = 250; // the debounce time; increase if the output flickers

int ledState = 0;

ISR(INT0_vect) {

}

void goToSleep(void) {

GIMSK |= _BV(INT0); //enable INT0

MCUCR &= ~(_BV(ISC01) | _BV(ISC00)); //INT0 on low level

ACSR |= _BV(ACD); //disable the analog comparator

ADCSRA &= ~_BV(ADEN); //disable ADC

set_sleep_mode(SLEEP_MODE_PWR_DOWN);

sleep_enable();

//turn off the brown-out detector.

//must have an ATtiny45 or ATtiny85 rev C or later for software to be able to disable the BOD.

//current while sleeping will be <0.5uA if BOD is disabled, <25uA if not.

cli();

mcucr1 = MCUCR | _BV(BODS) | _BV(BODSE); //turn off the brown-out detector

mcucr2 = mcucr1 & ~_BV(BODSE);

MCUCR = mcucr1;

MCUCR = mcucr2;

sei(); //ensure interrupts enabled so we can wake up again

sleep_cpu(); //go to sleep

cli(); //wake up here, disable interrupts

GIMSK = 0x00; //disable INT0

sleep_disable();

sei(); //enable interrupts again (but INT0 is disabled from above)

}

void setup() {

pinMode(buttonPin, INPUT_PULLUP); // interner PullUp Widerstand wird genutzt.

pinMode(PWM1, OUTPUT);

pinMode(PWM2, OUTPUT);

pinMode(3, OUTPUT);

pinMode(4, OUTPUT);

lauflichtTimer = millis();

digitalWrite(3, LOW);

digitalWrite(4, LOW);

}

void loop() {

// read the state of the switch into a local variable:

int reading = digitalRead(buttonPin);

// check to see if you just pressed the button

// (i.e. the input went from LOW to HIGH), and you've waited

// long enough since the last press to ignore any noise:

// If the switch changed, due to noise or pressing:

if (reading != lastButtonState) {

// reset the debouncing timer

lastDebounceTime = millis();

}

if ((millis() - lastDebounceTime) > debounceDelay) {

// whatever the reading is at, it's been there for longer

// than the debounce delay, so take it as the actual current state:

// if the button state has changed:

if (reading != buttonState) {

buttonState = reading;

// only toggle the LED if the new button state is HIGH

if (buttonState == HIGH) {

ledState++; // = !ledState;

//if(ledState>3) ledState=0;

//off(); // beim Statuswechsel werden alle LEDs ausgeschaltet.

}

// set the LED-Mode

if (ledState==1) lauflicht();

else if(ledState==2) dauerLicht();

else if(ledState==3) { off();goToSleep();ledState=1;lauflicht();}

// save the reading. Next time through the loop,

// it'll be the lastButtonState:

lastButtonState = reading;

}

// Beim Umschalten zwischen den Modi sollen die LED alle abgeschaltet werden.

void off(){

digitalWrite(PWM1, LOW);

digitalWrite(PWM2, LOW);

}

// Nur eine LED soll im Dauerbetrieb schwach leuchten

void dauerLicht(){

analogWrite(PWM2, mittel);

analogWrite(PWM1, mittel);

}

// Lässt die LEDs in der Reihenfolge, die im Array angegeben ist, für "flashdauer"

// mit der Intensität "hell" nacheinander aufleuchten.

// in der restlichen Zeit leuchten die LEDs mit der Intensität "dunkel"

void lauflicht() {

long time = millis();

int array[8] = {PWM1, PWM2};

int anzahlLEDinArray = 2; // hier die Anzahl der Array-Elemente eintragen

if(time-lauflichtTimer>currentLED*flashIntervall && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){

analogWrite(array[currentLED], hell);}

if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){

analogWrite(array[currentLED++], dunkel);}

if(time-lauflichtTimer>anzahlLEDinArray*flashIntervall){lauflichtTimer=millis();currentLED=0;}

}

Die Stromsparfunktion müsste eigentlich auch mit dem ATTiny45 funktionieren. Vielleicht finde ich noch heraus, was da schief läuft.

Hundeblinklicht, Version 5 – es wird Tiny

20.01.2015 Marcus Klütmann News, Prototypen

Der kleine Arduino, den ich bisher in den Hundeblinklichtern verbaut habe, war einfach zu groß und auch zu teuer. Ein kleiner ATTiny45 reicht für das bisschen Blinken völlig aus. Man könnte die Funktion natürlich auch als diskrete Schaltung aufbauen. Nachteil ist nur, dass diese Schaltung mit meinen hier vorhandenen Bauteilen alles andere als stromsparend ist. Der kleine ATTiny hingegen ist im Betrieb schon stromsparend und kann sogar noch in einen Schlafmodus versetzt werden. Somit erspare ich mir einen Schalter, mit dem ich die Stromzufuhr unterbechen muss. Der bereits vorhandene Taster schaltet nun zwischen den verschiedenen Modi durch. 1. Blinkmodus mit sehr hellen Blinkimpulsen. 2. Dauerlicht, das nicht ganz so hell ist, damit es nicht blendet. 3. Aus: der ATTiny wird in den Schlafmodus versetzt. Im Schlafmodus soll der Stromverbrauch so gering sein, so dass der verwendete Akku sehr lange hält. Laut dieser Seite http://www.mikrocontroller.net/articles/Sleep_Mode#Power_Down_Mode fließen nur um die 0,3 µA. Mein Messgerät zeigt in diesem Modus allerdings immer noch 1 mA an. Leider bin ich mir auch nicht so ganz sicher, ob ich den ATTiny richtig programmiert habe. Die Funktion für den Schlafmodus (Methode goToSleep)habe ich aus dieser Seite entnommen: http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf
Vielleicht mache ich da was falsch. Viel Ahnung habe ich noch nicht.

Blinklicht für Hunde — Links Version 4, Rechts Version 5

/*
 hundeblink
 @autor: Marcus Guin Kluetmann
 Für die Funktion des Buttons wurde das "Debounce" Beispiel 
 http://www.arduino.cc/en/Tutorial/Debounce
 created 21 November 2006
 by David A. Mellis
 modified 30 Aug 2011
 by Limor Fried
 modified 28 Dec 2012
 by Mike Walters
genutzt und angepasst.
Die Methode goToSleep wurde hier entliehen
 http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/
*/
#include <avr/sleep.h>
#include <avr/interrupt.h>
#define BODS 7 //BOD Sleep bit in MCUCR
#define BODSE 2 //BOD Sleep enable bit in MCUCR
 
uint8_t mcucr1, mcucr2;
int PWM1 = 0; // PWM LED
int PWM2 = 1; // PWM LED
int currentLED=0;
long lauflichtTimer;
int flashIntervall = 500; // Flash-Intervall
int flashdauer = 50;
int hell = 255; // Maximalhelligkeit der PWM LED
int dunkel = 2; // Minimalhelligkeit der PWM LED
int mittel = 10;// Mittlere Helligkeit nach dem Blitz für PWM LED
int buttonPin = 2;
int buttonState; // the current reading from the input pin
int lastButtonState = LOW; // the previous reading from the input pin
long lastDebounceTime = 0; // the last time the output pin was toggled
long debounceDelay = 250; // the debounce time; increase if the output flickers
int ledState = 0; 

 
void goToSleep(void) {
 //GICR |= (1 << INT0); // externen Interrupt freigeben
 GIMSK |= _BV(INT0); //enable INT0
 MCUCR &= ~(_BV(ISC01) | _BV(ISC00)); //INT0 on low level
 ACSR |= _BV(ACD); //disable the analog comparator
 ADCSRA &= ~_BV(ADEN); //disable ADC
 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
 sleep_enable();
 //turn off the brown-out detector.
 //must have an ATtiny45 or ATtiny85 rev C or later for software to be able to disable the BOD.
 //current while sleeping will be ~0.5uA if BOD is disabled, ~25uA if not.
 cli();
 mcucr1 = MCUCR | _BV(BODS) | _BV(BODSE); //turn off the brown-out detector
 mcucr2 = mcucr1 & ~_BV(BODSE);
 MCUCR = mcucr1;
 MCUCR = mcucr2;
 sei(); //ensure interrupts enabled so we can wake up again
 sleep_cpu(); //go to sleep
 cli(); //wake up here, disable interrupts
 GIMSK = 0x00; //disable INT0
 sleep_disable(); 
 sei(); //enable interrupts again (but INT0 is disabled from above)
}

 
void setup() {
 pinMode(buttonPin, INPUT_PULLUP); // interner PullUp Widerstand wird genutzt.
 pinMode(PWM1, OUTPUT);
 pinMode(PWM2, OUTPUT);
 lauflichtTimer = millis();
}
 
void loop() {
 // read the state of the switch into a local variable:
 int reading = digitalRead(buttonPin);

 // check to see if you just pressed the button
 // (i.e. the input went from LOW to HIGH), and you've waited
 // long enough since the last press to ignore any noise:

 // If the switch changed, due to noise or pressing:
 if (reading != lastButtonState) {
 // reset the debouncing timer
 lastDebounceTime = millis();
 }

 if ((millis() - lastDebounceTime) > debounceDelay) {
 // whatever the reading is at, it's been there for longer
 // than the debounce delay, so take it as the actual current state:

 // if the button state has changed:
 if (reading != buttonState) {
 buttonState = reading;

 // only toggle the LED if the new button state is HIGH
 if (buttonState == HIGH) {
 ledState++; // = !ledState;
 if(ledState>=3) ledState=0;
 off(); // beim Statuswechsel werden alle LEDs ausgeschaltet.
 }
 }
 }

 // set the LED-Mode
 if (ledState==1) lauflicht();
 else if(ledState==2) dauerLicht();
 else if(ledState==3) goToSleep();
 // save the reading. Next time through the loop,
 // it'll be the lastButtonState:
 lastButtonState = reading; 
 
}

// Beim Umschalten zwischen den Modi sollen die LED alle abgeschaltet werden.
void off(){
 digitalWrite(PWM1, LOW);
 digitalWrite(PWM2, LOW);
}

// Nur eine LED soll im Dauerbetrieb schwach leuchten
void dauerLicht(){
 analogWrite(PWM2, 5); 
 analogWrite(PWM1, 5); 
}

// Lässt die LEDs in der Reihenfolge, die im Array angegeben ist, für "flashdauer" 
// mit der Intensität "hell" nacheinander aufleuchten.
// in der restlichen Zeit leuchten die LEDs mit der Intensität "dunkel"
void lauflicht() {
 long time = millis();
 int array[8] = {PWM1, PWM2}; 
 int anzahlLEDinArray = 2; // hier die Anzahl der Array-Elemente eintragen
 if(time-lauflichtTimer>currentLED*flashIntervall && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){
 analogWrite(array[currentLED], hell);}
 if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){
 analogWrite(array[currentLED++], dunkel);}
 if(time-lauflichtTimer>anzahlLEDinArray*flashIntervall){lauflichtTimer=millis();currentLED=0;} 
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

hundeblink

@autor: Marcus Guin Kluetmann

Für die Funktion des Buttons wurde das "Debounce" Beispiel

http://www.arduino.cc/en/Tutorial/Debounce

created 21 November 2006

by David A. Mellis

modified 30 Aug 2011

by Limor Fried

modified 28 Dec 2012

by Mike Walters

genutzt und angepasst.

Die Methode goToSleep wurde hier entliehen

http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/

#include <avr/sleep.h>

#include <avr/interrupt.h>

#define BODS 7 //BOD Sleep bit in MCUCR

#define BODSE 2 //BOD Sleep enable bit in MCUCR

uint8_t mcucr1, mcucr2;

int PWM1 = 0; // PWM LED

int PWM2 = 1; // PWM LED

int currentLED=0;

long lauflichtTimer;

int flashIntervall = 500; // Flash-Intervall

int flashdauer = 50;

int hell = 255; // Maximalhelligkeit der PWM LED

int dunkel = 2; // Minimalhelligkeit der PWM LED

int mittel = 10;// Mittlere Helligkeit nach dem Blitz für PWM LED

int buttonPin = 2;

int buttonState; // the current reading from the input pin

int lastButtonState = LOW; // the previous reading from the input pin

long lastDebounceTime = 0; // the last time the output pin was toggled

long debounceDelay = 250; // the debounce time; increase if the output flickers

int ledState = 0;

void goToSleep(void) {

//GICR |= (1 << INT0); // externen Interrupt freigeben

GIMSK |= _BV(INT0); //enable INT0

MCUCR &= ~(_BV(ISC01) | _BV(ISC00)); //INT0 on low level

ACSR |= _BV(ACD); //disable the analog comparator

ADCSRA &= ~_BV(ADEN); //disable ADC

set_sleep_mode(SLEEP_MODE_PWR_DOWN);

sleep_enable();

//turn off the brown-out detector.

//must have an ATtiny45 or ATtiny85 rev C or later for software to be able to disable the BOD.

//current while sleeping will be ~0.5uA if BOD is disabled, ~25uA if not.

cli();

mcucr1 = MCUCR | _BV(BODS) | _BV(BODSE); //turn off the brown-out detector

mcucr2 = mcucr1 & ~_BV(BODSE);

MCUCR = mcucr1;

MCUCR = mcucr2;

sei(); //ensure interrupts enabled so we can wake up again

sleep_cpu(); //go to sleep

cli(); //wake up here, disable interrupts

GIMSK = 0x00; //disable INT0

sleep_disable();

sei(); //enable interrupts again (but INT0 is disabled from above)

}

void setup() {

pinMode(buttonPin, INPUT_PULLUP); // interner PullUp Widerstand wird genutzt.

pinMode(PWM1, OUTPUT);

pinMode(PWM2, OUTPUT);

lauflichtTimer = millis();

}

void loop() {

// read the state of the switch into a local variable:

int reading = digitalRead(buttonPin);

// check to see if you just pressed the button

// (i.e. the input went from LOW to HIGH), and you've waited

// long enough since the last press to ignore any noise:

// If the switch changed, due to noise or pressing:

if (reading != lastButtonState) {

// reset the debouncing timer

lastDebounceTime = millis();

}

if ((millis() - lastDebounceTime) > debounceDelay) {

// whatever the reading is at, it's been there for longer

// than the debounce delay, so take it as the actual current state:

// if the button state has changed:

if (reading != buttonState) {

buttonState = reading;

// only toggle the LED if the new button state is HIGH

if (buttonState == HIGH) {

ledState++; // = !ledState;

if(ledState>=3) ledState=0;

off(); // beim Statuswechsel werden alle LEDs ausgeschaltet.

}

// set the LED-Mode

if (ledState==1) lauflicht();

else if(ledState==2) dauerLicht();

else if(ledState==3) goToSleep();

// save the reading. Next time through the loop,

// it'll be the lastButtonState:

lastButtonState = reading;

}

// Beim Umschalten zwischen den Modi sollen die LED alle abgeschaltet werden.

void off(){

digitalWrite(PWM1, LOW);

digitalWrite(PWM2, LOW);

}

// Nur eine LED soll im Dauerbetrieb schwach leuchten

void dauerLicht(){

analogWrite(PWM2, 5);

analogWrite(PWM1, 5);

}

// Lässt die LEDs in der Reihenfolge, die im Array angegeben ist, für "flashdauer"

// mit der Intensität "hell" nacheinander aufleuchten.

// in der restlichen Zeit leuchten die LEDs mit der Intensität "dunkel"

void lauflicht() {

long time = millis();

int array[8] = {PWM1, PWM2};

int anzahlLEDinArray = 2; // hier die Anzahl der Array-Elemente eintragen

if(time-lauflichtTimer>currentLED*flashIntervall && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){

analogWrite(array[currentLED], hell);}

if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){

analogWrite(array[currentLED++], dunkel);}

if(time-lauflichtTimer>anzahlLEDinArray*flashIntervall){lauflichtTimer=millis();currentLED=0;}

}

Ich bin aber schon mal froh, dass der Schalter nun weg ist. Dieser war schwierig vor Wasser zu schützen.

Der Tester liegt im Innern des Gehäuses und kann duch Eindrücken des Gehäusedeckels (0,4 mm dickes Nylon) betätigt werden.

Die seitlichen Arme habe ich nun auch wieder durch einen fertigen Schlauch ersetzt. Viel stabiler und transparenter. Es sind noch Pins am ATTiny frei. Da könnte ich noch eine Akkuanzeige einbauen. Wenn die Spannung des Akkus auf einen bestimmten Wert absinkt, fängt eine rote LED an zu blinken.

Kategorie: Prototypen

Ein GPIO Display am Raspberry konfigurieren und andere Sachen

Make 3D printable Voronoi Patterns with Autodesk® Meshmixer

PiBoy Advanced remix #3DThursday #3DPrinting « Adafruit Industries – Makers, hackers, artists, designers and engineers!

You SLS – SLS 3D Drucker zum Nachbauen

HPI forscht: Doktorandin Stefanie Müller beschleunigt 3D-Prototyping

Open / Close Clockwork Sign by Ikeda Yosuke – Homeli

Ein paar Testdrucke – Becher

Hundeblinklicht Version 6

Hundeblinklicht V5 – Nachtrag

Hundeblinklicht, Version 5 – es wird Tiny

Neueste Beiträge

Archive

Kategorien

Social Media