Jürgens Anemometer - Markisen - Projekt

 

Inhalt

 

Wer öffnet die Markise wenn ich nicht zuhause bin?
UND wer schließt die Markise wenn's regnet?

Auf meiner Terrasse habe ich zwei elektrisch betriebene Markisen. Für die Markisen existiert eine 433MHz Funkfernbedienung mit der sich die Markisen öffnen und schließen lassen.
Abends sitze ich gerne auf der Terrasse, aber leider heizt sie sich bei sonnigem Wetter und geschlossenen Markisen tagsüber stark auf.
Also könnte ich bei sonnigem Wetter die Markisen morgens, bevor ich zur Arbeit gehe, öffnen damit die Terrasse tagsüber nicht aufgeheizt wird.

Alles schön und gut, ABER was tun wenn's zu regnen beginnt oder wenn plötzlicher starker Wind die Markisen zu beschädigen droht? Dann ist niemand da der die Markise schließt um sie vor Schaden zu bewahren.

Dann halt auf der heißen Terrasse sitzen?

NEIN!

Da muss ein Automatismus her ...

... automatisch die Fernbedienung drücken :)

Also muss ich etwas konstruieren das bei Sonne die Markisen öffnen und bei Wind oder Regen die Markisen sofort schließt.

Hmmm...

Mit einem Windmesser einem sogenannten Anemometer könnte ich mit einem Sensor die Drehzahl abnehmen und wüßte somit ob viel oder wenig Wind bläst.
Mit einem Temperaturfühler kann die Temperatur gemessen werden und mit einem lichtempfindlichen Widerstand die Helligkeit.

Die gesamten Informationen mit einem Microcontroller auswerten und entsprechend die Fernbedienung drücken :)

Projekt Anemometer

Also auf den Punkt gebracht:

Es ist ein Anemometer zu konsturieren (3D CAD) und mit dem 3D Drucker zu produzieren.
Dieser Windmesser soll eine kompakte Bauform aufweisen da er zwischen den beiden Markisen an der Wand montiert werden soll.
Im Windmesser soll ein Sensor (Hallgeber/Magnet oder Metall/Induktionssensor) die aktuelle Umdrehungen pro Minute an einen Microcontroller übergeben.

Es soll die aktuelle Temperatur wie auch die aktuelle "Lichthelligkeit" gemessen werden und diese Werte sollen ebenfalls an den Microcontroller übergeben werden.

Ein Endschalter "geschlossen" soll an beiden Markisen vorhanden sein und der aktuelle Wert an den Microcontroller übertragen werden.

Der Microcontroller soll mit Hilfe dieser Werte entscheiden ob die Markise geöffnet oder geschlossen werden soll.

Um die Markisen mit 433MHz Funksignalen bedienen zu können, muss der original Funkcode der vorhandenen Fernbedienung ausgelesen werden. Der ausgelesene Code für das Öffnen und Schließen soll im Microcontrollerprogramm einprogrammiert werden, um über ein 433MHz Sendemodul diese Codes an die Markise senden zu können.

Als zusätzliches Feature soll auch die Luftfeuchtigkeit gemessen werden.
Vom 433MHz Sender soll in 2 Minuten Intervallen die Temperatur, die Windgeschwindigkeit, die Helligkeit und die Luftemperatur sowie den Status (IST/SOLL) der Markisen an einen 433Mhz Empfänger übertragen werden.

Mit einem 433MHz Empfänger sollen die Werte an einen zweiten Microcontroller übergeben werden, der die empfangenen Werte auf einem LCD Display ausgibt (quasi eine Wetterstation).

Ausserdem soll bei Abweichung des IST/SOLL Markisenstatus bei mehr als der 3fachen Schließdauer der Markisen eine Alarmmeldung abgesetzt werden (eventuell Mail über WLAN ?!).

Da hab ich ja ganz schön was vor ....

Gut dass ich während der Zusatzusbildung "Mikrotechnik" ein Abschlußprojekt mit Microcontroller machen muss :)

Mit meinem Trainer konnte ich dies bereits abklären und der Projektvorschlag wurde angenommen.

Sher gut, zwei Fliegen mit einer Klatsche!

Die nächten Schritte

Ich möchte wie folgt vorgehen:

  1. Erstellung der Projektdokumentation (laufend ergänzen)
  2. 433MHz Codes auslesen und ein Testprogramm schreiben (öffnen, schließen)
  3. 3D CAD Entwurf Anemometer und am 3D Drucker produzeiren
  4. Stromlaufplan der Elektronik (Sender und Empfänger)
  5. Layout entwerfen, Platinen fräsen, Schaltungen fertigen
  6. Assemblieren aller Komponenten
  7. Programm schreiben
  8. Trockentest
  9. Montage
  10. Projektmappe fertigstellen
  11. Videodokumentation der Funktionen

 

Anforderung genaue Definition

Es sollen Markisen welche bereits einen elektrischen Antrieb aufweisen und mittels Funkfernbedienung (433Mhz) gesteuert werden können (auf / zu), um folgende Funktionen erweitert werden:


• Permanente Überwachung des aktuellen Windgeschwindigkeit

• Falls Markise geöffnet bei zu starkem Wind -> Markise schließen

• Permanente Überwachung der aktuell Lichtstärke

• Falls Lichtstärke zu niedrig (Abends) -> Markise schließen

• Permanente Überwachung der aktuellen Lufttemperatur

• Falls Temperatur zu niedrig -> Markise schließen

• Markise automatisch öffnen wenn der Pegel von Lichtstärke und Temperatur und Windgeschwindigkeit unter dem Schließbedingungswert liegt

• Wenn Markise automatisch geschlossen wurde, muss sichergestellt sein, dass die Markise tatsächlich geschlossen ist (mittels Endschalter). Falls die Endschalter nach der max. dreifachen Dauer welche die Markise im Normalbetreib zu schließen benötigt, muss ein „Alarmton“ ausgelöst werden (Störfall)

Zum Seitenanfang

 

Analyse

Für die Umsetzung der Anforderungen muss folgendes entwickelt werden:


1. 433MHz Funksender
2. elektronischer Windsensor (Anemometer)
3. elektronischer Lichtsensor
4. elektronischer Temperatursensor
5. Endschalter für Stellung geschlossen für 2 Markisen
6. Alarmgeber
7. LCD Display zur Statusanzeige
8. System Reset Taster
9. Microcontroller
10. Stromversorgung
11. Microcontroller Programm zu Steuerung

433MHz Funksender

Hier soll ein vorgefertigtes Modul (433MHz RF Transmitter – FS1000A) eingesetzt werden.
Dieses Modul benötigt eine Spannungsversorgung mit 5V DC max. 40mA. Auf einem Eingangsping kann ein High/Low Pegel angelegt werden welche ein Senden eines 433MHz Trägers auslöst.
Zur Erhöhung der Sendereichweite ist eine Antenne zu konstruieren.
Die Funksignale der vorhandenen Fernbedienung müssen ausgelesen werden.


Anemometer

Der Windsensor kann am vorhandenen 3D Drucker produziert werden. Vorher ist im 3D CAD ein Modell des Windmessers zu erstellen.

Die Abnahme der Windgeschwindigkeit soll mittels Messung der Umdrehungen erfolgen. Die Übergabe des Messwertes soll pro Umdrehung mit einem kurzen High Pegel erfolgen.

Als Sensor soll ein Hall Effekt Sensor (A3144) der über einen an der Drehscheibe befestigten Permanentmagneten (Neodym) erregt wird, eingesetzt werden.
Stromversorgung: 4,5 – 24V DC 25mA


Lichtsensor

Der Lichtsensor muss so empfindlich sein, dass Unterschiede zwischen direkter Sonneneinstrahlung, allgemein sonnigem Wetter, bewölkt, regnerisch und Dämmerung bzw. Nacht gemessen werden können. Die Reaktionszeit des Lichtsensors ist nicht relevant. Die Übergabe des Messwertes soll analog erfolgen.
Stromversorgung: LDR 5V DC 6mA


Temperatursensor

Der Temperatursensor muss einen Temperaturbereich von -25°C bis +50°C erfassen können.
Die Übergabe der Temperatur soll digital erfolgen. Es soll dazu ein vorgefertigtes Temperatursensormodul (DHT11) eingesetzt werden.
Stromversorgung: 5V DC 1mA.


Endschalter

An beiden Markisen sollen Endschalter die Position „Markise geschlossen“ erfassen (Markise offen = Schalter offen).


Alarmgeber

Nach Ausgabe des 433MHz Funksignals „Markise schließen“, soll nach einer Wartezeit von spätestens der dreifachen Dauer eines normalen Schließvorganges ein Alarm ausgelöst werden.
Aktiver Alarm soll über einen Piezo Summer und eine Warnleuchte (LED) angezeigt werden.
Standard Piezo 100dB 5V 10mA
LED 5V 20mA (Vorwiderstand)

LCD Display zur Statusanzeige

Folgende Informationen sollen angezeigt werden:

• Markisenstatus IST (offen / geschlossen)
• Markisenstatus SOLL (offen / geschlossen)
• Aktuelle Aktion (Normalbetrieb / schließen / öffnen / Alarm)
• Aktuelle Werte (Windgeschwindigkeit, Lichtstärke, Temperatur)

Dazu ist ein 16x2 LCD Display erforderlich. Die Ansteuerung erfolgt im 4 Bit Modus -> benötigt: 4 Datenleitungen und 3 Steuerleitungen.
Stromversorgung: 5V DC 230mA.


System Reset Taster

Es soll ein leicht zugänglicher Reset Taster vorhanden sein mit dem das System rückgesetzt werden kann.


Microcontroller

An den Microcontroller werden folgende Anforderungen gestellt.


Eingänge:


• Windsensor; 1 Pin digital
• Lichtsensor; 1 Pin analog (ADC)
• Temperatursensor; 1 Pin digital
• Endschalter; 2 Pins digital
• Reset Pin
• VCC 5V
• GND


Ausgänge:


• 433MHz Sender; 1 Pin digital
• Alarm Piezo; 1 Pin digital
• Alarm LED; 1 Pin digital
• LCD-Display; 7 Pins digital
• VCC 5V
• GND

1 x ADC Wandler Eingang, 4 x Digital Eingang, 1 x Reset, VCC und GND
10 x digital Ausgang, VCC und GND


Stromversorgung

Direkt an den Markisen ist 250V AC verfügbar.

Stromaufnahmen:


• 433MHz Sender / 5V 40mA
• LDR / Lichtstärke 5V DC 6mA
• Anemometer / Hall Effekt Sensor 5V 25mA
• DHT11 / 5V 1mA
• Endschalter / 2x Hall Effekt Sensor 5V 50mA
• LCD Display / 5V 230mA
• Alarm Piezo Summer / 5V 10mA
• Alarm LED Rot / 2V 20mA
• Micro Controller / 5V 20mA


Gesamt Strom Aufnahme: 5V 402mA
Es wird ein Netzteil mit 250V AC / 5V DC 1A benötigt.


Microcontroller Programm

An das Programm sind folgende Anforderungen gestellt:

  • Sammeln der Sensorwerte im Minutentakt
  • Logikprüfung laut Sensorwerte ob Markise geöffnet oder geschlossen werden soll
  • Prüfung Status Markise
  • Prüfung ob SOLL mit IST übereinstimmt
  • Entscheidung ob Markise geöffnet, geschlossen werden soll, bzw. so bleibt
  • Bei SOLL Markise geschlossen, prüfen ob Endschalter geschlossen -> falls nicht Markise schließen
  • Bei Markise öffnen -> Aussendung 433MHz Signal zum öffnen -> prüfen ob Endschalter geöffnet werden.
  • Bei Markise schließen -> Aussendung 433MHz Signal zum Schließen – prüfen ob Endschalter nach 3facher Normalschließzeit geschlossen werden.
    • Falls Endschalter nach schließen nicht geschlossen werden -> Alarm auslösen und das „Schließen Signal“ permanent an Markise senden.
      • Falls Endschalter geschlossen, Alarm beenden.


Zum Seitenanfang

 

Messung

Es soll aus der originalen Fernbedienung die 433MHz Codes ausgelesen und ausgemessen werden.

Messaufbau

Messgeräte:

• Digitales Speicheroszilloskop, DSO 203 Quad

Oszilloskop Messung:

Anschluss Masse auf Masse der originalen Fernbedienung, Tastkopf auf Signalausgang der Fernbedienung.


Analoges Ausgabesignal „Öffnen“:


Analoges Ausgabesignal „Schließen“:


Ausgabedaten in digitaler Form

Ausgabesignal „Öffnen“:


Ausgabesignal „Schließen“:


Werden beide Signale übereinander gelegt, so sind sie bis auf vier Abweichungen völlig deckungsgleich.


Zum Seitenanfang

 

Vermessung der Signale

Vermessung

Signal öffnen / schließen: A = 0,33ms ; B = 0,67ms ; H = High ; L = Low

  1. 7,75ms H
  2. 4,75ms L
  3. 1,50ms H
  4. AL
  5. BH
  6. BL
  7. AH
  8. AL
  9. BH
  10. BL
  11. AH
  12. BL
  13. AH
  14. AL
  15. BH
  16. BL
  17. AH
  18. BL
  19. AH
  20. AL
  21. BH
  22. AL
  23. BH
  24. AL
  25. BH
  26. AL
  27. BH
  28. AL
  29. BH
  30. AL
  31. BH
  32. BL
  33. AH
  34. AL
  35. BH
  36. AL
  37. BH
  38. BL
  39. AH
  40. BL
  41. AH
  42. AL

 

  1. BH
  2. AL
  3. BH
  4. BL
  5. AH
  6. AL
  7. BH
  8. AL
  9. BH
  10. BL
  11. AH
  12. AL
  13. BH
  14. AL
  15. BH
  16. BL
  17. AH
  18. AL
  19. BH
  20. AL
  21. BH
  22. AL
  23. BH
  24. BL
  25. AH
  26. AL
  27. BH
  28. AL
  29. BH
  30. AL / BL
  31. BH / AH
  32. BL
  33. AH
  34. AL
  35. BH
  36. AL
  37. BH
  38. AL / BL
  39. BH / AH
  40. BL
  41. AH
  42. 4,75ms L
  1. 1,50ms H
  2. AL
  3. BH
  4. BL
  5. AH
  6. AL
  7. BH
  8. BL
  9. AH
  10. BL
  11. AH
  12. AL
  13. BH
  14. BL
  15. AH
  16. BL
  17. AH
  18. AL
  19. BH
  20. AL
  21. BH
  22. AL
  23. BH
  24. AL
  25. BH
  26. AL
  27. BH
  28. AL
  29. BH
  30. BL
  31. AH
  32. AL
  33. BH
  34. AL
  35. BH
  36. BL
  37. AH
  38. BL
  39. AH
  40. AL
  41. BH
  42. AL

 

  1. BH
  2. BL
  3. AH
  4. AL
  5. BH
  6. AL
  7. BH
  8. BL
  9. AH
  10. AL
  11. BH
  12. AL
  13. BH
  14. BL
  15. AH
  16. AL
  17. BH
  18. AL
  19. BH
  20. AL
  21. BH
  22. BL
  23. AH
  24. AL
  25. BH
  26. BL
  27. BH
  28. AL / BL
  29. BH / AH
  30. BL
  31. AH
  32. AL
  33. BH
  34. AL
  35. BH
  36. AL / BL
  37. BH / AH
  38. BL

 

Daraus ergeben sich die Bitmuster:


Ein Bit hat eine Gesamtlaufzeit von 1ms. Das Sendeverhältnis pro Bit ist 2:1.
0 = 2/3 HIGH 1/3 LOW 1 = 1/3 HIGH 2/3 LOW


close
Startseq. 11011110 11111110 00111110 00011110 11001100 Zwischenseq. 110…

open
Startseq. 11011110 11111110 00111110 00011110 11101110 Zwischenseq. 110…

stopp
Startseq. 11011110 11111110 00111110 00011110 10101010 Zwischenseq. 110…

Zum Seitenanfang

 

Entwicklung


Anemometer
3D CAD Entwurf und 3D Druck Produktion

Der Entwurf des Anemometers wurde mit OPENSCAD erstellt. Die Einzelteile wurden exportiert um am 3D Drucker produziert.
Die Schaltung des Sensors wurde in Target erstellt und auf einer Lochrasterplatine aufgebaut.


Stückliste Sensor:
1 Hallgeber A3144 oder y3141
1 Widerstand Metallschicht 1kOhm
1 Leitung 3 Polig Polyestermantel 0,25mm² (schwarz, braun, blau)
1 Lochrasterplatine rund Durchmesser 26mm mit einer zentralen Bohrung von 6,5mm.

Stückliste Anemometer:
3D Produktion:
2 Gehäuseteile
3 WindCups
1 Magnetaufnehmerscheibe
1 Windcuphalterscheibe
1 Abdeckkappe

mechanische Teile:
1 M5 Gewindestange 85mm
2 Kugellager 625ZZ
7 M5 Beilagscheiben
6 M5 Muttern selbstsichernd
2 M5 Muttern



Elektronik:
1 Hallgeber Sensor Platine mit Anschlussleitung


Stromlaufplan Hallsensor

 

Testprogramm Hallgeber Anemometer

/*

Anemometer Halllgeber Test

Autor: JULE

Datum: 27.8.16

 

ANEMOMETER

==========

PC7 = Kontroll LED INT0

PC6 = Kontroll LED Timer0INT mit Teiler

PD2 = Hallgeber Ein INT0

 

LCD

===

E  = A1

RW = A2

RS = A3

D4 = A4

D5 = A5

D6 = A6

D7 = A7

*/

 

#define F_CPU 1000000UL

 

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include "lcd.h"5

 

uint8_t  iTimerCount = 0;

uint16_t  iINTCount = 0;

 

ISR(TIMER1_OVF_vect);

ISR(INT0_vect);

 

int main(void)

{

 

       DDRC = 0xFF;    //PORTC = Ausgang alle 8 Bits

       PORTC = 0x00;       // Pulldowns PortC

       DDRD = 0x00; // Port D input interupt INT0 = PD2

       PORTD = 0xFF;       // Pulldowns PortD

       DDRA = 0xFF; // LCD PORT out

 

       char cLCD_val[] = ""; // char Array fuer LCD Text

      

       //INT0

       MCUCR = 1<<ISC01 | 1<<ISC00;      // Trigger INT0 steigendeFlanke

       GICR = 1<<INT0;                                // Enable INT0

 

       // Timer0 interner Timer interrupt

       TCCR0= (1<<CS02)|(1<<CS00);//prescaler 1024

        bei 8 Bit Timer0 -> 1Mhz/ 1024 /255 = 3,8x pro Sek                                                    

       TIMSK= (1<<TOIE0);                // Timer 1 overflow interrupt aktivieren

 

       sei();                                            // Enable Interrupts

      

       //LCD Start

       LCDInit(LS_NONE); // LCD Cursor aus

       LCDHome(); //Cursor auf 0,0

       LCDClear(); //LCD loeschen

       LCDWriteString("Anemometer Test"); // LCD Text

       LCDGotoXY(0,1); //col, line

       LCDWriteString("(c) 2016 JULE"); // LCD Text

       _delay_ms(50); //warte 500ms

       LCDHome();

       LCDClear();

                                                                    

       while(1)

       {

             // LCD Ausgabe Umdrehungen

             LCDGotoXY(0,0); //col, line

             sprintf(cLCD_val,"Umdrehungen: %d ",iINTCount);

             LCDWriteString(cLCD_val); // LCD Text

       }

 

       return 0;

}

 

ISR(TIMER0_OVF_vect) //Timer0 overflow interrupt

{

       iTimerCount++;

       if (iTimerCount >= 16) //1Sek/ 3,8 * 16 = ca. alle 4,1 Sekunden

       {                         

             //Kontroll LED

             PORTC |= (1<<PC6);

             _delay_ms(1);

             PORTC &= ~(1<<PC6);

             _delay_ms(1);

 

             iTimerCount = 0;

             iINTCount = 0;                 

       }           

}

 

ISR(INT0_vect)  //interrupt INT0  

{

       iINTCount++;

 

       // Konroll LED

       PORTC |= (1<<PC7);

       _delay_ms(1);

       PORTC &= ~(1<<PC7);

       _delay_ms(1);

}

 

Zum Seitenanfang

Entwicklung

433MHz Funksender

Die Hardware muss nicht entwickelt werden da 433MHz Funksender / Empränger Sets bereits um kleines Geld zu haben sind.

Dieser FS1000A 433MHz Receiver kann mit einer zusätzlichen Antenne beträchtliche Strecken überbrücken. Er ist einfach anzuwenden da er TTL Pegel in 433MHz Trägersignale umwandelt.

Das ist für eine Programmierung mit einem µC optimal.

 

 


Testprogramm 433MHz
Es wurde mit dem Anemometer Testprogramm zusammengeführt.

/*

Controlling a Sunblind - Testprogram for sunblind control and anemometer test

Autor: JULE

Datum: 27.8.16

 

Inputs:

"      Windsensor; 1 Pin digital INT

"      Lightsensor; 1 Pin analog (ADC)

"      Tempsensor; 1 Pin digital

"      Endswitch; 2 Pins digital

"      Reset Pin

"      VCC 5V

"      GND

Outputs:

"      433MHz transmitter; 1 Pin digital

"      Alarm Piezo; 1 Pin digital

"      Alarm LED; 1 Pin digital

"      LCD-Display; 7 Pins digital

"      VCC 5V

"      GND

 

1 x ADC input,

1 x digital INT input,

3 x Digital output,

10 x digital output,

1 x Reset, VCC and GND

 

RX TX ! SMS

 

ANEMOMETER

==========

PC7 = Info LED INT0

PC6 = Info LED Timer0 INT

PD2 = Hall encoder input INT0

PD0 OpenCode

PD1 CloseCode

PD3 StopCode

 

433MHZ

======

PC4 433MHz Transmitter (HIGH = on PULLDOWN!)

PC5 LED (LOW = on PULLUP!)

 

LCD

===

E  = B0

RW = B1

RS = B2

D4 = D4

D5 = D5

D6 = D6

D7 = D7

DDRD = 0xF0;

DDRB = 0x07;

*/

 

#define F_CPU 8000000UL

 

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include "lcd.h"

 

uint8_t  iTimerCount = 0;

uint16_t  iINTCount = 0;

 

ISR(TIMER1_OVF_vect);

ISR(INT0_vect);

 

int main(void)

{

 

    DDRC = 0xFF;    //PORTC = output

       PORTC = 0xCF;       //5 and 4 Pulldown

 

       //LCD

       DDRD = 0xF0;

       DDRB = 0x07;

       PORTD = 0xFB;
      
//PD2 = int0; PD0 = switch1; PD1 = switch2;  PD3 = switch; PD4-7 = LCD DATA

       PORTB = 0x07; //PB0-3 = LCD control

 

       char cLCD_val[] = ""; // char Array for LCD Text

 

      

 

       // Bit Code Arrays

      int ArrStop[]  = {1,1,0,1,1,1,1,0,

                  1,1,1,1,1,1,1,0,

                  0,0,1,1,1,1,1,0,

                  0,0,0,1,1,1,1,0,

                  1,0,1,0,1,0,1,0};

      

      int ArrOpen[]  = {1,1,0,1,1,1,1,0,

                  1,1,1,1,1,1,1,0,

                  0,0,1,1,1,1,1,0,

                  0,0,0,1,1,1,1,0,

                  1,1,1,0,1,1,1,0};

      

      int ArrClose[]  = {1,1,0,1,1,1,1,0,

                  1,1,1,1,1,1,1,0,

                  0,0,1,1,1,1,1,0,

                  0,0,0,1,1,1,1,0,

                  1,1,0,0,1,1,0,0};

      

       //INT0

       MCUCR = 1<<ISC01 | 1<<ISC00;      // Trigger INT0 raising

       GICR = 1<<INT0;                                // Enable INT0

 

 

       // Timer0 internal timer interrupt

       TCCR0= (1<<CS02)|(1<<CS00);            
       
//prescaler 1024 with 8 BitTimer0 -> 1Mhz/ 1024 / 255 = 3.8 times per sec                                               

       TIMSK= (1<<TOIE0);                // activating timer0 overflow interrupt

 

       sei();                                               // Enable Interrupts

      

       //LCD Start

       LCDInit(LS_NONE); // LCD Cursor off

       LCDHome(); //Cursor to 0,0

       LCDClear(); //LCD clear

       LCDWriteString("Anemometer test"); // LCD Text

       LCDGotoXY(0,1); //col, line

       LCDWriteString("(c) 2016 JULE"); // LCD Text

       _delay_ms(50); //wait 50ms

       LCDHome();

       LCDClear();

                                                                    

       while(1) //main loop

       {

             // LCD Display Rounds per timer0 Interrupt

             LCDGotoXY(0,0); //col, line

             sprintf(cLCD_val,"Umdrehungen: %d ",iINTCount);

             LCDWriteString(cLCD_val); // LCD Text

             _delay_ms(200);

 

 

             //Close command

             if(!(PIND & (1 << PD1))) // Switch S1

             {

                    _delay_ms(25); //debounce

 

                    if(!(PIND & (1 << PD1)))

                    {

                           cli(); // !! Disable alle interrups!

 

                           LCDGotoXY(0,1); //col, line

                           LCDWriteString("CloseCode    "); // LCD text

                                  for(int k = 0; k < 20; k++) // send 20 times

                                  {

 

                                        //startsequence 7750L 4750H 1500L = 14000us

                                        if((k == 0) || (k % 2 == 0))

                                        {

                                        _delay_us(7750);

                                        }

                                        PORTC |= (1<<PC4); // 433MHz HIGH

                                        _delay_us(4750);

                                        PORTC &= ~(1<<PC4); // 433MHz LOW

                                        _delay_us(1500);

                                        for(int i = 0; i < 40; i++)
                                         
// 5 Bytes = 40 elements in array

                                        {

 

                                                                                             

                                               if(ArrClose[i] == 0) // send Bit 0

                                               {

                                                       PORTC |= (1<<PC4);
                                                       
// 433MHz HIGH

                                                      _delay_us(667); //HIGH 667

                                                      PORTC &= ~(1<<PC4); // 433MHz

                                                      _delay_us(333); //LOW 333

                                                     

                                               }

                                               else // send Bit 1

                                               {

                                                      PORTC |= (1<<PC4);
                                                     
// 433MHz HIGH

                                                      _delay_us(333); //HIGH 333

                                                     

                                                      PORTC &= ~(1<<PC4); // 433MHz

                                                      _delay_us(667); //LOW 667

                                                     

                                               }

      

                                        }

 

                                  }

                           LCDGotoXY(0,1); //col, line

                          LCDWriteString("CloseCode sent  "); // LCD text

                           _delay_ms(100);

                           sei(); //enable interrupts

                           }

                    }// end Close Command

 

 

             //Stop command

             if(!(PIND & (1 << PD3))) // Switch S1

             {

                    _delay_ms(25); //debounce

 

                    if(!(PIND & (1 << PD3)))

                    {

                           cli(); // !! Disable alle interrupts!

 

                           LCDGotoXY(0,1); //col, line

                           LCDWriteString("StopCode    "); // LCD text

                                  for(int k = 0; k < 20; k++) // send 20 times

                                  {

 

                                        _delay_us(7750);

                                        PORTC |= (1<<PC4); // 433MHz HIGH

                                        _delay_us(4750);

                                        PORTC &= ~(1<<PC4); // 433MHz LOW

                                        _delay_us(1500);

                                        for(int i = 0; i < 40; i++)
                                       
// 5 Bytes = 40 elements in array

                                        {

 

                                                                                             

                                               if(ArrStop[i] == 0) // send Bit 0

                                               {

                                                                                             

                                                      PORTC |= (1<<PC4);
                                                      
// 433MHz HIGH

                                                      _delay_us(667); //HIGH 667

                                                      PORTC &= ~(1<<PC4); // 433MHz

                                                      _delay_us(333); //LOW 333

 

                                               }

                                               else // send Bit 1

                                               {

                                                      PORTC |= (1<<PC4);
                                                       
// 433MHz HIGH

                                                      _delay_us(333); //HIGH 333

                                                      PORTC &= ~(1<<PC4); // 433MHz

                                                      _delay_us(667); //LOW 667

                                               }

      

                                        }

 

                                  }

                           LCDGotoXY(0,1); //col, line

                           LCDWriteString("StopCode sent  "); // LCD text

                           _delay_ms(100);

                           sei(); //enable interrups

                           }

                    }// end Stopp Command

 

 

             //OPEN command

             if(!(PIND & (1 << PD0))) // Switch S1

             {

                    _delay_ms(25); //debounce

 

                    if(!(PIND & (1 << PD0)))

                    {

                           cli(); // !! Disable alle interrupts!

 

                           LCDGotoXY(0,1); //col, line

                           LCDWriteString("OpenCode    "); // LCD text

                                  for(int k = 0; k < 20; k++) // send 20 times

                                  {

                                        //startsequence 7750L 4750H 1500L = 14000us

                                        if((k == 0) || (k % 2 == 0))

                                        {

                                        _delay_us(7750);

                                        }

                                        PORTC |= (1<<PC4); // 433MHz HIGH

                                        _delay_us(4750);

                                        PORTC &= ~(1<<PC4); // 433MHz LOW

                                        _delay_us(1500);

                                       

                                        for(int i = 0; i < 40; i++)

                                         // 5 Bytes = 40 elements in array

                                        {

                                                                                             

                                               if(ArrOpen[i] == 0) // send Bit 0

                                               {

                                                                                      

                                                      PORTC |= (1<<PC4);
                                                     
// 433MHz HIGH

                                                      _delay_us(667); //HIGH 667

                                                      PORTC &= ~(1<<PC4); // 433MHz

                                                      _delay_us(333); //LOW 333

                                               }

                                               else // send Bit 1

                                               {

                                                      PORTC |= (1<<PC4);

                                                      // 433MHz HIGH

                                                      _delay_us(333); //HIGH 333

                                                      PORTC &= ~(1<<PC4); // 433MHz

                                                      _delay_us(667); //LOW 667

                                               }

      

                                        }

 

                                  }

                           LCDGotoXY(0,1); //col, line

                           LCDWriteString("OpenCode sent   "); // LCD text

                           _delay_ms(100);

                           sei(); //enable interrupts

                           }

                    }// end Open Command

 

 

       } //end main loop

 

return 0;

} // end main function

 

ISR(TIMER0_OVF_vect) //Timer0 overflow interrupt

{

       iTimerCount++;

       if (iTimerCount >= 16) // 3,8 * 16 = every 4.1 seconds

       {                         

             //Timer LED

             PORTC &= ~(1<<PC6);

             _delay_ms(2);

             PORTC |= (1<<PC6);

 

             iTimerCount = 0;

             iINTCount = 0;                 

       }           

}

 

ISR(INT0_vect)  //interrupt INT0  

{

       iINTCount++;

 

       // INT0 LED 

       PORTC &= ~(1<<PC7);

       _delay_ms(1);

       PORTC |= (1<<PC7);

       _delay_ms(1);

}

 

 

    

 

Zum Seitenanfang

 

Entwicklung

DHT11 Temperatur- und Luftfeuchtesensor

Der Temperatur Sensor DHT 11 kann mit 5V Spannung betrieben werden und liefert die aktuelle Temperatur in °C sowie die relative Luftfeuchte in %. Es existiert eine Library für AVR µC sodass er sehr einfach programmiert werden kann.

 

 

 

Testprogramm DHT11

             //DHT11

                    uint8_t iCurrTemp;

                    uint8_t iCurrHum;

 

                    iCurrTemp = dht11_gettemperature(); //dht11.h

                    iCurrHum = dht11_gethumidity();

 

                    LCDGotoXY(0,1); //col, line

                    sprintf(cLCD_val,"T: %i%cC H: %i",iCurrTemp,"167",iCurrHum);

                    LCDWriteString(cLCD_val); // LCD Text

 

Zum Seitenanfang

 

Entwicklung

Programmcode V1.0 (Beta) inkl. GSM

Hier der vorerst fertige Programmcode V1.0 (Beta). Als zusätzliches Feature ist hier das SMS versenden über UART mit einem GSM Modul , schon implementiert.

 

Lauffähiges Programm für ATMEGA16

/*

===============================

Controlling a Sunblind

Autor: JULE Juergen Lessner

Datum: 12.09.2016

Version 1.0

===============================

 

1 x ADC input LDR

1 x digital INT input ANEMO

3 x Digital output DHT11 ENDSWITCHES

10 x digital output LCD LED PIEZO 433MHZ

RxTx  GSM SMS

1 x Reset, VCC and GND

 

ANEMOMETER

==========

PC7 = Info LED INT0 (DEBUGGING)

PC6 = Info LED Timer0 INT (DEBUGGING)

PD2 = Hall encoder input INT0

 

433MHZ

======

PC4 = 433MHz Transmitter output (needs PULLDOWN!)

 

DHT11

=====

PC5 = Temperature and Humidity input

 

LDR

===

PA0 = ADC input Light intensity

 

ENDSWITCH

=========

PC3 = LEFTSWITCH

PC2 = RIGHTSWITCH

 

GSM

===

PD0 = RX

PD1 = TX

 

ALERT

=====

LED

PIEZO

 

DEBUG LCD

=========

E  = B0

RW = B1

RS = B2

D4 = D4

D5 = D5

D6 = D6

D7 = D7

DDRD = 0xF0;

DDRB = 0x07;

*/

 

 

/*

TODOs

===================================

TODO calibrate windspeed ( km/h) //control values

TODO add Windspeed, Temp and Light info to SMStext

TODO write proper codeheader

===================================

*/

 

#define F_CPU 8000000UL

 

#define LCDCONF //for lcd.h setup

 

#include <avr/io.h>

#include <avr/interrupt.h>

#include <util/delay.h>

#include "lcd.h"

#include "dht11.h"

#include <string.h>

#include <stdlib.h>

 

 

 

#define RADIOPORT   PORTC

#define RADIOPIN    PC4

#define LDRPIN             0      //PORTA -> ADC

#define ENDSWPORT   PINC

#define ENDSWRIGHT  PC2

#define ENDSWLEFT   PC3

 

 

//control values

#define CLOSEWINDSPEED 12 //Windspeedvalue - must close immediately !

#define MAXOPENWINDSPEED 10 // max windspeedvalue for opening

#define HYSTERESISTIME 10 // in minutes for reopening after emergency close or normally close

#define OPENTEMP 28 //TempValue - must for opening

#define CLOSETEMP 25 //TempValue - close because too cold

#define OPENLIGHT 850 //Lightvalue - must for openenig (>840 = cloudless in Sept)

#define CLOSELIGHT 400 //Lightvalue - close because too dark

#define OPERATINGTIME  30 // operating time for open or close in sec.

#define TRUE 1

#define FALSE 0

 

//UART

#define BAUD        9600 //BAUD RATES tested: 1200, 2400, 9600, 19200, 38400

#define UBBR_VAL    ((F_CPU)/(BAUD*16UL)-1)  //calculating UBBR Value

#define UART_MAXSTRLEN 25                             //serial input stringbuffer lenght

 

//global

uint8_t giIsClosed = FALSE; // Flag Open = 0, closed = 1.

uint8_t  giTimerCount = 0;

uint16_t giINTCount = 0;

uint16_t giCurrWindSpeed = 0;

uint16_t giMaxWindSpeed = 0;

uint8_t giTimer0StartValue = 60; //Timer0 Start Value ->

// Timer Start Value Calc: 255-60 = 195; 8000000Hz = 0.125us per clockpulse * 195 * 1024 = ca. 25ms * 40 = ca. 1000ms = 1 sec * 4 = ca. 4 sec.

// Timer Setting for 4 seconds: 8 Bit timer -> startvalue = 60; prescaler = 1024; TimerCountLoop = 40*4 = 160 times.

char cLastWindSpeed[30];

uint16_t iLastWindIndex = 0;

uint16_t iLastWindCounter = 0;

 

//UART global

volatile uint8_t uartStringComplete = 0;     // 1 if String has received completely

volatile uint8_t uartStringCount = 0;

volatile char uartString[UART_MAXSTRLEN + 1] = "";

char cPhonenumber[] = "004366XXXXXXXXX8"; // Phonenumber where SMS should be sent to

 

 

//ISR routines

ISR(TIMER0_OVF_vect);

ISR(INT0_vect);

ISR(USART_RXC_vect);

 

//functions

void sendRadioCommand(uint8_t iCommand, uint16_t iRepeation); // iCommand: 0 = Stop, 1 = Open, 2 = Close

void doAlert(uint8_t iErrorcode); // iErrorcode : 0, 1, 2, 3

// 0 = noAlert SMS "Status: Wind, Temp, Light,opened/closed" , 1 = Warning Alert: Buzzer and LED, 2 = Alert: Buzzer, LED, SMS "Sunbeam could not be closed",

// 3 = Alert: SMS "Sunbeam could not be opened",

void sendSMS(char cSMStext[]); //send SMS -> itype: 0, 1, 2, 3

 

void uartInit(void);

uint8_t uartWriteChar(unsigned char cWriteChar);

void uartWriteString(volatile char * sWriteString);

 

int main(void)

{

    DDRA = 0x00;    // ADC in

       DDRC = 0xF3; //PORTC = output ; PC2 PC3 = Input

       PORTC = 0xC3;       //5, 4, 3, 2 Pulldown

 

       // DEBUG LCD

       DDRD = 0xF0;

       DDRB = 0x07;

       PORTD = 0xF8; //PD2 = int0; PD0 = RX; PD1 = TX; PD4-7 = LCD DATA

       PORTB = 0x07; //PB0-3 = LCD control

 

       char cLCD_val[] = ""; // char Array for LCD Text

       uint16_t iLoops = 0; //Loop Counter for Temp and Light for less running

       uint8_t iEmergencyClose = 0; // Flag for emergency close

 

       //DHT11

       uint8_t iCurrTemp = 0;

       uint8_t iCurrHum = 0;

 

       //LDR

       uint16_t iLDRVal = 0;

       uint8_t iAdcLow = 0;

 

       //Anemometer

       uint16_t iLastWindSpeed = 0;

       uint16_t iWindSpeed = 0;

 

       //ADC

       ADCSRA |= (1 << ADSC) | (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1); // Prescale 64 for 8MHz

 

       //UART

        uartInit(); //initialize UART

      

       //INT0

       MCUCR = 1<<ISC01 | 1<<ISC00;      // Trigger INT0 raising

       GICR = 1<<INT0;                                // Enable INT0

 

    // Timer0 internal timer interrupt

       TCNT0 = giTimer0StartValue; //set startvalue for timer0

       TIMSK= (1<<TOIE0);                // activating timer0 overflow interrupt

       TCCR0= (1<<CS02)|(1<<CS00);             //prescaler 1024 and start timer0

 

    sei();                                            // Enable Interrupts

      

       // DEBUG LCD Start

       LCDInit(LS_NONE); // LCD Cursor off

       LCDHome(); //Cursor to 0,0

       LCDClear(); //LCD clear

       LCDWriteString("Sunblind Control"); // LCD Text

       LCDGotoXY(0,1); //col, line

       LCDWriteString("V1.0(c)2016 JULE"); // LCD Text

       _delay_ms(50); //wait 50ms

       LCDHome();

       LCDClear();

 

       //Safety closing at beginning

       sendRadioCommand(2, 20);

       _delay_ms(OPERATINGTIME * 1000);//wait for closing

       if(!(ENDSWPORT & ENDSWRIGHT) && !(ENDSWPORT & ENDSWLEFT)) // check if Sunbeam is closed - if not closed

       {

             doAlert(2); //ALERT

       }

       else

       {

             giIsClosed = TRUE;

       }

                                                                    

       while(1) //main loop

       {

           // DEBUG LCD Display Rounds per 4 Seconds (timer0 Interrupt)

             LCDGotoXY(0,0); //col, line

             sprintf(cLCD_val,"W:%d",giINTCount);

             LCDWriteString(cLCD_val); // LCD Text

            

             if((iLoops == 0) || (iLoops >= 10000))

             {

                    //LDR

                    ADMUX = 0x20 + LDRPIN; //select Pin

                    ADCSRA |= (1<<ADSC); //read ADC

                    while((ADCSRA &(1<<ADIF)) == 0); //wait till ready

                    iAdcLow = ADCL;

                    iLDRVal = ADCH << 2 | iAdcLow >> 6; // BitShift ADC Value

 

                    // DEBUG LCD

                    LCDGotoXY(6,0); //col, line

                    sprintf(cLCD_val,"L:%i",iLDRVal);

                    LCDWriteString(cLCD_val); // LCD Text

 

                    //DHT11

                    iCurrTemp = dht11_gettemperature();

                    iCurrHum = dht11_gethumidity();

 

                    // DEBUG LCD

                    LCDGotoXY(12,0); //col, line

                    sprintf(cLCD_val,"T: %i    ",iCurrTemp);

                    LCDWriteString(cLCD_val); // LCD Text

 

                    if (iLoops >= 10000)

                    {

                           iLoops = 0;

                    }           

 

             }

             iLoops++;

 

             iLastWindSpeed = iWindSpeed; //TODO timer for Last WindSpeed ..

             iWindSpeed = giCurrWindSpeed;

            

             //EmergencyClose

             if((iWindSpeed >= CLOSEWINDSPEED) || (iCurrTemp <= CLOSETEMP) || (iLDRVal <= CLOSELIGHT))

             {

                    iEmergencyClose = 1;

                    if((ENDSWPORT & ENDSWRIGHT) && (ENDSWPORT & ENDSWLEFT)) // if Sunbeam is opend

                    {

                           // DEBUG LCD

                           LCDGotoXY(0,1); //col, line

                           sprintf(cLCD_val,"closing         ");

                           LCDWriteString(cLCD_val); // LCD Text

 

                           sendRadioCommand(2, 20); //close

                           sendRadioCommand(2, 20);

                           sendRadioCommand(2, 20);

                           for (uint8_t i = 0; i < 10; i++)

                           {

                                  _delay_ms(OPERATINGTIME*1000/10);//wait for closing

                                  if((ENDSWPORT & ENDSWRIGHT) && !(ENDSWPORT & ENDSWLEFT))

                                  {

                                        i = 10; // if closed -> end for loop

                                  }

                   

                           }

                          

                           if(!(ENDSWPORT & ENDSWRIGHT) && !(ENDSWPORT & ENDSWLEFT)) // check if Sunbeam is closed - if not closed

                           {

                                  doAlert(2); //ALERT

                                  // DEBUG LCD

                                  LCDGotoXY(0,1); //col, line

                                  sprintf(cLCD_val,"ALERT NOT CLOSED");

                                  LCDWriteString(cLCD_val); // LCD Text

                           }

                           else

                           {

                                  giIsClosed = TRUE;

                                  // DEBUG LCD

                                  LCDGotoXY(0,1); //col, line

                                  sprintf(cLCD_val,"closed          ");

                                  LCDWriteString(cLCD_val); // LCD Text

                           }

                    }

             }

            

            

             //Open Logic after iEmergencyClose

             if (iEmergencyClose == 1)

             {

                    //gets giMaxWindSpeed from last  mins till now

                    for (uint8_t i = 0; i < 50; i++)

                    {

                           _delay_ms(HYSTERESISTIME*1000/50);

                           //check last and current windspeed ...???

                           char cSearchString[4];

                           itoa(CLOSEWINDSPEED, cSearchString,10);

                           if(strstr(cLastWindSpeed,cSearchString) == 0) //checks windspeed from last 30 Mins

                           {

                                  //if everything is fine reset emergency

                                  iEmergencyClose = 0; // reset iEmergencyClose

                           }

                    }

             }

             if (iEmergencyClose == 0)

             {

                    if((iLDRVal >= OPENTEMP) && (iCurrTemp >= OPENLIGHT)) //check temp light if opening is necessary

                    {

                           if((iLastWindSpeed <= MAXOPENWINDSPEED) && (iWindSpeed <= MAXOPENWINDSPEED) && (giMaxWindSpeed <= MAXOPENWINDSPEED)) // check windspeed MAXOPENWINDSPEED CLOSEWINDSPEED if opening is possible

                           {

                                  if(!(ENDSWPORT & ENDSWRIGHT) && !(ENDSWPORT & ENDSWLEFT)) // if Sunbeam is closed

                                  {

                                        // DEBUG LCD

                                        LCDGotoXY(0,1); //col, line

                                        sprintf(cLCD_val,"opening         ");

                                        LCDWriteString(cLCD_val); // LCD Text

                                        sendRadioCommand(2, 5); //open

                                        _delay_ms(OPERATINGTIME);//wait for closing

                                        if((ENDSWPORT & ENDSWRIGHT) && (ENDSWPORT & ENDSWLEFT)) // check if Sunbeam is open - if not opened

                                        {

                                               doAlert(3); //ALERT

                                               // DEBUG LCD

                                               LCDGotoXY(0,1); //col, line

                                               sprintf(cLCD_val,"ALERT NOT OPENED");

                                               LCDWriteString(cLCD_val); // LCD Text

                                        }

                                        else

                                        {

                                               giIsClosed = FALSE;

                                               // DEBUG LCD

                                               LCDGotoXY(0,1); //col, line

                                               sprintf(cLCD_val,"opened          ");

                                               LCDWriteString(cLCD_val); // LCD Text

                                        }

                                  }

                           }                         

                    }

             }

       } //end main loop  

return 0;

} // end main function

 

// ISR Functions

ISR(TIMER0_OVF_vect) //Timer0 overflow interrupt

{

       cli(); //interrups off

       TCNT0 = giTimer0StartValue; //set startvalue for timer0

 

       giTimerCount++;

       if (giTimerCount >= 160) // ca. 4 sec.

       {                         

             giCurrWindSpeed = giINTCount;

             giTimerCount = 0;

             giINTCount = 0;            

       }

       if(iLastWindCounter >= 15) // every 1 min.

       {

             if(giCurrWindSpeed >= CLOSEWINDSPEED)

             {

                    cLastWindSpeed[iLastWindIndex] = CLOSEWINDSPEED;

             }

             else

             {

                    cLastWindSpeed[iLastWindIndex] = giCurrWindSpeed;

             }

 

             iLastWindCounter = 0;

       }

       iLastWindIndex++;

       iLastWindCounter++;

       if(iLastWindIndex >= 29)

       {

             iLastWindIndex = 0; //reset Arrayindex

       }

       sei(); //interrups on            

}

 

// interrupt INT0  

ISR(INT0_vect) 

{

       giINTCount++;

}

 

//USART RX interrupt

ISR(USART_RXC_vect) //RX interrupt vector

{

       cli();

       unsigned char cNextChar;

 

       // Read Data form Buffer

       cNextChar = UDR;

       if( uartStringComplete == 0 ) // if uartString currently used, drop char

       {     

             // puts Data in uartString if NOT (\0 OR \n OR \r) AND NOT UART_MAXSTRLEN

             if((cNextChar != '\n') &&  (cNextChar != '\r') && (uartStringCount < UART_MAXSTRLEN))

             {

                    uartString[uartStringCount] = cNextChar;

                    uartStringCount++;

             }

             else

             {

                    uartString[uartStringCount] = '\0'; // appends \0

                    uartStringCount = 0;

                    uartStringComplete = 1;

             }

       }

       sei();

}

 

// Functions

void sendRadioCommand(uint8_t iCommand, uint16_t iRepeation)

{

       char ArrStop[]  = {1,1,0,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,1,0,1,0,1,0,1,0,1,0};

       char ArrOpen[]  = {1,1,0,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,1,0,1,1,1,0,1,1,1,0};

       char ArrClose[]  = {1,1,0,1,1,1,1,0,1,1,1,1,1,1,1,0,0,0,1,1,1,1,1,0,0,0,0,1,1,1,1,0,1,1,0,0,1,1,0,0};

       char CurrArr[40];

       switch(iCommand)

       {

       case 0:

             strncpy(CurrArr, ArrStop, 41);

             break;

       case 1:

             strncpy(CurrArr, ArrOpen, 41);

             break;

       case 2:

             strncpy(CurrArr, ArrClose, 41);

             break;

       default:

             strncpy(CurrArr, ArrClose, 41);

             break;

       }

       cli();

       for(uint16_t iCount = 0; iCount < iRepeation; iCount++)

       {

             if((iCount == 0) || (iCount % 2 == 0))

             {

                    _delay_us(7750);

             }

             RADIOPORT |= (1<<RADIOPIN);

             _delay_us(4750);

             RADIOPORT &= ~(1<<RADIOPIN);

             _delay_us(1500);

             for(int i = 0; i < 40; i++)

             {                                                                                     

                    if(CurrArr[i] == 0)

                    {

                           RADIOPORT |= (1<<RADIOPIN);

                           _delay_us(667);

                           RADIOPORT &= ~(1<<RADIOPIN);

                           _delay_us(333);

                    }

                    else

                    {                  

                    RADIOPORT |= (1<<RADIOPIN);

                    _delay_us(333);                                                   

                    RADIOPORT &= ~(1<<RADIOPIN);

                    _delay_us(667);

                    }     

             }

       }

       sei();

       doAlert(0); // Status SMS

}

 

void doAlert(uint8_t iErrorcode) // Windspeed , Light and Temp missing

{

char cSMStext[] =  "TEST TEST TEST    ";

char cSMStext0[] = "STATUS INFORMATION";

char cSMStext1[] = "WARNING           ";

char cSMStext2[] = "ALERT NOT CLOSED  ";

char cSMStext3[] = "ALERT NOT OPENED  ";

 

       switch(iErrorcode)

       {

             case 0:

                    // status SMS

                    strncpy(cSMStext, cSMStext0, 19);

                    sendSMS(cSMStext);

                   

                    break;

             case 1:

                    // Warning Alert

                    strncpy(cSMStext, cSMStext1, 19);

                    sendSMS(cSMStext);

                   

                    break;

             case 2:

                    // could not be closed

                    strncpy(cSMStext, cSMStext2, 19);

                    sendSMS(cSMStext);

                   

                    break;

             case 3:

                    // could not be opened

                    strncpy(cSMStext, cSMStext3, 19);

                    sendSMS(cSMStext);

                   

                    break;

             default:

                    // Status SMS

                    sendSMS(cSMStext);

                   

                    break;

       }

}

 

void sendSMS(char cSMStext[])

{

       cli();

       //Sequence Send SMS

       uartWriteString("AT\n\r");

       if(uartStringComplete == 1)

             {

                    if(strncmp(uartString, "OK",2) == 0)

                    {

                           uartWriteString("AT+CMGF=1\r\n");

                           uartWriteString("AT+CMGS=\"");

                           uartWriteString(cPhonenumber);

                           uartWriteString("\"\r\n");

                           uartWriteString(cSMStext);

                           uartWriteString("\r\n");

                           uartWriteString("\033");//octal ESC = SMS_END

                    }

                    else

                    {

                           //LCD Message "SMS not sent"

 

                    }

                    uartStringComplete = 0;

             }

             _delay_ms(10);

       sei();

}

void uartInit(void)

{

       UBRRH = UBBR_VAL >> 8;

       UBRRL = UBBR_VAL & 0xFF;

       UCSRB |= (1<<TXEN) | (1<<RXEN) | (1 << RXCIE); //UART TX, RX enabled, RX Interrupt enabled;

       UCSRC |= (1<<URSEL)|(1 << UCSZ1) | (1 << UCSZ0); //async 8N1

}

 

uint8_t uartWriteChar(unsigned char cWriteChar)

{

       while (!(UCSRA & (1<<UDRE))); //wait till send

       UDR = cWriteChar;

       return 0;

}

 

void uartWriteString(volatile char * sWriteString)

{

       while (* sWriteString) //till \0

       {

             uartWriteChar(* sWriteString);

             sWriteString++;

       }

}

 

 

 

Zum Seitenanfang

Notizen...

Pinbelegung:

1.       Rot = VCC

2.       Grün = Temp / Hum

3.       Gelb = LDR / Licht

4.       Violett = Hall / Wind

5.       Schwarz = GND