Der 1-Wire Bus

Die bekannten Temperatursensoren DS18x20,  lassen sich über den 1-Wirebus von Maxim / Dallas (der nur 1 Portpin des MC belegt) auslesen. Sogar die Leitung für die +5 Volt Stromversorgung kann man einsparen, so das ein 2poliges Kabel (Daten und Gnd) vom Controller zum Sensor genügt. Im Datenblatt des DS18B20 (ab Seite 5) nennt Maxim diese Betriebsart Parasite Powered. In dieser Betriebsart "stiehlt" der DS18x20 seinen Strom von der Datenleitung, wenn diese gerade auf High ist. Geht der 1-Wire Bus auf Low, übernimmt dann ein zuvor geladener Kondensator der sich im Sensor befindet, kurzzeitig die Versorgung.
Durch die vielen Features des 1-Wirebus, ist allerdings auch mehr Wissen erforderlich und die Programmierung ist wesentlich aufwendiger als z.B bei einem TSIC 206/306, der ja auch nur eine Datenleitung Besitzt. Man muss eben mit einem Bus kommunizieren, und nicht mit einem einzelnen Temperatursensor, auch wenn nur ein Sensor am Bus ist ;-).
Da der 1-Wirebus ähnlich einer I2C oder TWI funktioniert, können gleich mehrere Sensoren an die Datenleitung des 1-Wirebus angeschlossen werden. Maxim bietet nicht nur Temperatursensoren für den 1-Wirebus an, sondern auch EEproms A/D Wandler und Porterweiterungen, um nur einige zu nennen. Diese können dann alle an dem einen Portpin angeschlossen werden und vom µC über den 1-Wirebus angesteuert und ausgelesen werden.

Hier mein Aufbau auf einem Breadboard, den ich mir zum programmieren  aufgebaut habe. 
Den 1-Wire Bus habe ich nachträglich  eingefärbt (DQ in orange und Gnd in blau)

Die DS18B20 und 18S20 Temperatursensoren...

... unterscheiden sich Hauptsächlich in der Auflösung die von 9 bis 12 Bit reicht. Der DS18S20 ist eigentlich für eine 9 Bit Auflösung vorgesehen. Ein kleiner Hinweis im DS18S20 Datenblatt (Seite 3, unten) beschreibt wie man aus dem Sensor auch 12 Bit auslesen kann. Dazu reicht ein bisschen Bitschieben und rechnen.
Der DS18B20 wird "Werksseitig" mit 12 Bit Auflösung ausgeliefert. Die hohe Auflösung hat allerdings ihren Preis. Die Wandlungszeit steigt quadratisch, mit jedem Bit. Allerdings kann der Programmierer daran noch drehen. Im Konfigurationsregister des DS18B20 kann über 2 Bits die Auflösung von 9..12 Bit und somit die Wandlungszeit von ca. 94..750mS eingestellt werden. 
In meinem Programm nehme ich die 750mS Wandlungszeit in kauf und nutze somit die volle Auflösung von 12 Bit beider Sensoren, wobei man den DS18S20 im Quellcode auch mit den vorgesehenen 9 Bit konfigurieren kann. Da der Sensor während der Wandlung mehr Strom zieht (ca. 1,5mA), müssen auch Wartezeiten (ca. 5 Sekunden) zwischen den Wandlungen eingehalten werden, um das Messergebniss nicht durch Eigenerwärmung zu verfälschen.
Die DS18B20/DS18S20 haben beide eine Genauigkeit (nicht zu Verwechseln mit der Auflösung) von +/- 0,5°C im Temperaturbereich von -10°C bis +85°C und sind schon kalibriert. Die gesamte Range der beiden Sensoren geht von -55°C bis zu 125 °C.

Die Hardware

Auch hier habe ich wie schon beim TSIC-Thermometer die kleine Portview Platine verwendet, obwohl ich zugeben muss, das zu überlegen gewesen währe ein LCD zu benutzen, um dann mehrere Temperaturen gleichzeitig anzeigen zu können. Jedoch hat (für mich jedenfalls), eine 7-Segmentanzeige den Vorteil, das man diese auch noch aus der Ferne, mit einem Blick, sehr gut ablesen kann. In meinem Aufbau nutze ich insgesamt 4 DS18x20 Sensoren. Zwei mal den 18B20 und zwei 18S20. Die Anzahl der verwendeten Sensoren lässt sich problemlos auf über 20 erweitern. Im Normalbetrieb werden die Sensoren der Reihe nach ausgelesen und auf dem Display angezeigt. Zuerst erscheint ein kleiner Infotext um welchen Sensor es sich handelt, danach wird die Temperatur für eine einstellbare Zeit auf dem Display angezeigt. Zusätzlich kann man jedem Sensor (optional) eine der 5 LEDs zuordnen, die dann leuchtet, solange solange die Temperatur von diesem angezeigt wird. Ich habe meinen 4 Sensoren 4 verschiedenfarbige LEDs zugeordnet und kann somit mit einem Blick erkennen, welche Temperatur gerade angezeigt wird.
Da eine 7-Segmentanzeige ja nicht alle Buchstaben vernünftig darstellen kann, ist bei der Auswahl des Infotext etwas Phantasie gefragt. Ich habe die Strings "out"," in","SCH" und "FLU" für Aussentemperatur, Innentemperatur, Schlafzimmer und Flur zugeordnet.

Auf der Skizze oben, sieht man wie die Platine des Portview-Moduls verkabelt werden muss.
Die Vorwiderstände müssen je nach verwendeter LED  berechnet werden.

Mit dem angeschlossenen Taster, kann man die einzelnen Sensoren "durchzappen". Jeder Tastendruck schaltet einen Sensor weiter, um am Ende wieder beim ersten Sensor zu beginnen. Ist der gewünschte Sensor ausgewählt, wird nur noch dieser Sensor ausgelesen, die Anzeige bleibt bei diesem Sensor stehen. Will man wieder zum automatischen durchschalten der Anzeige zurückkehren, drückt man den Taster 2 mal kurz hintereinander (Doppelklick). In der Skizze sieht man noch den für den 1-Wire Bus nötigen 4,7K Pullup-Widerstand und den Vorwiderstand für den Dezimalpunkt der an PC5 angeschlossen wird.
Der im Datenblatt verwendete Mosfet Transistor für die parasitäre Stromversorgung, wird in meiner Schaltung nicht verwendet, da ein Portpin des Mega8/48 die geforderten 1,5mA die während der Wandlungszeit erforderlich sind, problemlos liefern kann. Zur Sicherheit, lasse ich im Programm jeden Sensor einzeln wandeln, da sich die geforderten 1,5 mA mit jedem weiteren Sensor addieren würden.

Die Software

Ist in Assembler geschrieben. Dazu habe ich das AVR-Studio 4.19 verwendet. Durch die vielfältigen Möglichkeiten, kann ich zum DS18x20-Thermometer leider keine fertige hex Datei liefern. Das Programm ist so geschrieben, dass man im oberen Teil des Quellcodes, durch ändern von ein paar Parametern, das Thermometer nach seinen eigenen Wünschen konfigurieren kann.   Beim assemblieren (Build oder F7), wird dann durch bedingte Assemblierung, das Programm abhängig von den oben gemachten Eingaben übersetzt. Danach ist die brennfertige Hex-Datei auf der Festplatte verfügbar und kann in den AVR geladen werden. 
Zum konfigurieren des DS-Thermometer sind keine Programmierkentnisse erforderlich, allerdings sollte man sich etwas mit dem AVR-Studio vertraut machen.

Im Quellcode kann man im oberen Teil, folgende Einstellungen machen:

• µC. Das Programm für einen ATMega8 oder für einen ATMega48 übersetzen
• Stromversorgung der Sensoren. Normal oder Parasite
• Einzelner oder mehrere Sensoren. 
• Wenn einzelner Sensor. DS18S20 oder DS18B20
• Auflösung beim DS18S20. 9 Bit oder 12 Bit
• Wartezeit zwischen den Messungen in Sekunden
• Infotext scrollen. Ein / Aus, Geschwindigkeit

So in etwa sieht der relevante Teil des  Quellcodes aus, wen er ins AVR-Studio 4.19 geladen ist.

;-------------------------------------------------------------------------------------------------------   
;µC. Einen der beiden AVRs auskommentieren
;-------------------------------------------------------------------------------------------------------   
#define mega48
;#define mega8
;-------------------------------------------------------------------------------------------------------   
;Passendes Include File laden
;-------------------------------------------------------------------------------------------------------   
.nolist
#if defined mega48
#include "m48def.inc"
#else
#include "m8def.inc"
#endif
.list
;-------------------------------------------------------------------------------------------------------   
;Stromversorgung des Sensors. Wenn +5V an Pin3(Vcc) des DS18x20 soll, auskommentieren
;-------------------------------------------------------------------------------------------------------   
#define parasite
;-------------------------------------------------------------------------------------------------------   
;Nur einen DS18x20 Anonym (ohne Romcode) auslesen. ACHTUNG, es darf nur ein DS am Bus angeschlossen sein
;-------------------------------------------------------------------------------------------------------   
;#define Anonym     ;Sollen also mehrere DS18x20 mit bekanntem Romcode ausgelesen werden, auskommentieren
;#define DS18S20    ;Wird nur 1 Sensor Anonym ausgelesen, den passenden Sensor definieren    
;#define DS18B20    ;Sollen also mehrere Sensoren ausgelesen werden, beide Sensoren auskommentieren.
;-------------------------------------------------------------------------------------------------------   
;Beim DS18S20 die höhere Auflösung von 12 Bit nutzen
;-------------------------------------------------------------------------------------------------------   
#define DS18S20_Zehntel ;Bei Auskommentierung werden bein DS18S20 nur 9 Bit genutzt
;-------------------------------------------------------------------------------------------------------   
;Wartezeit zwischen den Messungen
;-------------------------------------------------------------------------------------------------------   
.set sekunden   =5 ;Sollte im Single & Anonym Modus min.5 Sekunden sein (Eigenerwärmung der Sensoren)
;-------------------------------------------------------------------------------------------------------
;Infotext rollen. Auskommentieren, wenn nicht gewünscht
;-------------------------------------------------------------------------------------------------------   
#define Scroll_In 
#define Scroll_Out
.set Speed=160      ;Verzögerung in mS. Max. 434
   

Die Auskommentierung einer Zeile wird im AVR-Studio mit einem Semikolon gemacht. Alles was dann nach dem Semikolon folgt, wird in grüner Schrift angezeigt und nicht übersetzt. Diese Funktion ist also nur für den Programmierer gedacht, damit dieser Notizen ins Programm einfügen kann und hat keine Auswirkung auf das später übersetzte Programm. Möchte man z.B. das Programm für einen ATMega 8 assemblieren, ändert man den Quelltext wie folgt:

;-------------------------------------------------------------------------------------------------------   
;µC. Einen der beiden AVRs auskommentieren
;-------------------------------------------------------------------------------------------------------   
;#define mega48
#define mega8

Stromversorgung des DS18x20

Möchte man aus irgendwelchen Gründen keine Parasitäre Spannungsversorgung, kann man durch auskommentieren von ;#define Parasite die normale Stromversorung aktivieren.

Gründe dafür könnten sein:  

• Man möchte mehr als 100°C messen.
• Man fürchtet einen Absturz des µC, währen der "Strong Pullup" aktiv ist und der DS18x20 auf low zieht

1.) Im Datenblatt der Sensoren wird erwähnt, das die parasitäre Versorgung nicht für Messungen über 100 °C geeignet ist. 

2.) Während der Messung, muss bei parasitärer Stromversorgung die Datenleitung zum Sensor auf Ausgang programmiert werden, um die nötigen 1,5 mA zu liefern, die der interne DS18x20- A/D-Wandler zum messen braucht. Stürzt der µC während dieser Zeit ab (z.B. EMV) und der DS18x20 will (aus welchen unwahrscheinlichen Gründen auch immer) einen low Pegel auf die Datenleitung legen, haben wir 2 Ausgänge mit unterschiedlichen Pegeln verbunden, was natürlich nicht lange gut geht .
Für diesen unwahrscheinlichen Fall habe ich den Watchdog des AVRs aktiviert, der alle 500 mS zurückgesetzt werden muss. Geschieht das nicht(z.B bei einem Absturz), löst dieser einen Reset aus der die Ports wieder initialisiert und somit die Datenleitung wieder auf Eingang konfiguriert. Der Kurzschluss kann also im schlechtesten Fall 500mS dauern. Ich selbst, habe die parasitäre Stromversorgung aktiviert.

Nur einen Sensor anschliessen

Bei nur einem Sensor am 1-Wirebus, sollte man ";#define Anonym" in "#define Anonym" ändern. In diesem Fall, ist es zusätzlich nötig, den verwendeten Sensor zu definieren. Werden mehrere Sensoren angeschlossen, bleiben alle 3 betreffende Zeilen Auskommentiert. Bei nur einem Sensor, ist der Taster und die LED(s) natürlich sinnlos, weshalb diese Teile des Codes auch nicht übersetzt werden. Es wird dann fortlaufend die Temperatur dieses einen Sensors auf dem Display angezeigt.

;------------------------------------------------------------------------------------------------------------   
;Nur einen DS18x20 Anonym (ohne Romcode) auslesen. ACHTUNG, es darf nur ein DS am Bus angeschlossen sein
;------------------------------------------------------------------------------------------------------------   
#define Anonym     ;Sollen also mehrere DS18x20 mit bekanntem Romcode ausgelesen werden, auskommentieren
;#define DS18S20    ;Wird nur 1 Sensor Anonym ausgelesen, den passenden Sensor definieren    
#define DS18B20    ;Sollen also mehrere Sensoren ausgelesen werden, beide Sensoren auskommentieren.

Beispiel für einen einzelnen DS18B20 am 1-Wire Bus

Auflösung beim DS18S20

Der DS18S20 ist normalerweise für eine Auflösung von 9 Bit (nur 0,5 hinterm Komma) vorgesehen. Da dieser ursprünglich als Nachfolger für den älteren DS1820 entwickelt wurde, wird aus aus Kompatibilitätsgründen in den Temperaturregistern, nach der Messung ein nur 9 Bit Temperaturwert bereitgestellt, obwohl der DS18S20 intern 12 Bit auflöst. Dallas stellt im Datenblatt eine Formel zur Verfügung um den DS18S20 auf 12 Bit zu erweitern. Man kann im Programm durch " #define DS18S20_Zehntel " die 12 Bitauswertung (0..9 hinterm Komma) aktivieren.

Wartezeit zwischen den Messungen

Wie schon erwähnt, zieht der DS18x20 während der Wandlung bis zu 1,5 mA. Würde man den Sensor permanent wandeln lassen, hätte dies eine Eigenerwärmung zur Folge. Bei meinen Versuchen stellte ich bei fortlaufenden Messungen (polling) eine Eigenerwärmung von bis zu 0,5°C fest. Dieser Fehler wird kleiner, je grösser die Intervalle zwischen den Messungen werden. Ab 5 Sekunden, stellte ich keine Temperaturerhöhungen mehr fest. Im Programm kann bei "  .set sekunden   =5 " die Zeit in Sekunden Festgelegt werden.

Infotext rollen

Spielerei . Hier kann man entscheiden, ob Text einfach normal auf dem Display erscheint, oder von rechts hereingeschoben werden soll..  Mann kann das herein und hinausschieben getrennt einstellen. Die Geschwindigkeit in Millisekunden können in der Speedvariable geändert werden. Sinnvolle Werte sind ~120...250

Mehrere Sensoren am 1-Wire Bus

Hierbei gibt es 2 verschiedene Möglichkeiten.
Man kann mit dem 1-Wirebefehl "Search_Rom" und einem speziellen Suchalgorithmus jeden unbekannten Sensor am Bus ansprechen. Allerdings weiss man dann nicht um welchen Sensor es sich handelt. Da ich bis jetzt das erste mal auf dem 1-Wire Bus unterwegs bin, nutze ich (vorerst ) die 2. und auch einfachere Möglichkeit.
Damit die Software später die einzelnen 1-Wire Komponenten auseinanderhalten kann, hat jeder Baustein eine individuelle Signatur. Im Datenblatt von Dallas/Maxim ist die Rede von einem "64-Bit Lasered ROM Code". Dieser 8 Byte lange Code ist bei jedem Sensor unterschiedlich. Ähnlich wie beim I2C-Bus, kann man mit dieser Bytefolge jeden  Baustein einzeln adressieren.
Bei nur einem DS18x20 am Bus, ist das kein Problem. Maxim stellt für diesen Fall sogar extra den 1-Wire Befehl "Skip-Rom" zur Verfügung. Allerdings darf bei Verwendung von "Skip-Rom" nur ein DS18B20 / DS 18S20 am Bus vorhanden sein, da ja sonst alle Sensoren beim auslesen der Temperatur gleichzeitig Antworten würden, was einen Crash auf dem 1-Wire Bus zur Folge hätte.
Will man also einen bestimmten DS18x20 ansprechen, sendet man also zunächst den 8-Byte langen Rom Code. Leider ist die Signatur  nicht auf den DS18x20 aufgedruckt oder sonstwie ersichtlich. Der Romcode muss ausgelesen werden.  Zu diesem Zweck habe ich in die Software eine kleine Routine eingebaut die diese 8 Bytes ausliest und als Hexzahlen auf dem Display anzeigt.

Um den Romcode eines DS18B20 /DS18S20 auszulesen geht man folgendermaßen vor:

• Zunächst spielt man die Firmware auf. Am besten eine Version in der #define Anonym definiert ist.
• -WICHTIG - Den noch Anonymen Sensor schliesst man als "einzigen Sensor" an den 1-Wire Bus an.
• Man überbrückt mit einem Jumper Pin 1 und 2 von JP1.
• Nach dem einschalten werden dann alle 8 Bytes nacheinander auf dem Display angezeigt.
• - Test - Nach dem abziehen des Jumpers wird die Temperatur des Sensors ausgelesen, so sieht man auch gleich, ob der DS18x20 plausible Werte liefert. 

Wird der Jumper aufgesteckt, erscheint auf der  Anzeige mit "LC0", was soviel wie "Lasered Code 0" bedeutet. Kurz darauf wird für etwa 4..5 Sekunden eine Hexzahl angezeigt (Byte 0) die man sich notiert. Danach wird das Display kurz dunkel und es erscheint "LC1" und kurz darauf Byte 1. Das geht dann so weiter bis zu LC7 um dann wieder mit LC0 zu beginnen. Sind alle 8 Bytes notiert, lässt man die Sequenz zur Sicherheit nochmals durchlaufen um die notierten Werte zu verifizieren.
Diesen Vorgang wiederholt man solange, bis der "64-Bit Lasered ROM Code" aller DS18x20 Sensoren, die an das Thermometer angeschlossen werden sollen, bekannt sind. Jetzt kann man die Hexwerte in den Quellcode einfügen. Natürlich müssen meine Daten entfernt werden.

;*****************************************************************************************
;                               Tabelle der DS18x20 Roms
;*****************************************************************************************
#ifndef Anonym                          ;Bei mehreren Sensoren Assemblieren
.org    flashend-$ff                    ;Ganz hinten rein
RomCode:
;------------------------------------------------------------------------------------------------------
;Sensor 1
;------------------------------------------------------------------------------------------------------
.db $28,$75,$45,$c7,$03,$00,$00,$0d     ;Ein DS18B20 mit Family Code $28
.db _oo,_uu,_t,led0                     ;Infotext "out".LED an PC0 Ein.
;------------------------------------------------------------------------------------------------------
;Sensor 2
;------------------------------------------------------------------------------------------------------
.db $28,$eb,$09,$c7,$03,$00,$00,$67     ;Auch ein 18B20
.db _,_ii,_n,led1                       ;Infotext " in"
; -----------------------------------------------------------------------------------------------------
;Sensor 3
;------------------------------------------------------------------------------------------------------
.db $10,$5b,$74,$35,$02,$08,$00,$af     ;Ein DS18S20
.db _S,_C,_H,led2                       ;Infotext "SCH" für z.B. Schlafzimmer
;------------------------------------------------------------------------------------------------------
;Sensor 4
;------------------------------------------------------------------------------------------------------
.db $10,$c5,$97,$35,$02,$08,$00,$99
.db _F,_L,_U,led3                       ;Infotext "FLU" für Flur
;------------------------------------------------------------------------------------------------------
;Anzahl der Sensoren.(Hier nix machen, wird berechnet)
;------------------------------------------------------------------------------------------------------
.set Anzahl= (PC-RomCode)/6   ;Im Flash wird mit Wortlänge gerechnet, deshalb bei 12 Byte /6
#endif

Jeder Sensor bekommt in der Tabelle einen Datenblock von 12 Bytes zugeordnet. Zuerst werden die 8 Bytes Romcode, den man zuvor ausgelesen hat, eingetragen. Danach folgt ein kleiner Text von 3 Zeichen, der vor dem anzeigen der Temperatur angezeigt wird. In das letzte Byte, wird die LED eingetragen, die leuchten soll, solange der entsprechende Sensor aktiv ist oder eine Null. Es ist wichtig, die länge des Datenblocks von 12 Byte einzuhalten, sonst wird im Programm der Zeiger zum nächsten Datenblock nicht richtig berechnet.
Da nur 5 Leitungen für Leds zur Verfügung stehen, kann man das Led-Byte auch verodern. Bei Eingabe von z.B. "led1|led4"  würden beide Leds leuchten. So könnte man auch eine Duo oder RGB-Led (gemeinsame Anode) verwenden, die dann mit 3 Led-Pins bis zu 7 verschiedene Farben anzeigen könnte.

Da der Romcode im ersten Byte den Familycode enthält, braucht der DS18x20 nicht mehr extra definiert werden. Das ist nur nötig, wenn wie oben beschrieben ein einzelner Sensor ohne Romcode betrieben wird. Das erste Byte, sollte immer mit $10  bei einem DS18S20 oder $28 bei einem DS18B20 beginnen.

Bei den Buchstaben ist man mit einer Siebensegmentanzeige etwas eingeschränkt, da sich auf dieser nicht alle Chars vernünftig darstellen lässt. Hier die Tabelle mit den möglichen Zeichen.

;-------------------------------------------
;Einzelne Segmente
;-------------------------------------------
.equ    a_ = 0b0111111
.equ    b_ = 0b1011111
.equ    c_ = 0b1101111
.equ    d_ = 0b1110111
.equ    e_ = 0b1111011
.equ    f_ = 0b1111101
.equ    g_ = 0b1111110
;-------------------------------------------
;Equates der Chars
.equ _   =  $FF    // Space
.equ _0  =  $81    // 0
.equ _1  =  $CF    // 1
.equ _2  =  $92    // 2
.equ _3  =  $86    // 3
.equ _4  =  $CC    // 4
.equ _5  =  $A4    // 5
.equ _6  =  $A0    // 6
.equ _7  =  $8F    // 7
.equ _8  =  $80    // 8
.equ _9  =  $84    // 9
.equ _A  =  $88    // A
.equ _aa =  $e2    // a
.equ _B  =  $E0    // B
.equ _cc =  $F2    // c
.equ _C  =  $B1    // C
.equ _D  =  $C2    // D
.equ _E  =  $B0    // E
.equ _F  =  $B8    // F
.equ _gg =  $84    // g
.equ _G  =  $A1    // G
.equ _hh =  $E8    // h
.equ _H  =  $C8    // H
.equ _ii =  $EF    // i
.equ _I  =  $CF    // I
.equ _J  =  $C3    // J
.equ _L  =  $F1    // L
.equ _n  =  $EA    // n
.equ _oo =  $E2    // o
.equ _O  =  $81    // O
.equ _P  =  $98    // P
.equ _q  =  $8C    // q
.equ _r  =  $FA    // r
.equ _S  =  $A4    // S
.equ _t  =  $F0    // t
.equ _uu =  $E3    // u
.equ _U  =  $C1    // U
.equ _Y  =  $D8    // Y

Wie man sieht, fehlen die breiteren Buchstaben wie z.B. W und M sowie Buchstaben die einen Schrägstrich beinhalten z.B. Z und K. Bei anderen Buchstaben geht dafür Gross- und Kleinschrift wie z.B. beim O. In Diesem fall wird für ein kleines o der Buchstabe doppelt geschrieben, also _oo.

Download ASM-Quellcode für AVR-Studio 4.19

Da ich meine Programme in Assembler schreibe, benutze ich immer noch die ältere AVR-Studio 4.xx Version. Ich weiss zwar, das es mittlerweile schon AVR-Studio 6.x zu haben ist, sehe aber im Moment keine Vorteile für ASM-Programmierer (ist nur meine persönliche Meinung). Wer Wert auf schönere Piktogramme und Design legt, kann auch die neuste Version herunterladen und den Quellcode für diese Version konvertieren. Leider kann ich dann nicht weiterhelfen, wenn es dann nicht so funktioniert wie gewünscht.

Da mich immer wieder Emails erreichen, wie den ein Assembler Programm in ein AVR geladen wird habe ich hier eine kleine Anleitung angehängt auf die ich dann in Zukunft verlinken kann . 
Wer sich im AVR-Studio schon etwas auskennt, dem genügen wohl schon die Informationen von oben um das DS18x20 Thermometer aufzubauen und braucht nicht mehr  weiterzulesen. 

Neues Projekt erstellen

Hat man das AVR-Studio 4.19 installiert und gestartet, kann man auch gleich ein neues Projekt erstellen.

Hier Atmel AVR Assembler wählen und einen Projektnamen eingeben.

Ein klick auf Finish, öffnet den Editor. Ausserdem legt AVR-Sudio einen Projektordner an und erzeugt in diesem ein Projektfile welches später durch anklicken das Projekt öffnet.

AVR-Studio ist nun Bereit. Nun kann der Quelltext in das Mittlere Fenster kopiert werden. Dazu den Quellcode mit dem Windows Editor öffnen und "ALLES markieren".

Kopieren.

Und in den AVR-Studio Editor kopieren

Um das Programm zu assemblieren (übersetzen) und somit die brennbare Hex-Datei zu erhalten im Menü Build wählen, oder einfach F7 drücken. Hat alles geklappt meldet AVR-Studio im Status Fenster unten, Assembly complete, 0 Errors, 0 Warnings.
Nun befindet sich die brennbare Hex-Datei sowie alle anderen Dateien im Projektordner.

Den AVR programmieren

Den Programmer (in meinem Beispiel der AVR-Dragon) mit der ISP-Pfostenleiste der Hardware und mit dem PC verbinden. Im Tools-Menü  Programm AVR -> Connect wählen um seinen Programmer aus einer Liste auszuwählen. Hat bis dahin alles geklappt, erscheint ein Fenster wie unten.
Zunächst sollte man die Device (den AVR, der am Programmer hängt) auswählen. Danach stellt man den ISP mode ein (ist default) und bei Settings, die ISP Frequenz. Diese sollte maximal 1/4 der µC Frequenz betragen. Langsamer geht immer . Achtung, auch wenn ein 8 MHz Quarz auf der Platine ist, läuft ein neuer AVR (meistens) auf 1 MHz, sodass die maximale ISP-Frequenz 250 KHz betragen darf. Ich gehe meistens aus Sicherheitsgründen noch eine Stufe herunter und stelle 125 KHz ein. Ist alles soweit eingestellt verrät uns ein Klick auf Read Signature ob unser AVR mit uns spricht. Der angezeigte Hex-Wert ist die Signatur eines AT mega48. Wichtig ist der Satz darunter, der besagt das die Signatur zu unserem eingestellten Mega48 passt.

Ein klick auf den Program Reiter, öffnet den Programmierdialog. Hier unter Flash den Pfad zur Hex-Datei herstellen. Ein klick auf Program, lädt die Hex-Datei in unseren AVR.

Bei den Fusebits können auch (falls bekannt), die Hex-Werte direkt eingegeben werden.
Bei SUT_CKSEL wählt man die Taktquelle aus. In diesem Fall den internen RC Oszilator mit 8 MHz. Bei der Start-up Time wähle ich aus Sicherheitsgründen immer den höchsten Wert, 65mS.
Die CKDIV8 Fuse die den Systemtakt durch 8 teilt, muss abgeschaltet werden. Diese ist bei einem neuen Mega48 eingeschaltet.
Die BODLEVEL Einstellung bewirkt, das wenn die Betriebsspannung unter den eingestellten Wert fällt, einen Reset. Wenn wir die Schaltung mit einem Steckernetzteil mit nachgeschaltetem 7805 versorgen, kann die Brown-out detection auch abgeschaltet werden.

Wichtig! Nicht mit den Fusebits herumspielen, wenn man nicht weiss was man macht.

Immer das Datenblatt des entsprechenden µC aufmerksam lesen.
Beispiel: Man stellt an SUT_CKSEL den Takt auf einen externen Quarz (oder Quarzoszillator), obwohl keiner angeschlossen ist.
Der AVR lässt sich jetzt nicht mehr programmieren, weil kein Takt an den entsprechenden XTAL Pins erzeugt wird.
Abhilfe: Einen Quarz (oder Quarzoszillator) anschliessen und die Fuses auf RC Oszilator programmieren.

Beispiel 2: Man schaltet RSTDISBL ein.
Nun haben wir ein Portpin dazubekommen dafür aber keinen Resetpin mehr . Da die Resetleitung auch für ISP benötigt wird, können wir den AVR nicht mehr über ISP programmieren. Wir haben uns also ausgesperrt. Hier hilft nur noch ein Programmiergerät das auch HV-Programmierung unterstützt. Z.B. der AVR-Dragon.

Datenschutzerklärung  Kontakt  AVR-Projekte.de durchsuchen