Hilfe:Klartraum-Maske Seite 2

So, ich habe mal ein bisschen was programmiert. Ich habe mich
dann doch für den Attiny13A entschieden, weil sich bei dem
der Watchdog einfacher nutzen lässt ( WD-Interrupt statt Reset ).
Der Spannungsbereich ist mit 1.8V..5.5V auch sehr entgegenkommend.

Es werden 2 Ports für die LEDs genutzt. Normalerweise würde das auch
ein Port schaffen, wenn die jeweils relativ hochohmig angebunden werden.

Strombilanz:
Warte 6h auf REM-Phase 4.5µA
Led-Blinkend mit Watchdog (1800ms*4.5µA + 200ms * 5mA)/2s = ~ 500µA )*
Power-Down-Mode nach REM-Blinken 120nA

Betrieb mit einer CR2032, die grob über 200mAh verfügen sollte (das
anfängliche 3x-Blinken als Start-Feedback vernachlässige ich mal) :

6.0h Warten auf REM 4.50uA = 270 µAh
0.5h aktiv blinken (0.2/1.8) 500.00µA = 250 µAh
17.5h Warten auf nächste Nacht 0.12µA= 2.1µAh
= 522µAh Tagesverbrauch
Bei 200mAh sind das -> 383 Tage, die Batterie hält also ein gutes
Jahr bei täglicher Anwendung.

Wenn es nicht angewendet wird, ist der Idle Strom so gering, dass
die Batterie in diesem Zustand theoretisch 190 Jahre hält. Es lohnt
sich also nicht mehr, in diesem Bereich zu optimieren oder sich was
anderes Schlaues an externer Beschaltung auszudenken.

)* Ich habe hier einen Widerstand von 2kOhm vor die (roten) LEDs geschaltet,
leuchtet also eher schwach und damit kann auch noch experimentiert
werden.
Ich denke, das Signal direkt vor den Augen sollte nicht den Eindruck
vermitteln, dass einem ein Auto mit Lichthupe entgegen kommt
-> böse Träume

Gruß
Stefan

Hier der Assembler-Source-Code, erstellt mit AVR-Studio 4:

Code :


.include "tn13adef.inc"



/* Ports:





      +-----------------------------+

      |                             |

      |           +----_----+       |

 +3V--*-[10k]-*---|/Res  Vcc|-------*-------------+

      |       |  -|PB3   PB2|----|<|----[ 2k  ]---*

      =       /  -|PB4   PB1|-                    |

 GND--*-------*---|Gnd   PB0|----|<|----[ 2k  ]---*

                  +---------+   

                   ATTINY13A





Fuse to:

Low:  0x69  -> Clk=4.8M/8 = 600kHz

High: 0xFF



 Weitere Spar-Massnahmen:

 - OSCCAL und CLKPR benutzen um die Clock in den Aktiv-Zeiten voellig in den Keller zu drehen? Wahrscheinlich bringt das

   aber nicht mehr viel, denn die allermeiste Zeit ist die Clock sowieso angehalten.



*/



#define DEBUG 0



; Konfiguration:

   #define WD_16MS_MEAS      32                                ; im 16ms-Mode messe ich bei 3V tatsaechlich etwa 32ms

   #define WD_8S_MEAS        9.5                               ; 8s per Debug-Blinken ausmessen und hier ermittelten Wert eintragen

   #define LED_ON_DUR        200                               ; LED soll beim Blinken 200ms an sein

   #define LED_OFF_DUR       1800                              ; und 1800ms aus





  .equ LED_ON_TICKS       = (LED_ON_DUR/WD_16MS_MEAS)          ;  200ms  ( in 32ms-Watchdog-Ticks gerechnet )

  .equ LED_OFF_TICKS      = (LED_OFF_DUR/WD_16MS_MEAS)         ; 1800ms

  .equ LED_POWERON_LOOPS  = 3                                  ; Direkt nach Reset 3 mal blinken

#if !DEBUG

  .equ LED_ONOFF_LOOPS    = ((30*60)/(LED_ON_DUR+LED_OFF_DUR)) ; 30 Minuten * 60 Sekunden / Loop-Dauer in Sekunden = Anzahl Loops ( 900 )

  .equ SLEEP_TIME         = ((6*60*60)/WD_8S_MEAS)             ; Zeit bis zur Aktivierung der LEDs = 6 Stunden x 60min x 60s / 8s Watchdog-Tick (2273)

#else // Debug-Configuration

  .equ LED_ONOFF_LOOPS    = (10)                               ; Debug: 10 Blink-Zyklen reichen aus

  .equ SLEEP_TIME         = (40/WD_8S_MEAS)                    ; Debug: nur 40s schlafen

#endif





; Pin Config

.equ LED1_PIN     = 0  ; 5 PB0 ( AIN0+ (BG))   Mosi 

.equ UNUSED_0     = 1  ; 6 PB1 ( AIN1- /INT0)  Miso, spaeter vielleicht Taster oder IR-Transistor

.equ LED2_PIN     = 2  ; 7 PB2 SCK ( ADC1 )

.equ UNUSED_1     = 3  ; 2 PB3 (XTAL)

.equ UNUSED_2     = 4  ; 3 PB4 (XTAL)

; reset ist PB5        ; 1 PB5



; Variablen:

.def SleepH     = r16  ; verbliebene Schlafticks bis zur Blink-Phase

.def SleepL     = r17 

.def LEDLoopsH  = r18  ; wie oft wird noch geblinkt

.def LEDLoopsL  = r19

.def temp       = r20

.def temp2      = r21

.def IRQtemp    = r22





.org 0x0000

reset:

  rjmp main              ; 1 RESET ( pwron, ext, brownout, wd )

  reti ;rjmp EXT_INT0    ; 2 AT12 IRQ0 handler, enabled but not used

  reti ;rjmp PIN_CHANGE  ; 3 Pin change handler

  reti ;rjmp TIM0_OVF    ; 4 Timer0 overflow handler

  reti ;                 ; 5 EEPROM ready

  reti ;rjmp ANA_COMP    ; 6 Analog Comparator handle

  reti ;TIM0-COMPA       ; 7

  reti ;TIM0-COMPB       ; 8

  rjmp wdog ;Watchdog    ; 9

  reti ;ADC              ;10



;---- Watchdog-Interrupt------------------------------------------------

wdog:

  in   IRQtemp,WDTCR

  ori  IRQtemp,(1<<WDTIE)  ; vom IRQ geloeschtes WDTIE wieder setzen, sonst

  out  WDTCR,IRQtemp       ; kommt danach ein Watchdog-RESET, kein Int

  reti

;-----------------------------------------------------------------------





; Hier gehts los:

main:

 wdr

 ldi    temp, (1<<LED1_PIN)|(1<<LED2_PIN) ; LED1 und 2 sind Output

 out    DDRB, temp

 ser    temp                              ; alles High setzen, damit sind a) die Leds aus und b) bei den 

 out    PORTB,temp                        ; Inputs alle Pullups aktiv, es floated nix -> Power



 ; Energiesparmassnahmen

 ldi    temp, (1<<ACD)                    ; disable comparator

 out    ACSR,temp



 ldi    temp, (1<<PRTIM0)|(1<<PRADC)      ; shutdown timer0 and ADC module

 out    PRR, temp



 ldi    temp, (1<<AIN1D)|(1<<AIN0D)       ; disable digital input-buffers on AIN1 and AIN0 ( PB0 and 1 )

 out    DIDR0, temp



 ; Power-Down-Sleep-Mode für spaeter vorbereiten

 ldi    temp,(1<<SE)|(1<<SM1)|(0<<SM0) 

 out    MCUCR, temp



 ; Watchdog auf "schnell" als IRQ konfigurieren

 ldi    temp2, (0<<WDE)|(1<<WDTIE)|(0<<WDP3)|(0<<WDP2)|(0<<WDP1)|(0<<WDP0) ; value to be written to WDTCR

 rcall  set_wdog                          ; Prescaler steht auf 



 clr    LEDLoopsH

 ldi    LEDLoopsL, LED_POWERON_LOOPS

 rcall  BlinkLoop     ; zur Begruessung 3mal blinken



 ; jetzt warten auf den REM-Schlaf

 ldi    temp2, (0<<WDE)|(1<<WDTIE)|(1<<WDP3)|(0<<WDP2)|(0<<WDP1)|(1<<WDP0) ; auf Super-Langsam stellen ( 8 Sekunden )

 rcall  set_wdog



 ldi    SleepH, HIGH(SLEEP_TIME)  ; Sleep-Timer auf 6 Stunden aufziehen

 ldi    SleepL,  LOW(SLEEP_TIME)



CountSheep:

 sleep

#if DEBUG                         ; kurze Wake-Phase anzeigen

 cbi    PORTB, LED1_PIN           ; Lampe ein   

 rcall  waitshort

 sbi    PORTB, LED1_PIN           ; Lampe aus

#endif



 dec    SleepL

 brne   CountSheep

 cpi    SleepH,0                  ; Schon alles auf 0 runter jetzt?

 breq   BlinkPhase                ; ja, mit dem Blinken anfangen

 dec    SleepH

 rjmp   CountSheep



BlinkPhase:

 ; Watchdog fuer´s Blinken wieder auf "schnell" als IRQ konfigurieren

 ldi    temp2, (0<<WDE)|(1<<WDTIE)|(0<<WDP3)|(0<<WDP2)|(0<<WDP1)|(0<<WDP0) ; value to be written to WDTCR

 rcall  set_wdog



 ldi    LEDLoopsH, HIGH(LED_ONOFF_LOOPS)

 ldi    LEDLoopsL,  LOW(LED_ONOFF_LOOPS)

 rcall  BlinkLoop  ; etwa eine halbe Stunde rumblinken



 ; So, jetzt sind wir mit allem fertig. Controller in einen Betriebszustand mit

 ; super-niedriger Energieaufnahme bringen. -> Watchdog disable und Power-Down-Sleep

 ; Aus diesem Schlaf erwacht der Controller nicht mehr. Mit dem Taster am Reset-Pin

 ; kann jedoch ein Hardware-Reset ausgeloest werden und das Spiel startet von vorne.



PowerOff:

 ; jetzt wieder Power-Down-Sleep-Mode

 cli   ; keine Interrupts mehr



 ldi    temp2, (0<<WDE)|(0<<WDTIE)|(1<<WDP3)|(0<<WDP2)|(0<<WDP1)|(1<<WDP0) ; Disable WD, super-langsam so lassen, hat keinen Effekt

 rcall  set_wdog

 sleep

 rjmp   PowerOff  ; hier sollte der Prozessor nie hinkommen, wenn doch wird er sofort wieder in den Schlaf versetzt





;----------------------------------------------------------------------------------

;  Unterfunktionen

;----------------------------------------------------------------------------------

#if DEBUG                  ; waitshort wird nur für Debug gebraucht

waitshort:

 clr    temp2

waitloop:

 dec    temp2

 nop

 brne   waitloop

 ret

#endif





blink:

 cbi    PORTB, LED1_PIN    ; Lampen ein

 cbi    PORTB, LED2_PIN

 ldi    temp,  LED_ON_TICKS

led_sleep_on:

 sleep

 dec    temp

 brne   led_sleep_on



 sbi    PORTB, LED1_PIN   ; Lampen aus

 sbi    PORTB, LED2_PIN

 ldi    temp,  LED_OFF_TICKS

led_sleep_off:

 sleep

 dec    temp

 brne   led_sleep_off

 ret





BlinkLoop:

 rcall blink         ; 1x blinken bitte

 dec  LEDLoopsL      ; 1 abziehen

 brne BlinkLoop      ; wenn nicht 0, direkt nochmal blinken

 cpi  LEDLoopsH,0    ; High-Byte schon 0?

 breq BlinkLoopEnd   ; ja, raus hier

 dec  LEDLoopsH      ; nein: eins abziehen

 rjmp BlinkLoop      ; und weiterblinken

BlinkLoopEnd:

 ret





set_wdog:

 ; Watchdog auf schnell konfigurieren ( aus Spec )

 cli

 wdr

 ; Start timed sequence

 in     temp, WDTCR

 ori    temp, (1<<WDCE) | (1<<WDE)    ; watchdog change enable

 out    WDTCR, temp                   ; -- Got four cycles to set the new values from here -

 out    WDTCR, temp2                  ; Set new prescaler(time-out) value from temp2

 ; watchdog-Int scharf schalten

 sei

 ret

_________________
Alle sagten: Das geht nicht. Dann kam einer, der wusste das nicht und hat´s gemacht.