Ich würde gerne eine 1-Wire Slave Application auf einem Atmel Avr
realisieren. Der uC soll dabei als Slave im Bus zur verfügung stehen.
Das ganze sollte mit dem 1-Wire Protokoll von Dallas kompatibel sein da
noch andere 1-Wire Devices am Bus hängen.

Leider gibts von Atmel nur eine Application Note für die
Implementierung des Masters.

Ich würde ungern das Rad neu erfinden. Das hat sicher schonmal jemand
gemacht.

Hat jemand erfahrung damit und weiss wo ich entsprechenden SOurce COde
finden kann?

hallo martin,

du willst dir also soweit ich das verstehe mit einem mc ein
1-wire-device erstellen.

im prinzip ist das doch nicht schwerer, als den mc als master zu
programmieren. brauchst doch die selben routinen nur das du halt den
portpin nun abtasten musst, ob ein reset ansteht und das ganze zeug.

selbermachen ist doch am schönsten!

Es ist fast hoffnungslos. Wenn es nur ein Slave waere, dann koennte man
das realisieren, aber wenn da andere Slaves dran haengen, dann hat man
mit AVR kaum eine Chance. Timing ist sehr wichtig fuer 1-wire, AVR
schafft es nicht. Und es gibt keine vernuenftige Beschreibung, weil es
von DS lizensiert ist. Alles was man finden kann ist nur ein Paar
Tests.

Geht m.E. nur mit etwas Nachilfe in Form externer Hardware, die ggf. den
1µs-Impuls vom Master latched. Ansonsten müsste der AVR garantiert
binnen 1µs reagieren können, was sich schwer garantieren lässt, wenn
der noch was anderes tun soll.

Hmm. Vielleicht mit Hilfe vom USI, so vorhanden. Der start condition
detector könnte sich missbrauchen lassen um den Impuls zu latchen, und
ein timer mit input capture kriegt raus, wie lange das schon her ist.
Damit könnte es gehen. Trotzdem haarig.

Wäre denn der ordinäre externe Interrupt nicht für den 1µs-Impuls
geeignet?

Beim Lesen zieht der Master für 1µs auf 0. Der Slave muss dann binnen
dieser 1µs den Pin selber auf 0 ziehen, wenn er eine 0 zurückgeben
will, oder er lässt den Pin in Ruhe bei einer 1.

In Software ist diese Reaktionszeit schlecht zu gewährleisten.

hallo,

wo habt ihr die 1us her. schau ich mir die timmingbeschreibung von
maxim an, finde ich diese bedingung nicht. ich gehe davon aus, das man
die devices nicht im overdrive modus betreibt.

z.b. um auf den presence puls zu reagieren, hat man genügent zeit. Die
erst phase ist ca. 600us und detektiert wird bei 610us.

avr kenn ich perönlich nicht. aber der takt wird doch sicher auch bei
20mhz liegen.

schwirig ist eher, das das timing zwischen min und max werten läuft.
hier würde ich auf masterseite den ds2482-100 empfehlen, der sich ums
timing kümmert und nicht die onewire schnittstelle sleber realisieren.

Habe das seit ein paar Wochen am laufen für einen Tiny13 und Mega8. Hat
allerdings noch einen kleinen Bug (gelegentlich antwortet der nur mit
FFs, gibt dann aber CRC Error, kann aber auch am Netzwerk liegen), aber
funktioniert prinzipiell in einem Netzwerk mit mehreren DS1820.

Kann ich heute abend mal reinstellen. Ist aber noch Alpha status.

Gruss
Axel

hallo peter,

das timing lässt sich gut aus dem datenblatt zum DS2482-100 ablesen.
dort steht, das der master nach ca. 14us (typischer wert), den zustand
auswertet. also muss ich nach feststellen der negativen flanke bis
dahin meinen zustand stabil haben. bei den devices, z.b. dem ds2433
wird das fenster für die detektierung mit trvd - tlowr  angeben. wie
man daraus sieht, stellt der ds2482-100 den zustand zimlich am ende
erst fest. so schlägt maxim das ja auch vor, wenn man sich den master
mit einem portpin selber schustert.

Man muss sich also nicht einigen, da ja das von maxim geklärt ist und
wann dein mc das zurück liest, kannst ja du selber festlegen.

ich nutzte den ds2482-100 und hab damit keine probleme.

Das One-Wire Timing laesst sich prima mit einem UART erzeugen. Bei Maxim
oder Atmel gab eine Applikationsnote dazu.

Die Frage ist doch, was ich für einen Master verwende. Digiterm z. B.
verwendet den PC UART, das Timing dort kann ich beeinflussen. Das
Gleiche gilt, wenn man einen AVR als Master nimmt.

Somit sind die 1 us zwar in der Theorie vorhanden, kommen aber
praktisch kaum vor. Eigentlich muss man nur die Flanke detektieren und
dann das Signal auf den Pin bekommen. Das kann man aber schon
vorbereiten, d. h. der Flankeninterrupt kann das direkt nach Aufruf
machen.

Entscheidend ist, dass man rechtzeitig aktiv wird, bevor der Master das
Signal abtastet.

Gruss
Axel

@ Joachim,

hmm, das mit den Patenten könnte tatsächlich ein Problem sein, wenn ich
das hier veröffentliche. Ist vielleicht auch schlicht der Grund, warum
ich nirgends ein Programm für so einen Slave finden konnte.

Hast Du eine E-Mail Adresse, wo ich das hinschicken kann ?

Gruss
Axel

Hallo Joachim,

ich schicke es Dir heute abend, will den Code erst noch ein bischen
aufräumen.

Gruss
Axel

Hallo Axel,

ich hätte auch interesse an dem Code. Wäre super wenn du ihn mir auch
schicken könntest.

Email:  einer.meiner@lycos.de

Danke und Grüße,

Joachim

Hallo Axel,

ich hätte auch interesse an Deinem Code.

Könntest Du ihm mir bitte auf diese Adresse schicken:
stephan_bauer@gmx.de

Danke

Grüße

Stephan

Nun Das mit den Patenten geht so: US-Patente gelten nur in USA! Wenn Du
kein Geld damit machst, kannst Du das benutzen. Patente sind keine
Geheimnisse... eher das Gegenteil! Was nicht geht: Patent nutzen für
eine Sache die verkauft oder vermietet wird.

Ok, ich schieb ihn heute Abend hoch.

Ist aber, wie bereits geschrieben, noch Alpha Stadium (funktioniert
aber).

Gruss
Axel

Hier also der Code. Läuft auf einem Tiny13 und einem Mega8. Das kann im
Makefile eingestellt werden.Im Tiny13 wird es aber schon sehr knapp und
es ist der Timer und der externe interrupt belegt. Ich habe im Haus
einen 1-Wire Bus hängen, an dem viele 18B20 hängen, die Tiny13 Variante
nutze ich um z. B. Reedkontakte abzufragen.

Der Baustein verhält sich im Prinzip wie ein 1820 Temperatur Sensor
wobei natürlich keine Temperaturen, sondern die 8 Datenbytes ausgegeben
werden, die in "transdata" stehen.

Dazu gibt es noch eine adaptierte Digitemp 3.3.2 Source, die
zusätzliche Aufrufparameter zum Schreiben der zwei EEPROM Zellen
bietet.

Gruss
Axel

dann sind patente nur schutz dieser speziellen sache. die idee selbst
ist nicht geschützt. wenn du nicht unbedingt die genauen zeiten
brauchst dann fahr das ding auf einer anderen (nicht in den
datenblättern spezifizierten) taktrate und schon ist das nicht mehr
1wire konform - aber kompatibel.
wenn die z.b. nur zwischen zwei µC aus layout-gründen nur eine leitung
ziehen kannst, dann bist du doch nicht an 1wire gebunden.
abgesehen davon sind 1µS bei 8MHz takt eines avrs immer noch 8 takte...
assembler lässt grüssen.

Hallo Axel

Wie hast du den Tiny13 beschaltet?
Data I/O auf welchem Port, mit externem Transistor?
Interner RC-Oszi oder extern?

Gruss Mike

Hallo Mike,

lies doch einmal in "onewire.c" nach.
Data I/O liegt an INT0.
Die Taktfrequenz sollte 9,6 MHz sein.
Ein Transistor ist sicher nicht erforderlich. Bei einem bidirektonalen
Anschluß wüsste ich nicht wie das Schaltungstechnisch aussehen sollte?

Gruß
Joachim

Hallo Christian,

Du hast recht.
Ich hatte mich auf diesen Teil der Datei bezogen:

#define ONEWIREPIN 1         // Pin, an dem der 1-Wire angeschlossen ist, MUSS INT0 sein
#define PRESENCEZEIT 15      // Timingdeclarationen für 9,6 MHz
#define PRESENCEWAITZEIT 2
#define ABTASTZEIT 3           // Abtastzeitpunkt beim empfangen 
#define SENDEZEIT 5           //  Dauer des 0-Sendeimpulses

Die 17% Abweichung sind dann offensichtlich nicht kritisch.

Gruß
Joachim

Hallo zusammen,

hab mir eine ATTiny13 besorgt, scheint aber nicht zu funktionieren.
Kann es sein das "SKIP_ROM" nicht richtig unterstütz wird ?

wenn ich per SKIP_ROM alle DS18B20 abfrage, reagiert der ATiny aber und
verstümmelt die Daten bzw. der Bus bricht ab.

Der 1-Wire Master schickt auch noch ein "SEARCH ROM [F0h]" Kommando beim
einlesen der DS18B20, evtl. reagiert der ATiny darauf.

Im Code ist "SEARCHROM" ist zwar definiert, aber nicht benutzt.

erwind schrieb:
> wenn ich per SKIP_ROM alle DS18B20 abfrage, reagiert der ATiny aber und
> verstümmelt die Daten bzw. der Bus bricht ab.

Mit SKIP-ROM darf man nur einen Dallas-Baustein am Bus haben. Dieser
fühlt sich dann ohne Seriennummern-Check angesprochen.

hab im Master nachgeschaut - CONVERT T [44h] wird mit SKIP ROM [CCh]
angefordert.
Nach etwa 1s wird mit SEARCH ROM [F0h] nach den IDs der DS18(S,B)20
Sensoren gesucht, diese werden dann gezielt mit READ SCRATCHPAD [BEh] +
ID aus dem vorhergehenden SEARCH ROM [F0h] Commando ausgelesen.

Das Tut alles seit Jahren, ich brauche aber ein paar Eingänge, so bin
ich auf die ATiny Geschichte hier gestossen.

Läuft das tatsächlich bei jemandem am Bus zusammnen mit anderen Dallas
Bausteinen ?

Welche Komando-Reihenfolge führt zum Ziel ?

Hier mal ide aktuelle Variante. Habe da einiges angepasst, um die
Störungen wegzukriegen, bin aber nicht sicher, ob das auf einem ATTINY
noch läuft, da ich das nur noch auf einem ATMEGA laufen lasse.

So läuft das aber seit drei Jahren ohne Fehler.

// Timer interrupt routine
#ifdef _AVR_ATtiny13_
ISR (TIM0_OVF_vect)
#elif defined (_AVR_ATmega8_)
ISR (TIMER0_OVF_vect)
#endif    // Port als Ausgang
{
    unsigned char tim0_i, status;
    signed int temperaturwert, temperaturwert_bruch;
    TIMSK0 &= ~(1 << TOIE0);       // Timer Interrupt aus
    status = status_global;
#ifdef _AVR_ATtiny13_
          DDRB &= ~(1 << ONEWIREPIN);    // Pin auf Eingang
#elif defined (_AVR_ATmega8_)
          DDRD &= ~(1 << ONEWIREPIN);    // Pin auf Eingang
#endif
    if (status == RESET){
#ifdef _AVR_ATtiny13_
          DDRB |= (1 << ONEWIREPIN);    // Pin auf Ausgang
#elif defined (_AVR_ATmega8_)
          DDRD |= (1 << ONEWIREPIN);    // Pin auf Ausgang
#endif
          status = PRESENCEPULSE;
          bitcount = 0;
          TCNT0 = ~PRESENCEZEIT;     // Neu Starten zum bestimmen der
Presencepulselaenge
          TIFR0 |= (1 << TOV0);
          TIMSK0 |= (1 << TOIE0);       // Timer Interrupt an
    }
    else if (status == PRESENCEPULSE){    // Presence Puls zu ende,
Timer INT aus, Pin auf Eingang, warten auf Opcode
          status = RECEIVE_OPCODE;
          bitcount = 0;     // TINT wird oben ausgeschaltet
    }

   else if (status & (RECEIVE_OPCODE | MATCHROM | WRITEMEM)){
            bitcount++;
            if (bitcount == 1) {
                transbyte = 0;
            }
            transbyte = transbyte >> 1;
            if (PIND & (1 << ONEWIREPIN)){
                transbyte |= 0x080;
            }
            if (bitcount == 8){
                if (status == RECEIVE_OPCODE) {
                        if (transbyte == 0x55){   // 0x55 -> Matchrom
                              status = MATCHROM;
                              transbyte = 0;    // New
                        }
                        else if (transbyte == 0x4E){
                              status = WRITEMEM;
                              transbyte = 0;
                        }
                        else if (transbyte == 0x48){  // Write data to
EEPROM
                              status = WRITEMEM;
                              transbyte = 0;
                        }
                        else if (transbyte == 0x48){  // Write data to
EEPROM
                            for (tim0_i = 2; tim0_i < 4; tim0_i++){
                                while(EECR & (1<<EEPE)) ;
                                /* Set Programming mode */
                                //EECR = (0<<EEPM1)|(0>>EEPM0);
                                /* Set up address and data registers */
                                EEARL = tim0_i;            // EEPROM
Address
                                EEDR = transdata[tim0_i];
                                /* Write logical one to EEMPE */
                                EECR |= (1<<EEMPE);
                                /* Start eeprom write by setting EEPE */
                                EECR |= (1<<EEPE);
                            }
                              status = IDLE;
                              transbyte = 0;
                        }
                        else if (transbyte == 0xBE){    // Daten lesen
                              status = READMEM;
                              shift_reg = 0;     // Schiebergister für
CRC loeschen
                             transbyte = transdata[0];
                        }
                        else {
                                status = IDLE;
                        }
                        bitcount = 0;
                        bytecount = 0;
                }
                else if (status == MATCHROM){
                        if (bytecount == 0){
                                if (transbyte == FAMILYCODE);
                                else status = IDLE;
                        }
                      else if (bytecount < 7){
                                if (transbyte ==  DEVICEID) ;
                                else  status = IDLE;
                        }
                        else {                  // Byte 8
                                status = RECEIVE_OPCODE; // Eigentlich
CRC checken, aber wozu ?
                        }
                        if (status == IDLE){
                                bytecount = 0;
                        }
                        bytecount++;
                        bitcount = 0;
                }
                else if (status == WRITEMEM){
                        if (bytecount == 0){
                                onewire_cmd1 = transbyte;
                                transdata[2] = transbyte;
                        }
                        else {
                                onewire_cmd2 = transbyte;
                                transdata[3] = transbyte;
                                status = RECEIVE_OPCODE;
                                bytecount = 0;
                        }
                        bytecount++;
                        bitcount = 0;
                }
          }
    }
    else {                 // status == READMEM oder rest
#ifdef _AVR_ATtiny13_
          DDRB &= ~(1 << ONEWIREPIN);    // Pin auf Eingang
#elif defined (_AVR_ATmega8_)
          DDRD &= ~(1 << ONEWIREPIN);    // Pin auf Eingang
#endif
    }
    status_global = status;
}

// Flankenerkennung am 1-Wire pin, entsprechend wird dann dei Aktion
ausgewählt
ISR (INT0_vect)
{
    unsigned char tim0_i, status;
    status = status_global;
#ifdef _AVR_ATtiny13_
          DDRB &= ~(1 << ONEWIREPIN);    // Pin auf Eingang
#elif defined (_AVR_ATmega8_)
          DDRD &= ~(1 << ONEWIREPIN);    // Pin auf Eingang
#endif

#ifdef _AVR_ATtiny13_
      if (PINB & (1 << ONEWIREPIN)){     // Steigende Flanke am One Wire
#elif defined (_AVR_ATmega8_)
    if (PIND & (1 << ONEWIREPIN)){     // Steigende Flanke am One Wire
#endif
            if ((TCNT0 < 0xE0) && (TCNT0 > 35)) {    // Reset pulse wenn
Puls >30 und < F0 geaendert auf 35
                  TIFR0 |= (1 << TOV0);                   // Timer
Overflow loeschen
                  TCNT0 = ~PRESENCEWAITZEIT;                  // Timer
Neu Starten Fuer Presencepulse
                  TIMSK0 |= (1 << TOIE0);       // Timer Interrupt an
                  status = RESET;
            }
      }
      else {                                      // Fallende Flanke am
One Wire
          if (status == READMEM){
                if ((transbyte & 0x01) == 0){
#ifdef _AVR_ATtiny13_
                      DDRB |= (1 << ONEWIREPIN);    // Pin auf Ausgang
#elif defined (_AVR_ATmega8_)
                      DDRD |= (1 << ONEWIREPIN);    // Pin auf Ausgang
#endif
                  }
                TIFR0 |= (1 << TOV0);         // TimerOverflow loeschen
                TCNT0  = ~SENDEZEIT;
                TIMSK0 |= (1 << TOIE0);       // Timer Interrupt an
                fb_bit = (transbyte ^ shift_reg) & 0x01;   // CRC
berechnen
                shift_reg = shift_reg >> 1;
                if (fb_bit)
                        shift_reg = shift_reg ^ 0x8c;
                bitcount++;
                transbyte = transbyte >> 1;
                if (bitcount == 8){
                        bitcount = 0;
                        bytecount++;
                        if (bytecount == 8){
                                 transbyte = shift_reg;  // CRC senden
                        }
                        else if (bytecount == 9) status = IDLE;  // CRC
senden
                        else transbyte = transdata[bytecount];
                }
          }
          else if (status == IDLE) {           // Erste fallende Flanke
              TIFR0 |= (1 << TOV0);         // TimerOverflow loeschen
              TIMSK0 &= ~(1 << TOIE0);       // Timer Interrupt aus
              TCNT0 = 0;
             // status = RESET;                // Erste fallende Flanke
nach Idle, Timer nutzen um Länge des Pulses zu messen
          }
          else if (status & (RECEIVE_OPCODE | MATCHROM | WRITEMEM)){
                TCNT0 = ~ABTASTZEIT;          // Zeichen abtasten in
ABTASTZEIT
                TIFR0 |= (1 << TOV0);         // TimerOverflow loeschen
                TIMSK0 |= (1 << TOIE0);       // Timer Interrupt an
          }
          else if (status == RESET) {           // Da hat ein anderer
einen Presence Pulse gesendet, da haengen wir uns dran
//              DDRD |= (1 << ONEWIREPIN);    // Pin auf Ausgang
                status = PRESENCEPULSE;
                bitcount = 0;
                TCNT0 = ~PRESENCEZEIT;     // Neu Starten zum bestimmen
der Presencepulselaenge
                TIFR0 |= (1 << TOV0);       // Timer OVF loeschen
                TIMSK0 |= (1 << TOIE0);       // Timer Interrupt an
          }
          else if (status == PRESENCEPULSE);   // Gar nichts tun,
Pegeländerung kommt vom eigenen Timer beim Senden oder anderen
          else {
               status = IDLE;
                TCNT0 = 0;
                TIFR0 |= (1 << TOV0);         // TimerOverflow loeschen
                TIMSK0 &= ~(1 << TOIE0);       // Timer Interrupt aus
          }
     }
    status_global = status;
}

hab das mal in den Ur-Code eingepflegt, komme aber erst Morgen zum
testen.

Danke schon mal

AVR Memory Usage
----------------
Device: attiny13

Program:     958 bytes (93.6% Full)
(.text + .data + .bootloader)
Data:         15 bytes (23.4% Full)
(.data + .bss + .noinit)

Build succeeded with 6 Warnings...