Arduino Archive • FabMo - Nur ein Technik-Blog

Das muss ich auch mal nachbauen.

NodeMcu Lua ESP8266 ESP-12F WIFI

21.10.2017 Marcus Klütmann Prototypen

Arduino Clone

Bei Banggood gibt es gerade günstig einen Arduino Nano Clone mit WiFi Modul. Regulär weniger als 8 US Dollar. Vergünstigt jetzt gerade 3,99 US$ (bis 15. November 2017).

Arduino Nano Clone - Entwicklungsboard — NodeMcu Lua ESP8266 ESP-12F WIFI

Funktioniert das auch? Antwort: Ja. Die Boards, die bei mir angekommen sind, funktionieren auch. Man muss nur ein bisschen was vorbereiten, damit man mit den Boards auch arbeiten kann.

Treiber

Der günstige Preis kommt nicht daher, dass die Anbieter so menschenfreundlich sind. Es werden günstige und gut verfügbare Komponenten benutzt. Unter anderem ist für die serielle Kommunikation ein CH340 verbaut. Arduino nutzt meistens Serielle to TTL Chips von FTDI. Vorteil, es wird besser bereits ab Window 7 unterstützt. Bei Windows 10 muss man für den CH340 keine Treiber installieren. Für ältere Windows Versionen schon. Den Treiber gibt es hier: http://en.doit.am/CH341SER.zip

Arduino IDE

Die Arduino IDE (1.8) muss auch noch vorbereitet werden. Das ist bei allen Bords so, die nicht direkt von Arduino sind. Starte die Arduino IDE und unter Datei/Voreinstellungen gibt es ein Feld “Zusätzliche Boardverwalter-URLs:”. Dort muss folgedes eingetragen werden

http://arduino.esp8266.com/stable/package_esp8266com_index.json

Sollte bereits ein Link in dem Feld stehen, kann man weitere Links durch ein Komma getrennt anfügen. Oder man klickt auf den kleinen Button rechts von dem Feld. In dem neuen Fenster kann man einzelne Links in eine separate Zeile schreiben.

Die Voreinstellungen werden nun noch mit dem OK Button geschlossen und die Arduino IDE einmal neu gestartet.

Ganz oben in der Liste unter “Werkzeuge/Board:” gibt es den “Boardverwalter”. Dort bitte einmal drauf klicken. Es öffnet sich ein neues Fenster “Boardverwalter”. In dem Suchfeld “esp8266” eingeben. Es sollte dann ein Ergebnis “esp8266 by ESP8266 Community” angezeigt werden. Dieses Paket muss einmal installiert werden.

Unter Werkzeuge/Board: gibt es nun eine Sektion mit “ESP8266 Modules”. Für mein Board musste ich hier “NodeMCU 1.0 (ESP12-E Module)” auswählen. Jetzt nur noch den richtigen COM Port auswählen und man kann seine Programme auf das Board laden.

ATtiny85 Ring Watch

19.02.2016 Marcus Klütmann 3D Drucker, Prototypen

Eigentlich total hässlich, aber die Idee finde ich toll.

Base on the previous Instructables – ATtiny Watch Core and more, I have made a real gadget, an ATtiny85 Ring Watch.

Quelle: ATtiny85 Ring Watch

Das elektronische Schaf

18.12.2015 Marcus Klütmann Prototypen

Lange ist es her, seit ich mich um das elektronische Schaf gekümmert habe. Mit dem Unterboden war ich nicht wirklich zufrieden. Nun habe ich mich endlich mal an einen neuen Versuch gewagt.

links: neue Version, rechts: alte Version

Die Motoren sind nun um 5° nach unten geneigt. Das ergibt ein bisschen mehr Bodenfreiheit und die Drehungen sollten ein bisschen leichter gehen. Eine 10° Neigung müsste ich auch noch mal ausprobieren.

Da der Raum für den Motor zu eng war, ist beim Eindrücken des Motors das Gehäuse ein bisschen aufgeplatz (links zu sehen). Die Layerhafung ist bei diesem Versuch auch nicht so ganz gut. Gedruckt habe ich mit ABS.

Dafür war die Haftung am Druckbett zu gut.

Obwohl die Maße 170 mm x 128 mm betragen hat sich keine einzige Ecke des Modells vom Druckbett abgehoben. Leider haftete das Modell auch nach dem Abkühlen noch so stark am Druckbett, dass ich es nur mit Mühe runterbrechen konnte. Vor dem Drucken kippe ich ein wenig Aceton (Achtung gut lüften!) auf das Druckbett und schwenke ein paar mal etwas ABS darin herum. Das ABS löst sich im Aceton etwas auf und klebt dann nach dem Trocknen am Druckbett fest. Die Schicht ist dabei kaum zu sehen, aber es reicht vollkommen aus, um als Haftgrund zu dienen.

Ich werde nachher noch mal einen Druck starten. Mit veränderter Motoraufnahme (etwas weiter), dickeren Wänden (2mm auf 4 mm) und leicht erhöhter Drucktemperatur (234°C auf 237°C). Druckzeit ca. 6 Stunden.

DEFCON 1 – Bitte nicht stören

16.08.2015 Marcus Klütmann 3D Drucker, News

DEFCON oder auch Verteidigunsbereitschaftszustand spielt nicht nur beim Militär eine Rolle.

Auf der Arbeit ist es völlig normal, dass man immer mal wieder mit seinen Kollegen kommunizieren “muss”. Klar gibt es Firmen, in denen jeder isoliert für sich arbeitet. Dort ist die Kommunikation untereinander auf das nötigste beschränkt. “Nicht optionale gesellschaftliche Konventionen”, wie es Sheldon in The Big Bang Theory nennt.

Der normale Alltag besteht aber eher darin, dass man sich selber immer mal wieder an Kollegen wendet, um Informationen (Feedback, Lösungen, etc.) zu erhalten oder eben Kollegen kommen zu einem selber und haben Fragen.

Soweit kein Problem. Selbst “Tratschen” fördert die Produktivität. Dabei geht es nicht darum, dass man Gerüchte in die Welt setzt, sondern dass man einfach mal seinen Platz verlässt und sozial mit anderen interagiert. Laut Bildschirmarbeitsverordnung ist eine regelmäßige Abwechslung bei Bildschirmarbeiten sogar vorgesehen. Diese Abwechslung macht den Kopf wieder frei und entspannt. Die Arbeit fällt dann wieder etwas leichter.

Wenn dann aber mal Stress aufkommt oder man sich auf eine komplizierte Aufgabe konzentrieren möchte, sind Störungen eher unwillkommen. Gerade bei komplizierten Aufgaben kostet jede Störung viel Zeit. Nur woher sollen die Kollegen wissen, dass man selber gerade nicht gestört werden möchte? Man kann ein Fähnchen an den Monitor klemmen. Das wäre eine simple und effektive Möglichkeit. Man muss die Fähnchen nur einmal den Kollegen mitteilen.

Mir gefallen technische Spielerein. In Anlehung an das DEFCON der USA habe ich eine 5 farbige Ampel gebaut. Dazu dann noch 3 Taster. Ein Taster, um die Gefahrenstufe zu erhöhen, der zweite, um die Gefahrenstufe zu senken und der dritte Taster schaltet die Ampel in den stromsparmodus (Akkubetrieb oder USB möglich) oder weckt die Ampel eben aus diesem.

Das Gehäuse ist nur ein erster Test. Es hat sich gleich herausgestellt, dass die Tasten am besten von oben drückbar sein sollte. So von der Seite gedrückt fällt der 20 cm hohe Turm zu leicht um.

Das Ganze wird über einen kleinen Arduino Mini Pro gesteuert. Hier ist der Sketch:

#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;
volatile int sleepMode = 0;

int R = 7;            
int G = 3;            
int B = 4;           
int O = 5;             
int W = 6;       

int power = 2;
int up = 8;
int down = 9;


long debounceDelay = 20;    // the debounce time; increase if the output flickers
uint8_t ledState = 0;  

uint8_t buttonStateUp;             // the current reading from the input pin
uint8_t lastButtonStateUp = LOW;   // the previous reading from the input pin
long lastDebounceTimeUp = 0;  // the last time the output pin was toggled
int readingUp;
long timerUp;

uint8_t buttonStateDown;             // the current reading from the input pin
uint8_t lastButtonStateDown = LOW;   // the previous reading from the input pin
long lastDebounceTimeDown = 0;  // the last time the output pin was toggled
int readingDown;
long timerDown;

long debounceDelayPower = 200;    // the debounce time; increase if the output flickers
uint8_t buttonStatePower;             // the current reading from the input pin
uint8_t lastButtonStatePower = LOW;   // the previous reading from the input pin
long lastDebounceTimePower = 0;  // the last time the output pin was toggled
int readingPower;
long timerPower;

void pin2_isr()
{
  sleep_disable();
  detachInterrupt(0);
  //pin2_interrupt_flag = 1;
  sleepMode=0;
  Serial.print("Wake: sleepMode= ");
  Serial.println(sleepMode);
  while(!digitalRead(power));
}

/*ISR(INT0_vect) { 
  if(!digitalRead(power)){ 
    sleepMode = 0;
    while(!digitalRead(power)); // solange in der Schleife bleiben, bis der Taster losgelassen wird.
  }
}*/

void setup()
{
  Serial.begin(9600);
  pinMode(R, OUTPUT);     
  pinMode(G, OUTPUT);    
  pinMode(B, OUTPUT);    
  pinMode(O, OUTPUT);      
  pinMode(W, OUTPUT);  
       
  pinMode(power, INPUT_PULLUP);       
  pinMode(up, INPUT_PULLUP);       
  pinMode(down, INPUT_PULLUP);  
  
  digitalWrite(R, HIGH); 
  digitalWrite(G, HIGH); 
  digitalWrite(B, HIGH);   
  digitalWrite(O, HIGH);   
  digitalWrite(W, HIGH);    

  attachInterrupt(0, pin2_isr, LOW);

  sleepMode=0;
  
}

void loop()
{
  // read the state of the switch into a local variable:
  readingUp = digitalRead(up);
  readingDown = digitalRead(down);
  readingPower = digitalRead(power);
  if (readingUp != lastButtonStateUp) {
    lastDebounceTimeUp = millis();
  } 
  else
    if ((millis() - lastDebounceTimeUp) > debounceDelay) {
      if (readingUp != buttonStateUp) {
        buttonStateUp = readingUp;
        if (buttonStateUp == HIGH) {
          timerUp = millis();
          ledState++; // = !ledState;
          if(ledState == 6 ) ledState=1;
        } 
      }
    }
  if (readingDown != lastButtonStateDown) {
    lastDebounceTimeDown = millis();
  }
  else
    if ((millis() - lastDebounceTimeDown) > debounceDelay) {
      if (readingDown != buttonStateDown) {
        buttonStateDown = readingDown;
        if (buttonStateDown == HIGH) {
          timerDown = millis();
          ledState--; // = !ledState;
          if(ledState == 0 ) ledState=5;
        } 
      }
    }
  if (readingPower != lastButtonStatePower) {
    lastDebounceTimePower = millis();
  }
  else
    if ((millis() - lastDebounceTimePower) > debounceDelayPower) {
      if (readingPower != buttonStatePower) {
        buttonStatePower = readingPower;
        if (buttonStatePower == HIGH) {
          timerPower = millis();
          sleepMode=1; // = !ledState;
        } 
      }
    }


switch(ledState){
  case 1:        
  digitalWrite(R, LOW);     
  digitalWrite(G, HIGH);    
  digitalWrite(O, HIGH);     
  digitalWrite(B, HIGH);     
  digitalWrite(W, HIGH);    
  break;
  case 2:  
  digitalWrite(R, HIGH);     
  digitalWrite(G, LOW);      
  digitalWrite(O, HIGH);     
  digitalWrite(B, HIGH);    
  digitalWrite(W, HIGH);    
  break;
  case 3:  
  digitalWrite(R, HIGH);     
  digitalWrite(G, HIGH);     
  digitalWrite(B, LOW);    
  digitalWrite(O, HIGH);     
  digitalWrite(W, HIGH);     
  break;
  case 4:  
  digitalWrite(R, HIGH);     
  digitalWrite(G, HIGH);    
  digitalWrite(B, HIGH);     
  digitalWrite(O, LOW);     
  digitalWrite(W, HIGH);    
  break;
  case 5: 
  digitalWrite(R, HIGH);     
  digitalWrite(G, HIGH);     
  digitalWrite(B, HIGH);      
  digitalWrite(O, HIGH);   
  digitalWrite(W, LOW);    
  break;   
  case 6:
  sleepMode=1;
  Serial.print("Switch: sleepMode= ");
  Serial.println(sleepMode);
  break;
  }   

  while(sleepMode==1){
    
    digitalWrite(R, HIGH);     
    digitalWrite(G, HIGH);     
    digitalWrite(B, HIGH);      
    digitalWrite(O, HIGH);   
    digitalWrite(W, HIGH); 
    attachInterrupt(0, pin2_isr, LOW);
    delay(100);
    goToSleep();
    
  Serial.print("While: sleepMode= ");
  Serial.println(sleepMode);
  }
  sleepMode=0;   
  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState:
  lastButtonStateUp = readingUp; 
  lastButtonStateDown = readingDown; 
  lastButtonStatePower = readingPower; 
}



 
void goToSleep(void) {
  sleep_enable();
  attachInterrupt(0, pin2_isr, LOW);
  /* 0, 1, or many lines of code here */
  set_sleep_mode(SLEEP_MODE_PWR_DOWN);
  cli();
  sleep_bod_disable();
  sei();
  sleep_cpu();
  /* wake up here */
  sleep_disable();
  
  /*
    //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)
    */
}

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

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

#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;

volatile int sleepMode = 0;

int R = 7;

int G = 3;

int B = 4;

int O = 5;

int W = 6;

int power = 2;

int up = 8;

int down = 9;

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

uint8_t ledState = 0;

uint8_t buttonStateUp; // the current reading from the input pin

uint8_t lastButtonStateUp = LOW; // the previous reading from the input pin

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

int readingUp;

long timerUp;

uint8_t buttonStateDown; // the current reading from the input pin

uint8_t lastButtonStateDown = LOW; // the previous reading from the input pin

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

int readingDown;

long timerDown;

long debounceDelayPower = 200; // the debounce time; increase if the output flickers

uint8_t buttonStatePower; // the current reading from the input pin

uint8_t lastButtonStatePower = LOW; // the previous reading from the input pin

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

int readingPower;

long timerPower;

void pin2_isr()

{

sleep_disable();

detachInterrupt(0);

//pin2_interrupt_flag = 1;

sleepMode=0;

Serial.print("Wake: sleepMode= ");

Serial.println(sleepMode);

while(!digitalRead(power));

}

/*ISR(INT0_vect) {

if(!digitalRead(power)){

sleepMode = 0;

while(!digitalRead(power)); // solange in der Schleife bleiben, bis der Taster losgelassen wird.

}

}*/

void setup()

{

Serial.begin(9600);

pinMode(R, OUTPUT);

pinMode(G, OUTPUT);

pinMode(B, OUTPUT);

pinMode(O, OUTPUT);

pinMode(W, OUTPUT);

pinMode(power, INPUT_PULLUP);

pinMode(up, INPUT_PULLUP);

pinMode(down, INPUT_PULLUP);

digitalWrite(R, HIGH);

digitalWrite(G, HIGH);

digitalWrite(B, HIGH);

digitalWrite(O, HIGH);

digitalWrite(W, HIGH);

attachInterrupt(0, pin2_isr, LOW);

sleepMode=0;

}

void loop()

{

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

readingUp = digitalRead(up);

readingDown = digitalRead(down);

readingPower = digitalRead(power);

if (readingUp != lastButtonStateUp) {

lastDebounceTimeUp = millis();

}

else

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

if (readingUp != buttonStateUp) {

buttonStateUp = readingUp;

if (buttonStateUp == HIGH) {

timerUp = millis();

ledState++; // = !ledState;

if(ledState == 6 ) ledState=1;

}

if (readingDown != lastButtonStateDown) {

lastDebounceTimeDown = millis();

}

else

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

if (readingDown != buttonStateDown) {

buttonStateDown = readingDown;

if (buttonStateDown == HIGH) {

timerDown = millis();

ledState--; // = !ledState;

if(ledState == 0 ) ledState=5;

}

if (readingPower != lastButtonStatePower) {

lastDebounceTimePower = millis();

}

else

if ((millis() - lastDebounceTimePower) > debounceDelayPower) {

if (readingPower != buttonStatePower) {

buttonStatePower = readingPower;

if (buttonStatePower == HIGH) {

timerPower = millis();

sleepMode=1; // = !ledState;

}

switch(ledState){

case 1:

digitalWrite(R, LOW);

digitalWrite(G, HIGH);

digitalWrite(O, HIGH);

digitalWrite(B, HIGH);

digitalWrite(W, HIGH);

break;

case 2:

digitalWrite(R, HIGH);

digitalWrite(G, LOW);

digitalWrite(O, HIGH);

digitalWrite(B, HIGH);

digitalWrite(W, HIGH);

break;

case 3:

digitalWrite(R, HIGH);

digitalWrite(G, HIGH);

digitalWrite(B, LOW);

digitalWrite(O, HIGH);

digitalWrite(W, HIGH);

break;

case 4:

digitalWrite(R, HIGH);

digitalWrite(G, HIGH);

digitalWrite(B, HIGH);

digitalWrite(O, LOW);

digitalWrite(W, HIGH);

break;

case 5:

digitalWrite(R, HIGH);

digitalWrite(G, HIGH);

digitalWrite(B, HIGH);

digitalWrite(O, HIGH);

digitalWrite(W, LOW);

break;

case 6:

sleepMode=1;

Serial.print("Switch: sleepMode= ");

Serial.println(sleepMode);

break;

}

while(sleepMode==1){

digitalWrite(R, HIGH);

digitalWrite(G, HIGH);

digitalWrite(B, HIGH);

digitalWrite(O, HIGH);

digitalWrite(W, HIGH);

attachInterrupt(0, pin2_isr, LOW);

delay(100);

goToSleep();

Serial.print("While: sleepMode= ");

Serial.println(sleepMode);

}

sleepMode=0;

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

// it'll be the lastButtonState:

lastButtonStateUp = readingUp;

lastButtonStateDown = readingDown;

lastButtonStatePower = readingPower;

}

void goToSleep(void) {

sleep_enable();

attachInterrupt(0, pin2_isr, LOW);

/* 0, 1, or many lines of code here */

set_sleep_mode(SLEEP_MODE_PWR_DOWN);

cli();

sleep_bod_disable();

sei();

sleep_cpu();

/* wake up here */

sleep_disable();

//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)

}

In dem Sketch sind ein paar Sachen vom SleepMode bewusst auskommentiert. Der auskommentierte Teil gehört zum ATtiny. Dieser funktioniert prinzipiell auch beim normalen Arduino, muss aber ein klein wenig angepasst werden. Die Anpassungen habe ich mir (erst einmal) erspart und die einfache Methode genutzt.

Als nächstes wird der Code ein wenig aufgeräumt. Dann kommt das Feature hinzu, dass sich die Ampel, stündlich seit der letzten Benutzung eine Gefahrenstufe herunter geht. So sieht man dann auch selber, wann eine Stunde um ist und man sich selber mal eine kleine Abwechslung gönnen muss.

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.

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.

Für mich hilfreiche Links zum ATtiny

28.01.2015 Marcus Klütmann News

Ich benutze gerne den Arduino in seinen verschiedenen Formen. Alle Anschlüsse sind leicht erreichbar (steckbar) und die Programmierung mit der Arduino IDE ist für gewöhnlich auch ein Kinderspiel. Der Nachteil ist, dass so ein Arduino, auch in den kleinen Varianten, immer noch recht groß ist und auch viel Strom verbraucht. Also musste mal was Neues her. Am besten sollte es auch noch weitest gehend kompatibel mit dem Arduino sein. Da bin ich dann auch den ATtiny gestoßen. Immerhin werden auf dem Arduino auch die Chips von Atmel verbaut. Nur diesmal sollte es eben ein ATtiny statt des ATmega sein.

Den ATtiny gibt es in verschiedenen Ausführungen. Ich habe mir zum Testen einen ATtiny12, ATtiny45 und ATtiny85 besorgt. Jeweils in der Duchsteckversion mit 8 Beinchen. Von Außen sind alle Versionen gleich. Nur im Innern ergeben sich kleine Unterschiede. So hat beispielsweise der ATiny85 drei PWM Ausgänge und der ATtiny 45 nur 2.

Für mein Hundeblinklicht ist es wichtig, dass die Elektronik sparsam mit der Energie umgeht. Zusätzlich habe ich noch nach einer einfachen Möglichkeit gesucht, die Elektronik mit einem einfachen Taster statt eines Schalter abzuschalten. Der ATtiny funktioniert auch ohne Spannungsstabilisierung. 1,8 V bis 5,5 V Betriebsspannung benötigt der kleine Chip. Ideal für einen 3,7 V Lithium-Akku, dessen Spannung von 4,2 V bis ca 3,6 V geht.

Ich fassen einmal kurz meine erreichten Vorteile des ATtiny gegenüber des Arduinos auf.

Einsparung des Schalters zum Abschalten der Elektronik
Wegfallen des DC-DC Spannungswandlers von 3,7 V auf 5 V
ATtiny ist bedeutend kleiner als ein ganzes Arduino Mini Bord
ATtiny ist günstiger
ATtiny ist stromsparender

Unten: Gehäuse mit Arduino Mini, Oben: ATtiny Das aktuelle Gehäuse ist sogar noch einmal etwas kleiner geworden.

Die Größeneinsparung ist schon enorm. Aber auch die Kosteneinsparung ist sehr gut. So ein Arduino Mini (Klon) kostet ca. 8 Euro, vielleicht auch nur 5 Euro. Der ATtiny nur um die 1 Euro. Kostenintensiv ist auch der DC-DC Wandler. Der von mir verwendete Pololu Wandler kostet um die 4 US$. Der eingesparte Schalter kostet nur ein par Cent. Aber man spart auch noch Platz im Gehäuse 🙂

Nun ist der ATtiny da. Wie soll der nun programmiert werden. Ein dafür geeigneten “Flasher” habe ich mir nicht gekauft. Mit einem Arduino soll das Ganze auch funktionieren. Also mal kurz rumgesucht und folgenden Link (neben anderen) gefunden: http://www.frag-duino.de/index.php/maker-faq/37-atmel-attiny-85-mit-arduino-arduinoisp-flashen-und-programmieren Dort wird beschrieben, was man machen muss, damit man mit Hilfe eines Arduinos den kleinen ATtiny mit Daten füttern kann. Zuerst hatte ich es mit einem Arduino Leonardo versucht, aber damit klappte es nicht. Mit einem Arduino Mega funktionierte es dann.

Danach habe ich nach einer Möglichkeit gesucht, den ATtiny in einen Energiesparmodus zu versetzten. Auch hier gibt es diverse Programmbeispiele. Angefangen habe ich mit diesem hier: http://www.arduino-hausautomation.de/2014/emils-ampel-attiny45-im-tiefschlaf/ Eine kleine Ampel wird per Knopfdruck eingeschaltet. Nach einer bestimmten Zeit wird der ATtiny wieder schlafen geschickt. Den dort abgebildeten Code musste ich noch ein bisshen anpassen, damit der ATtiny per Knopfdruck aufgeweckt und auch wieder schlafen geschickt werden kann.

Pinbelegung ATTiny — Pinbelegung ATtiny 45 – Seite 2

Mega Duem
D53 Reset (SS)
D51 D11 (MOSI)
D50 D12 (MISO)
D52 D13 (SCK)
Gnd Gnd
+5 +5

Auch dieser Link war hilfreich: http://playground.boxtec.ch/doku.php/arduino/attiny Hier werden ein paar der ATtiny Typen verglichen.

/*
  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>
#include <util/delay.h>
#include <avr/io.h>
#define BODS 7                   //BOD Sleep bit in MCUCR
#define BODSE 2                  //BOD Sleep enable bit in MCUCR
 
uint8_t mcucr1, mcucr2;
uint8_t PWM1 = PB0;  // PWM LED
uint8_t PWM2 = PB1;  // PWM LED
uint8_t LED = PB4;
uint8_t buttonPin = PB2;

uint8_t anzahlLED = 2; // hier die Anzahl der Array-Elemente eintragen
uint8_t currentLED=0;
long lauflichtTimer;
int flashIntervall = 500; // Flash-Intervall
uint8_t flashdauer = 50;

uint8_t buttonState;             // the current reading from the input pin
uint8_t lastButtonState = LOW;   // the previous reading from the input pin
long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 400;    // the debounce time; increase if the output flickers
uint8_t ledState = 0;  

boolean sleepMode = 0;

ISR(INT0_vect) { 
  analogWrite(PWM1, 10);
  analogWrite(PWM2, 10); 
  digitalWrite(LED, LOW);
  _delay_ms(500);
  digitalWrite(PWM1, LOW);
  digitalWrite(PWM2, LOW);
  if(!digitalRead(buttonPin)){ 
    analogWrite(LED, 15);  // Wenn diese LED leuchtet, kann der Taster losgelassen werden, um den ATtiny aufzuwecken
    sleepMode = 0;
    while(!digitalRead(buttonPin));
  }
}
 
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() {
  DDRB &= ~(1 << buttonPin);    // pinMode(buttonPin, INPUT_PULLUP);  
  PORTB = B0000100; //PORTB |= (1 << buttonPin);    // enable pull-up resistor
  
  DDRB |= 1<<PB0; //pinMode(PWM1, OUTPUT);
  DDRB |= 1<<PB1; //pinMode(PWM2, OUTPUT);
  DDRB |= 1<<PB3 | 1<<PB4 | 1<<PB5;
  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;
        off();
      }
    }
  }

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

void off(){
  digitalWrite(PWM1, LOW);
  digitalWrite(PWM2, LOW);
  digitalWrite(LED, LOW);
  //PORTB = B0000100;
  //PORTB &= ~(1<<PB1);
  //PORTB &= ~(1<<PB0);
}

// LED soll im Dauerbetrieb schwach leuchten
void dauerLicht(){
  analogWrite(PWM1,10);
  analogWrite(PWM2,10);
  analogWrite(LED,2);
}


// 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();
  if(time-lauflichtTimer>currentLED*flashIntervall && time-lauflichtTimer < currentLED*flashIntervall+flashdauer){
    digitalWrite(currentLED, HIGH); } //PORTB |= 1<<currentLED; }
  if(time-lauflichtTimer>currentLED*flashIntervall+flashdauer && time-lauflichtTimer < (currentLED+1)*flashIntervall){
    analogWrite(currentLED++,5);}//PORTB &= ~(1<<currentLED++); }
  if(time-lauflichtTimer>anzahlLED*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

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

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>

#include <util/delay.h>

#include <avr/io.h>

#define BODS 7 //BOD Sleep bit in MCUCR

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

uint8_t mcucr1, mcucr2;

uint8_t PWM1 = PB0; // PWM LED

uint8_t PWM2 = PB1; // PWM LED

uint8_t LED = PB4;

uint8_t buttonPin = PB2;

uint8_t anzahlLED = 2; // hier die Anzahl der Array-Elemente eintragen

uint8_t currentLED=0;

long lauflichtTimer;

int flashIntervall = 500; // Flash-Intervall

uint8_t flashdauer = 50;

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

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

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

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

uint8_t ledState = 0;

boolean sleepMode = 0;

ISR(INT0_vect) {

analogWrite(PWM1, 10);

analogWrite(PWM2, 10);

digitalWrite(LED, LOW);

_delay_ms(500);

digitalWrite(PWM1, LOW);

digitalWrite(PWM2, LOW);

if(!digitalRead(buttonPin)){

analogWrite(LED, 15); // Wenn diese LED leuchtet, kann der Taster losgelassen werden, um den ATtiny aufzuwecken

sleepMode = 0;

while(!digitalRead(buttonPin));

}

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() {

DDRB &= ~(1 << buttonPin); // pinMode(buttonPin, INPUT_PULLUP);

PORTB = B0000100; //PORTB |= (1 << buttonPin); // enable pull-up resistor

DDRB |= 1<<PB0; //pinMode(PWM1, OUTPUT);

DDRB |= 1<<PB1; //pinMode(PWM2, OUTPUT);

DDRB |= 1<<PB3 | 1<<PB4 | 1<<PB5;

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;

off();

}

// set the LED-Mode

if (ledState==1){

analogWrite(LED, 2);

lauflicht();

}else if(ledState==2){

dauerLicht();

}else if(ledState==3){

sleepMode=1;

ledState=1;

}

while(sleepMode==1){

goToSleep();

_delay_ms(200);

digitalWrite(LED, LOW);

}

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

// it'll be the lastButtonState:

lastButtonState = reading;

}

void off(){

digitalWrite(PWM1, LOW);

digitalWrite(PWM2, LOW);

digitalWrite(LED, LOW);

//PORTB = B0000100;

//PORTB &= ~(1<<PB1);

//PORTB &= ~(1<<PB0);

}

// LED soll im Dauerbetrieb schwach leuchten

void dauerLicht(){

analogWrite(PWM1,10);

analogWrite(PWM2,10);

analogWrite(LED,2);

}

// 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();

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

digitalWrite(currentLED, HIGH); } //PORTB |= 1<<currentLED; }

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

analogWrite(currentLED++,5);}//PORTB &= ~(1<<currentLED++); }

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

}

Um den Code auf den jetzigen Stand zu bringen, musste ich einiges lesen. Auch das anfangs kryptisch wirkende Datenblatt des ATtiny hat sich mir ein wenig geöffnet. Hier ist noch ein Quellcode zu finden, in dem die Verwendung der Register ausführlich beschrieben ist: http://matt16060936.blogspot.de/2012/04/attiny-pwm.html
Zu guter Letzt habe ich mich noch mit den Interrupts auseinander gesetzt. http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

Meine Methode “lauflicht()” ist so gestaltet, dass die ohne die Funktion delay auskommt. So war es möglich, schnell auf einen Tastendruck zu reagieren. Bei Verwendung von delay hätte der Taster während des delays nicht reagiert. Mittlerweile müsste ich soweit sein, dass ich den Taster komplett als Interrupt definiere. Dann müsste der ATtiny auch während der Wartephase reagieren. Das probiere ich später noch mal aus.

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.

Schlagwort: Arduino

DIY Arduino RC Transmitter – HowToMechatronics

NodeMcu Lua ESP8266 ESP-12F WIFI

Arduino Clone

Treiber

Arduino IDE

ATtiny85 Ring Watch

Das elektronische Schaf

DEFCON 1 – Bitte nicht stören

You SLS – SLS 3D Drucker zum Nachbauen

Hundeblinklicht Version 6

Für mich hilfreiche Links zum ATtiny

Hundeblinklicht V5 – Nachtrag

Hundeblinklicht, Version 5 – es wird Tiny

Neue Beiträge

Archive

Kategorien

Weitere Inhalte