TEB0912 CPLD

Overview

Lattice MachXO2-4000HC is a CPLD chip, that is used in TEB0912 board as a system management controller. The system controller implements power management same as power sequencing, . Rather than power management is the system controller responsible for reset generation, zynq initial configuration. System controller contains of some additional features same as debouncing the power button and displaying the power status with LEDs. The  JTAG and UART interfaces are routed  in the firmware of CPLD  from FTDI chip to FPGA. In this board the CPLD is responsible for controlling and monitoring of power supply of the board. There are various DC-DC converter or regulators , one input current sensor and six temperature sensors. To control every converter chip or regualtor monitors CPLD power good outputs of regulators or DC-DC converters continuously to avoid over-voltage in the power system. System controller reads the measured temperature of all temperature sonsors continuously to avoid over-temperature in regulators or DC-DC converter chips. The firmware of CPLD contains of various subsystems same as i2c master and i2c slave subsystems. I2c master reads the data of current sensor and 6 temperature sensors  , that measure the temperature of DC-DC converter chips. I2c slave is responsible for communicating with FPGA to read register addresses and write the measured data in FPGA.

Feature Summary

• Power Management
• Reset Management
• JTAG Routing
• Boot Mode
• User IOs
• LED and power state display
• UART
• I2C Slave
• I2C Master
• I2C to GPIO
• RAM Memory
• Data Management State Machine
• Temperature Sensor TMP461
• Current Sensor INA219AIDCNR

Firmware Revision and supported PCB Revision

See Document Change History

Product Specification

Port Description

Functional Description

JTAG

JTAG signals routed directly through the CPLD to FPGA. Access between CPLD and FPGA is multiplexed via JTAGEN pin of CPLD (B30) (logical one for CPLD, logical zero for FPGA).

Boot Mode

TEB0912 supports JTAG, QSPI and SD card boot modes. Boot mode depends on the logic state of  S2 dip switch pins that are connected with FPGA boot mode configuration pins.

Power

In this board the CPLD is responsible for controlling and monitoring of output voltage and temperature of regulators and DC-DC converters. To control every converter chip or regualtor the CPLD monitors power good signal of regulators or DC-DC converters continuously to avoid over-voltage in the power system.

I2C

The main interface in the system is I2C interface. The user can input the data in the system through i2c slave subsystem. The entered data is stored in RAM memory. The state machine reads the stored data and communicates with corresponding sensor through i2c master subsystem and stores the feedback data again in RAM memory. The user can read back reported data for example temperature value.

Internal Registers

Ram memory is a 16x8 Byte Memory.

The memory consists of the following registers:

• config_reg
• sensor_addr
• pointer_reg_byte
• data_to_write
• state_reg
• data_to_read

Sensor_addr register consists of sensor address that the temperature should be read from. Pointer_reg_byte is sensor internal register address that is to be written to or read from. Data_to_write register consists of data that in pointer_reg_byte will be written.  The readed data  from sensor is saved in data_to_read register. As long as state machine is busy , it will be state_teg value equal to 0x01. Config_reg consists of control bits. To start data transfer in state machine start_bit must be set to 1. If write_bit set to one, the inhalt of data_to_write will be written in pointer_reg_byte register of sensor . To read the inhalt of pointer_reg_byte register of sensor the read_bit must be set to 1.

Transfer state machine

To manage data transfer between RAM memory and i2c master subsystem that is connected with sensors, it is necessary to design a state machine. This state machine will be controlled with control bits of config_reg register. If start_bit is activated, state machine begins to transfer data between RAM memory and i2c master subsystem. If write_bit is set to one,  saved data in RAM memory will be written in temperature sensor. If read_bit is set to one, temperature value will be readed from sensor and will be saved in RAM memory. Every state in the state machine consists of a state machine to manage i2c master communications.

In the following diagram this state machine construction is shown:

Sensors on board

All temperature sensors are TMP461 of texas instruments. When this sensor  is in shutdown mode, a single conversion is started by writing  any value in one_shot_start register ( poniter address 0x0F). The device returns to shutdown mode when the conversion and cycle completes. The result value is saved in high and low byte of  Local/ Remote temperature registers. The high byte consists of temperature integer value and low byte consists of fraction part of temperature value. (Pointer addresses 0x00,0x15 for local temperature register and pointer addresses 0x01,0x10 for remote temperature register). The channel enable register (read address 16h, write address 16h) enables or disables the temperature conversion of remote and local temperature sensors. LEN (bit 0) of the channel enable register enables/disables the conversion of local temperature. REN (bit 1) of the channel enable register enables/disables the conversion of remote temperature. Both LEN and REN are set to 1 (default), this enables the ADC to convert both local and remote temperatures. 

The TMP461 device is a digital temperature sensor that combines a local temperature measurement channel and a remote-junction temperature measurement channel in a single WQFN-10 package. The device is two-wire and SMBus-interface-compatible with nine pin-programmable bus address options, and is specified over a temperature range of –40°C to 125°C. The TMP461 device also contains multiple registers for programming and holding configuration settings, temperature limits, and temperature measurement results. In the following it is listed important registers of this sensor:

• STATUS REG---------------------------------------Addr ---> 0x02  (read only)  (Default N/A)

• Local temperature register MSB 8 bits---------Addr ---> 0x00  (read only)  (Default 0x00)

• Local temperature register LSB 4 bits----------Addr ---> 0x15  (read only)  (Default 0x00)

• Remote temperature register MSB 8 bits------Addr ---> 0x01  (read only)  (Default 0x00)

• Remote temperature register LSB 4 bits-------Addr ---> 0x10  (read only)  (Default 0x00)

• Configuration register---------------------------Addr ---> 0x03  (read/write) (Default 0x00)

• Channel enable register-------------------------Addr ---> 0x16  (read/write) (Default 0x03)

• Conversion rate register------------------------Addr ---> 0x04  (read/write) (Default 0x08)

• One-shot start register--------------------------Addr ---> 0x0F  (read/write) (Default N/A)

The INA219 is a high-side current shunt and power monitor with an I2C interface. The INA219 monitors  both shunt drop and supply voltage, with  programmable conversion times and filtering. A programmable calibration value, combines with an internal multiplier, enables direct readouts in amperes. An additional multiplying register calculates  power in watts. The I2C interface features 16 programmable accesses.

To access these sensors through ZynqMP can be executed the following instructions in linux console consecutively:

1. Write device address

   • i2cset -y 2 0x20 0x01 <sensor address>    --> This command writes sensor address in RAM memory address 0x01 (sensor_addr register)

2. Write register address

   • i2cset -y 2 0x20 0x02 <register address>  --> This command writes desired register address in RAM memory address 0x02 (pointer_reg_byte register) 

3. Write data that should be written in the register

   • i2cset -y 2 0x20 0x03 <data to write>     --> This command writes desired value in RAM memory address 0x03 (data_to_write register)

4. Start to write data

   • i2cset -y 2 0x20 0x00 0x03                --> This command set write_bit to one. (Write command)    

5. Stop writing data

   • i2cset -y 2 0x20 0x00 0x00                --> This command stops writing in RAM memory.

6. Start to read data

   • i2cset -y 2 0x20 0x00 0x05                --> This command set read_bit to one. (Read command)

7. Stop reading data

   • i2cset -y 2 0x20 0x00 0x00                --> This command stops reading from RAM memory.

8. Read data_to_read register

   • i2cget -y 2 0x20 <data to read>           --> This command reads data from desired register.
     
     

For example to read a temperature sensor it is necessary to give the following commands in linux console:

• i2cset -y 2 0x20 0x01 <sensor address>    --> Writing device address

• i2cset -y 2 0x20 0x02 0x0F                --> Writing One-shot register address

• i2cset -y 2 0x20 0x03 0xFF                --> Writing any value in the register to start converting of ADC in sensor

• i2cset -y 2 0x20 0x00 0x03                --> Start to write these values

• i2cset -y 2 0x20 0x00 0x00                --> To turn i2c master data transfer off

• i2cset -y 2 0x20 0x02 0x00                --> Writing address of local temperature high byte register that consists of the temperature value

• i2cset -y 2 0x20 0x00 0x03                --> Start to write these values

• i2cset -y 2 0x20 0x00 0x00                --> To turn i2c master data transfer off

• i2cset -y 2 0x20 0x00 0x05                --> Start to read temperature value of sensor and save it in data_to_read register

• i2cset -y 2 0x20 0x00 0x00                --> To turn i2c master data transfer off

• i2cget -y 2 0x20 0x09                     --> Reading temperature value from data_to_read register

• i2cset -y 2 0x20 0x02 0x15                --> Writing address of local temperature low byte register that consists of fraction of the temperature value

• i2cset -y 2 0x20 0x00 0x03                --> Start to write these values

• i2cset -y 2 0x20 0x00 0x00                --> To turn i2c master data transfer off

• i2cset -y 2 0x20 0x00 0x05                --> Start to read temperature value of sensor and save it in data_to_read register

• i2cset -y 2 0x20 0x00 0x00                --> To turn i2c master data transfer off

• i2cget -y 2 0x20 0x09                     --> Reading temperature fraction value from data_to_read register
  
  

If the following shell script is executed in linux console it can be read all temperatures of all temperature sensors on the board. This script file will be executed automatically while booting, if this file is copied to SD card.

#!/bin/sh

set sensor_addr=0                       # Temperature = Temp+Fraction*16^-1 °C for example 50+1*16^-1 = 50.0625 °C 
Temp=0                                  # 8bits
Fraction=0                              # 4bits                                          
i=0
n1=0
n2=0
for sensor_addr in 0x48 0x4A 0x4B 0x4C 0x4D 0x4E
do
        echo "Sensor Address $sensor_addr:"
        echo "Reading Sensor $i:"
        i2cset -y 2 0x20 0x01 $sensor_addr          # Write sensor address in RAM memory address 0x01
        i2cset -y 2 0x20 0x02 0x0F                  # Write one-shot-start register address in 0x02 of RAM
        i2cset -y 2 0x20 0x03 0xFF                  # Write 0xFF value in 0x03 address of RAM
        i2cset -y 2 0x20 0x00 0x03                  # Writing in sensor
        i2cset -y 2 0x20 0x00 0x00                  # Stop writing
        i2cset -y 2 0x20 0x02 0x00                  # Write 0x00 value (local temperature register high byte address) in 0x02 of RAM memory
        i2cset -y 2 0x20 0x00 0x03                  # Writing in sensor
        i2cset -y 2 0x20 0x00 0x00                  # Stop writing
        i2cset -y 2 0x20 0x00 0x05                  # Reading sensor
        i2cset -y 2 0x20 0x00 0x00                  # Stop reading
        Temp=`i2cget -y 2 0x20 0x09`                # Read temperature value stored in 0x09 address of RAM memory
        #echo $Temp
        n1=$(($Temp))
        #echo $n1
        i2cset -y 2 0x20 0x02 0x15                  # Write 0x15 value (local temperature register low byte address) in 0x02 of RAM memory
        i2cset -y 2 0x20 0x00 0x03                  # Writing in sensor
        i2cset -y 2 0x20 0x00 0x00                  # Stop writing
        i2cset -y 2 0x20 0x00 0x05                  # Reading sensor
        i2cset -y 2 0x20 0x00 0x00                  # Stop reading
        Fraction=`i2cget -y 2 0x20 0x09`            # Read temperature value stored in 0x09 address of RAM memory
        #echo $Fraction
        n2=$((Fraction>>4))                         # Shift bits 4 times            
        #echo $n2      
        echo "-----------------------------"
        #printf "Sensor %d Temperature = %d Celsius \n" $i $Temp
        #printf "Sensor %d Fraction = %d \n" $i $Fraction
        echo "Sensor $i Temperature = "
        awk "BEGIN {print  $n1+$n2*16**-1}"   
        echo "Celsius"
        echo "-----------------------------"
        let i++
done

LED

Green LED

RED LED

Appx. A: Change History and Legal Notices

Revision Changes

• Changes REV02 to REV03:

  • Added i2c slave to communicate with FPGA

  • Added i2c master to read and write temperature sensors  value

  • Added i2c master state machine to manage communication between CPLD and temp. sensors  

  • Added a 8x16 byte RAM to save data in RAM 

  • Correction of power sequencing
• Changes REV01 to REV02:
  • Power Management
  • FAN enable
  • LED blink sequencing
• Changes REV00 to REV01:
  • Power on (min)
  • UART
  • JTAG

Document Change History

To get content of older revision  got to "Change History"  of this page and select older document revision number.

Legal Notices