Temperatursensor ADT7420 auslesen

[Torch M. (thelightener)]

Hallo!

Ich bin FPGA-Neuling und befasse mich gerade mit dem FPGA-Board Nexys 4 
von Digilent:

http://www.digilentinc.com/Data/Products/NEXYS4/Nexys4_RM_VB2_Final_5.pdf

Auf diesem Board ist der Temperatursensor ADT7420 verbaut:

http://www.analog.com/static/imported-files/data_sheets/ADT7420.pdf


Programmiert wird mit der ISE Design Suite 14.7. Mein späteres Ziel ist 
es, die Temperatur auf einer der 7-Segmentanzeigen in dezimal 
darzustellen. Leider weiß ich gerade nicht weiter, wie ich mit dem 
ADT7420 auf dem Board arbeiten kann. Wie ist es mir z.B. möglich, die 
Bausteinregister per VHDL so zu programmieren, dass der IC arbeitet wie 
ich es möchte und wie funktioniert das Auslesen der Temperaturregister? 
Der Umfang des Datenblattes erschlägt mich gerade etwas, so dass ich gar 
nicht weiß wo ich anfangen soll. Der Baustein ermöglicht auch ein 
direktes Auslesen der Temperaturregister beim Starten des ICs (S. 23 im 
Datenblatt ADT7420 bzw. S.22f Datenblatt FPGA-Board). Wenn es mir 
gelingen würde, die zwei 8-bit Register auszulesen und damit evtl. LEDs 
zum Leuchten zu bringen, wäre mir schon sehr geholfen.

MfG
Thelightener

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Torch M. schrieb:
> Wie ist es mir z.B. möglich, die Bausteinregister per VHDL so zu
> programmieren, dass der IC arbeitet wie ich es möchte und wie
> funktioniert das Auslesen der Temperaturregister?
Das ist der zweite Schritt.

> Auf diesem Board ist der Temperatursensor ADT7420 verbaut:
Also musst du erst mal eine Komponente beschreiben, die das I2C 
Protokoll umsetzt und mit der du ein Byte über den I2C Bus versenden und 
empfangen kannst. Auf den Seiten 17 und 18 wird beschrieben wie das 
geht.

Dann brauchst du einen Zustandsautomaten, der nacheinander über die 
vorher implementierte I3C Schnittstelle die richtigen Werte an den 
Sensor schickt und empfängt. Und von den (wenigen) 14 Registern, die der 
Baustein hat, sind für dich nur 5 interessant. Zuerst solltest du 
versuchen, das ID-Register auszulesen, denn dort muss der Wert 0xCB 
zurückkommen.

> Der Baustein ermöglicht auch ein direktes Auslesen der
> Temperaturregister beim Starten des ICs (S. 23 im Datenblatt ADT7420
Wo steht das genau?

[Thomas T. (knibbel)]

Hallo,

muss es wirklich direkt über VHDL sein?

Bei solchen Dingen (Auslesen, Umwandeln in Dezimal, Anzeigen) kommt es 
nicht wirklich auf die Durchlaufzeit an und von daher denke ich, dass es 
wesentlich einfacher ist, wenn man es prozessorbasiert realisiert.

Als Beispiel sei an dieser Stelle der Picoblaze vorgeschlagen. Einfach 
über zwei Ports mit dem Display und dem Temp-Sensor verbinden und die 
gesamte Ansteuerung und dazwischen das Umwandeln ins Dezimale per 
Software erledigen.

Ich denke, das wird einfacher als die ganzen Module und 
Zustandsautomaten zu schreiben. Erst recht für einen FPGA-Neuling, wie 
Du selbst schreibst...

Gruß,
Thomas

[Torch M. (thelightener)]

Hallo,

danke für eure Beiträge. Wie der I²C-Bus funktioniert habe ich (denke 
ich) überblickt und welche Bitfolgen ich erzeugen muss, damit der 
Baustein tut was er soll, weiß ich auch. Als nächstes möchte ich die 
Bits einer beliebige Bitfolge taktabhängig auf einen Ausgang geben, weiß 
aber noch nicht wie ich das bewerkstelligen kann. Wie kann ich z.B. die 
Bits von:

signal bit_stream: std_logic_vector(3 downto 0) := "1010";

sequentiell auf einen Ausgang geben, angefangen beim MSB?


@Lothar Miller
Digilent Datenblatt S. 23, Abschnitt 12.3


@Thomas T.
Da ich nun mal das genannte Board in der Hand halte, muss ich es damit 
auch realisieren.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Torch M. schrieb:
> Wie kann ich z.B. die Bits von:
> signal bit_stream: std_logic_vector(3 downto 0) := "1010";
> sequentiell auf einen Ausgang geben, angefangen beim MSB?
Da sind zwei Ansätze denkbar:
1. ein Multiplexer
2. ein Schieberegister
Für den 1. Ansatz brauchst du einen Zähler von 0..3, der dann als Index 
für den Zugriff auf die Bits verwendet wird.
Für den 2. Weg brauchst du den '&' Operator (Concatenation).

Für FPGAs empfehle ich die 2. Lösung, weil sie viele Flipflops haben, 
bei CPLDs ist die Nummer 1. wegen der mächtigen Produktterme besser.

Hier ain paar Anwendungen für Schieberegister (einfach nach dem & 
suchen):
http://www.lothar-miller.de/s9y/categories/42-RS232
http://www.lothar-miller.de/s9y/categories/55-PS2
http://www.lothar-miller.de/s9y/categories/50-RC-5

[Thomas T. (knibbel)]

Torch M. schrieb:
> Da ich nun mal das genannte Board in der Hand halte, muss ich es damit
> auch realisieren.

Davon bin ich auch ausgegangen...

Gemeint war die Implementation einer kleinen CPU (Picoblaze) auf dem 
FPGA, welche dann über einen angeflanschten I2C-Bus den Sensor 
anspricht. Über die auf dieser CPU laufende Software wäre eine 
Fehlerdetektion auf dem I2C-Bus auch einfacher, als in reiner 
Hardware...

Sicher ist eine reine VHDL-Lösung mittels Statemachines auch möglich. 
Wobei ich den Aufwand der "Binär->Dezimal"-Wandlung der Temperatur als 
nicht trivial einstufe (Das LSB hat eine Wertigkeit von 0.0625°C (oder 
0.0078°C)).

Gruß,
Thomas

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Thomas T. schrieb:
> Wobei ich den Aufwand der "Binär-Dezimal"-Wandlung der Temperatur als
> nicht trivial einstufe
Das ist eine simple Multiplikation mit anschließendem Abschneiden der 
nicht relevanten Stellen...

[Torch M. (thelightener)]

Hallo,

mit dem Code am Threadende versuche ich 7 Bits seriell auf einen Ausgang 
zu geben. Die Ausgabe klappt auch, allerdings nicht so wie erhofft. Im 
Anhang ist ein Screenshot des Simulationsergebnisses zu sehen. Man 
sieht, dass wenn enable auf '1' gesetzt wird, die FSM beim nächsten Takt 
nach shifting springt. Bei diesem Takt müsste allerdings (so habe ich es 
mir zumindest vorgestellt) sda schon das LSB von device_addr ausgeben 
(also 1), da die Wertigkeit von bitcnt 0 ist. Tu es aber nicht. Dieses 
Bit wird irgendwie abgeschnitten. Wo liegt das Problem?

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;
-------------------------------------------------------------
entity Proj_data_shift is
    Port ( clk   : in    STD_LOGIC;
           --rst   : in    STD_LOGIC;
           --scl   : out    STD_LOGIC;
           enable  : in     STD_LOGIC;
           sda   : inout  STD_LOGIC);
end Proj_data_shift;
-------------------------------------------------------------
architecture Behavioral of Proj_data_shift  is

constant  device_addr: STD_LOGIC_VECTOR(6 downto 0) := "1110111";
signal   bitcnt: integer range 0 to 7;

type data_shift is (idle, shifting);
signal state : data_shift := idle;

begin
-------------------------------------------------------------
process begin
wait until rising_edge(clk); 
case state is

  when idle =>
    SDA <= '0';
    if (enable = '1') then
      state <= shifting;
    end if;
  
  when shifting =>
    if (bitcnt < 7) then
      bitcnt <= bitcnt + 1;
      sda <= device_addr(bitcnt);
    else
      bitcnt <= 0;
      state <= idle;
    end if;
end case;
end process;
-------------------------------------------------------------
end behavioral;

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Torch M. schrieb:
> Wo liegt das Problem?
Dein Stichwort heißt: Latency.

Eigentlich logisch:
Wenn du zusammen mit dem Zustandswechsel etwas ausgeben oder ändern 
willst, dann musst du es zusammen mit dem Zustandswechsel 
aktualisieren.

process begin
wait until rising_edge(clk); 
case state is

  when idle =>
    SDA <= '0';
    if (enable = '1') then
      state <= shifting;     -- Zustandswechsel
      sda <= device_addr(0); -- GLEICHZEITIG Signal ändern
      bitcnt <= 1;           -- Vorbereiten für den nächsten Takt
    end if;
  
  when shifting =>
    if (bitcnt < 7) then   
      sda <= device_addr(bitcnt);
      bitcnt <= bitcnt + 1;
    else
      state <= idle;
    end if;
end case;
end process;

BTW:
Auf einem FPGA wäre es effizienter, die Daten  mit einem Schieberegister 
hinauszubefördern. Ein Multiplexer braucht viel Logik...

[Torch M. (thelightener)]

Hallo,

ich habe mittlerweile den I²C-Bus zum Laufen gekriegt und kann den 
Sensor schreiben und lesen. Auch die Ausgabe auf der 7-Segment-Anzeige 
funktioniert. Leider ist mir ein Problem aufgefallen, dessen Ursprung 
ich einfach nicht finden kann. Wenn ich die Sensortemperatur (mittels 
Föhn) von Raumtemperatur bis meinetwegen 30°C hochjage und die 
Temperatur wieder abfällt, dann habe ich ab <26°C immer einen Sprung auf 
<=24°C. D.h. er überspringt in diesem Bereich einfach immer 2°C, so dass 
die angezeigte Temperatur letztendlich nicht stimmen kann. Einen Fehler 
bei der Umrechnung des Temperaturregister-Inhaltes und der Anzeige auf 
dem 7-Segment-Display schließe ich aus, da ich mir parallel dazu auch 
den Temperaturregister-Inhalt (16 Bit) auf den 16 LEDs anzeigen lasse. 
Eine Umrechnung der angezeigten Bits ergibt stets den angezeigten Wert 
auf der 7-Segment-Anzeige. Der Fehler muss also meiner Meinung nach in 
der FSM zur Beschreibung des I²C-Protokolls liegen. Leider bin ich auch 
nach langer Sucherei nach wie vor ratlos, wo das Problem liegen könnte.

Mein I²C-Protokoll habe ich so ausgelegt, dass ich über zwei 
entsprechende Bits (rw bzw. tbr) festlegen kann, ob ein Register 
geschrieben oder gelesen werden (rw) soll und ob ein Byte oder zwei Byte 
gelesen werden sollen (tbr). Ich konfiguriere den Sensor auf 16-Bit 
Auflösung, gebe noch einige Schwellwerte für den Temperaturalarm vor und 
ende dann in einer Endlosschleife, in der nur noch die 
Temperaturregister mittels 2-Byte-read ausgelesen werden. Sobald die 
Bits gelesen worden sind, werden sie an das Modul zur Visualisierung 
weitergegeben. Die einzelnen Module habe ich per Schematic verbunden. 
Falls es jemanden gibt, der sich meinem Problem (was ich in der FSM im 
Status "two_byte_read" vermute) annehmen möchte: Der Code für mein 
I²C-Protokoll lautet wie folgt:

library IEEE;
use IEEE.STD_LOGIC_1164.ALL;
use IEEE.NUMERIC_STD.ALL;

entity I2C_Master_Controller is
    Port ( 
clock       : in STD_LOGIC; 
rst         : in STD_LOGIC;  -- reset
rw          : in STD_LOGIC;  -- read or write
tbr         : in STD_LOGIC;  -- two-byte-read
reg_addr_in : in STD_LOGIC_VECTOR(7 downto 0);  --Registeradresse vom Konfigurationsmodul
data_in     : in STD_LOGIC_VECTOR(7 downto 0); --Daten vom Konfigurationsmodul, die bei rw <= '0' in den Sensor geschrieben werden
busy        : out STD_LOGIC;  
data_out    : out STD_LOGIC_VECTOR(15 downto 0);--Registerinhalt
scl         : out STD_LOGIC;      
sda         : inout STD_LOGIC);
end I2C_Master_Controller;

architecture Behavioral of I2C_Master_Controller is

type state_type is (idle, start_condition, send_dev_addr, loop_send_dev_addr, get_ack, loop_get_ack, send_reg_addr, loop_send_reg_addr, repeat_condition,loop_repeat_condition, loop_again_repeat_condition, one_byte_read, loop_one_byte_read, get_no_ack, loop_get_no_ack, send_stop, loop_send_stop, loop_again_send_stop, write_data, loop_write_data, two_byte_read, loop_two_byte_read);
signal state, prev_state: state_type; 

constant dev_addr_w : std_logic_vector(7 downto 0) := "10010110";-- Sensoradresse mit Write-Bit
constant dev_addr_r : std_logic_vector(7 downto 0) := "10010111";--Sensoradresse mit Read-Bit

signal tmp_data        :  STD_LOGIC_VECTOR(15 downto 0);
constant prescaler     :  integer := 100000000/400000;
signal data            :  std_logic_vector(7 downto 0);
signal bitcnt          :  integer range 0 to 7;
signal cnt_clk         :  integer range 0 to prescaler;
signal new_clk         :  STD_LOGIC;
signal sda_tmp         :  STD_LOGIC;
signal first_byte_sent : STD_LOGIC; --Bit für 2-Byte-Read: wird '1', sobald das erste Byte vom Sensor empfangen wurde.

begin

sda <= 'Z' when sda_tmp = '1' else '0';
-------------------------------------------------------------------------
-------------------------------------------------------------------------
process(new_clk, rst)
begin
if (rst <= '0') then    
  scl <= '1';
  sda_tmp <= '1';  
  tmp_data <= x"FFFF";
  data_out <= x"FFFF";
  first_byte_sent <= '1';
  data_out <= x"FFFF";
  bitcnt <= 7;  
  busy <= '0';
  state <= idle;  
elsif rising_edge(new_clk) then
case state is
  when idle =>      
      busy <= '0';      
      first_byte_sent <= '0';
      scl <= '1';
      sda_tmp <= '1';
      state <= start_condition;      
-------------------------------------------------------------------------    
  when start_condition =>
      busy <= '1';
      sda_tmp <= '0';          
      bitcnt <= 7;
      data <= dev_addr_w;
      prev_state <= start_condition;
      state <= send_dev_addr;    
-------------------------------------------------------------------------
  when send_dev_addr =>
    scl <= '0';
    sda_tmp <= data(bitcnt);
    state <= loop_send_dev_addr;
    
  when loop_send_dev_addr =>
    scl <= '1';
    if bitcnt /= 0 then
      bitcnt <= bitcnt - 1;
      state <= send_dev_addr;
    else
      bitcnt <= 7;
      case prev_state is
      when start_condition =>
        prev_state <= send_dev_addr;
      when repeat_condition =>
        prev_state <= repeat_condition;
      when others => null;
      end case;      
      state <= get_ack;
    end if;
-------------------------------------------------------------------------
  when get_ack =>
    scl <= '0';
    sda_tmp <= '1';
    state <= loop_get_ack;
    
  when loop_get_ack =>
    scl <= '1';
    sda_tmp <= '0';
    case prev_state is    
    when send_dev_addr =>  
      state <= send_reg_addr;      
    when send_reg_addr =>
      if rw = '0' then
        bitcnt <= 7;
        state <= write_data;
        elsif rw <= '1' then
        bitcnt <= 7;
        state <= repeat_condition;
      end if;
    when repeat_condition =>
      if tbr <= '0' then
        state <= one_byte_read;
      elsif tbr <= '1' then
        state <= two_byte_read;
      end if;
    when write_data =>      
      state <= send_stop;
    when two_byte_read =>
      first_byte_sent <= '1';
      state <= two_byte_read;
    when others =>
      state <= idle;
    end case;  
-------------------------------------------------------------------------    
  when send_reg_addr =>
    scl <= '0';
    sda_tmp <= reg_addr_in(bitcnt);
    state <= loop_send_reg_addr;
    
  when loop_send_reg_addr =>
    scl <= '1';
    if bitcnt /= 0 then
      bitcnt <= bitcnt - 1;
      state <= send_reg_addr;
    else
      bitcnt <= 7;
      prev_state <= send_reg_addr;
      state <= get_ack;      
    end if;
-------------------------------------------------------------------------  
  when repeat_condition =>
    scl <= '0';
    sda_tmp <= '1';
    state <= loop_repeat_condition;
    
  when loop_repeat_condition =>
    scl <= '1';
    sda_tmp <= '1';
    state <= loop_again_repeat_condition;
    
  when loop_again_repeat_condition =>
    scl <= '1';
    sda_tmp <= '0';    
    data <= dev_addr_r;
    prev_state <= repeat_condition;
    state <= send_dev_addr;
-------------------------------------------------------------------------    
  when write_data =>
    scl <= '0';
    sda_tmp <= data_in(bitcnt);
    state <= loop_write_data;    
    
  when loop_write_data =>
    scl <= '1';
    if bitcnt /= 0 then
      bitcnt <= bitcnt - 1;
      state <= write_data;
    else
      bitcnt <= 7;
      prev_state <= write_data;
      state <= get_ack;      
    end if;    
-------------------------------------------------------------------------    
  when one_byte_read => 
    scl <= '0';
    sda_tmp <= '1';
    state <= loop_one_byte_read;
    
  when loop_one_byte_read =>
    scl <= '1';
    data(bitcnt) <= sda;
    if bitcnt /= 0 then
      bitcnt <= bitcnt - 1;
      state <= one_byte_read;
    else
      bitcnt <= 7;
      tmp_data(15 downto 8) <= data;
      tmp_data(7 downto 0) <= (others => '0');
      state <= get_no_ack;
    end if;
-------------------------------------------------------------------------
  when two_byte_read => 
    scl <= '0';
    sda_tmp <= '1';
    state <= loop_two_byte_read;
    
  when loop_two_byte_read =>
    scl <= '1';
    data(bitcnt) <= sda;
    if bitcnt /= 0 then
      bitcnt <= bitcnt - 1;
      state <= two_byte_read;
    elsif first_byte_sent <= '0' then
        bitcnt <= 7;
        tmp_data(15 downto 8) <= data;
        state <= get_ack;
        prev_state <= two_byte_read;
    elsif first_byte_sent <= '1' then
        bitcnt <= 7;
        tmp_data(7 downto 0) <= data;
        state <= get_no_ack;
    end if;  
-------------------------------------------------------------------------    
  when get_no_ack =>
    scl <= '0';
    sda_tmp <= '1';    
    data_out <= tmp_data;
    state <= loop_get_no_ack;
    
  when loop_get_no_ack =>
    scl <= '1';
    state <= send_stop;
-------------------------------------------------------------------------
  when send_stop =>
    scl <= '0';
    sda_tmp <= '0';
    state <= loop_send_stop;
  
  when loop_send_stop =>
    scl <= '1';
    sda_tmp <= '0';    
    state <= loop_again_send_stop;
    
  when loop_again_send_stop =>
    scl <= '1';
    sda_tmp <= '1';
    state <= idle;    
-------------------------------------------------------------------------
  when others => 
    state <= idle;
-------------------------------------------------------------------------    
end case;
end if;
end process;
-------------------------------------------------------------------------
-------------------------------------------------------------------------
process (clock)
begin
if rising_edge(clock) then
  if (cnt_clk < prescaler) then
    cnt_clk <= cnt_clk + 1;
    if (cnt_clk < prescaler/2) then
      new_clk <= '0';
    else 
      new_clk <= '1';
    end if;
  else
    cnt_clk <= 0;
  end if;
end if;

end process;
-------------------------------------------------------------------------
-------------------------------------------------------------------------
end Behavioral;

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Torch M. schrieb:
> er überspringt in diesem Bereich einfach immer 2°C
Nur von "oben nach unten" oder auch von "unten nach oben"?

BTW: ich finde es interessant, ein einzelnes std_logic Bit auf 
"kleiner-gleich" zu vergleichen:

      ...
    elsif first_byte_sent <= '0' then
      ...    
    elsif first_byte_sent <= '1' then
      ...

[Torch M. (thelightener)]

Hallo Lothar,

er springt "in beide Richtungen". Das mit dem <= Vergleich ist natürlich 
ein Fehler, ist mir bislang noch nicht aufgefallen. Wundert mich, dass 
es deswegen keine Probleme gibt bei der Synthese.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Torch M. schrieb:
> er springt "in beide Richtungen".
Sind die Temperaturen an sich plausibel? Hast du bei den 
Timing-Constraints wenigstens den Takt angegeben? Passt dein erzeugtes 
Timing zu dem im Bild 2 vom Datenblatt?

[Torch M. (thelightener)]

Die Temperaturen sind plausibel und liegen immer so zwischen 21°C - 
23°C, also bei Raumtemperatur. Mit "Timing-Constraints" habe ich mich 
noch gar nicht beschäftigt, weiß damit also noch nichts anzufangen. Das 
ändert sich aber jetzt. Geht es dir bei dem Timing-Constraint um den 
Takt, mit dem ich meine I²C-FSM betreibe? Wo kann ich mir mein erzeugtes 
Timing anschauen?

Edit: Also ganz sicher bin ich mir doch nicht mehr ob die Temperaturen 
wirklich plausibel sind... er hat sich jetzt ca. bei 23°C eingependelt, 
bei mir ist es aber sicher ein paar Grad kälter.