Anbindung SHT71 an STM32F4Discovery

[(unknown) (Gast)]

Hallo Leute,

Für ein Projekt habe ich die Aufgabe gefasst einen Feuchte-Temp Sensor 
von Sensirion (SHT71) an das STM32F4Discovery Board anzuhängen. Geht mal 
primär davon aus, dass ich ein totaler Noob bin und davon keinen blassen 
Schimmer habe.

Ich habe nun diverse Beispielprogramme laufen lassen und analysiert und 
danach auf Keil uVision 4 ein Programm geschrieben. Oh Wunder es tut 
nicht wie ich mir das vorstelle.

Code unten. Der Sensor wurde mit einem Pullupwiderstand an der 
Datenleitung angebunden. Ich kann kompilieren, Der Code läuft auch, 
bloss dass ich im Debugger keine Temperatur bekomme. Lustigerweise 
bekomme ich ein ACK vom Sensor (da habe ich eine rote LED leuchten 
lassen, wenn der die Datenleitung auf 0 zieht)

Für Tipps oder Hilfe wäre ich sehr dankbar, wenn mehr Infos nötig sind, 
dann liefere ich die gerne nach...

int main(void) {
  
  /*  Setup of the I2C Interface to SHT71 Sensor */
  setup_I2C();
  
   /* Initialize LEDs mounted on STM32F4-Discovery board */
  STM_EVAL_LEDInit(LED5);  
  
  while (1) {
    /*   Temperatur lesen */
    uint8_t mytemp[] = { 0, 0, 0};
    read_SHT71(TMP_ADRESS, mytemp);
    
    helptemp = mytemp[0]*256 + mytemp[1];
    temp = 0.01 * helptemp - 39.6;
    
    Delay(10000L);
    
  
    Delay(25000000L);
  }
}

void setup_I2C(void)
{
  /*  GPIO Setup  
      Initialise Pins PB6 and PB7*/
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  GPIO_I2C.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_I2C.GPIO_Mode = GPIO_Mode_AF;
  GPIO_I2C.GPIO_OType = GPIO_OType_PP;
  GPIO_I2C.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_I2C.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOB, &GPIO_I2C);
}

void read_SHT71(uint8_t adr, uint8_t * data) {
  uint8_t i;
  uint8_t j;
  uint8_t helpdata[]= {0,0,0,0,0,0,0,0};
  
  /* Start Transmission
  *       ___     ___
  * SCL _/   \___/   \____
  *     ___        _____ 
  * SDA    \______/     \_
  */
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //SCL 1
  Delay(5000L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_7); //SDA 0
  Delay(5000L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); //SCL 0
  Delay(1000L);
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //SCL 1
  Delay(500L);
  GPIO_SetBits(GPIOB, GPIO_Pin_7);   //SDA 1
  Delay(500L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); //SCL 0
  Delay(1000L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_7); //SDA 0
  Delay(1000L);
  
  /* Send Adress
  *
  * Temperature = 000 0011
  * Humidity    = 000 0101
  *
  */
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(125L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
  Delay(125L);
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(125L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
  Delay(125L);
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(125L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
  Delay(125L);
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(125L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
  Delay(55L);
  
  //SDA 1 if Humidity measuring, 0 else
  if (adr == HUM_ADRESS) {
    GPIO_SetBits(GPIOB, GPIO_Pin_7);       
  }
  else {
    GPIO_ResetBits(GPIOB, GPIO_Pin_7); 
  }
  Delay(55L);
  
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(125L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
  Delay(55L);
  
  //SDA 1 if Temperature measuring, 0 else
  if (adr == TMP_ADRESS) {
    GPIO_SetBits(GPIOB, GPIO_Pin_7);       
  }
  else {
    GPIO_ResetBits(GPIOB, GPIO_Pin_7);
  }
  Delay(55L);
  
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(125L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6);
  Delay(55L);
  
  //SDA 1 if Temperature or Humidity measuring, 0 else
  if (adr == HUM_ADRESS) {
    GPIO_SetBits(GPIOB, GPIO_Pin_7);   //SDA 1    
  }
  else if (adr == TMP_ADRESS) {
    GPIO_SetBits(GPIOB, GPIO_Pin_7);   //SDA 1    
  }
  else {
    GPIO_ResetBits(GPIOB, GPIO_Pin_7); //SDA 0
  }
  Delay(55L);
  
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(125L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6);
  Delay(125L);
  
  // Read ACK = 0
  GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
  Delay(55L);
  if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7) == 0) {
    STM_EVAL_LEDOn(LED5); // Red LED if Ack, funktioniert
  }
  Delay(55L);
  GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
  Delay(100000L);
  
  /*wait for sensor to pull data line low after completion of measurement */
  while (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7) != 0) {
  }
  Delay(125L);
  
  /*
  * Reading the Data 
  * High Byte, Ack, then low Byte
  */
  
  for (i = 0; i < 2; i++) {
    for (j = 0; j < 8; j++) {
      GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
      Delay(55L);
      if (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7) == 0) {
        helpdata[j] = 0;
      }
      else {
        helpdata[j] = 1;
      }
      Delay(55L);
      GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
      Delay(125L);
      }
    data[i] = helpdata[0]*128+helpdata[1]*64+helpdata[2]*32+helpdata[3]*16+helpdata[4]*8+helpdata[5]*4+helpdata[6]*2+helpdata[7];
    // Ack to Sensor (only first time)
    if (i == 0) {
      GPIO_ResetBits(GPIOB, GPIO_Pin_7); //SDA 0
      GPIO_SetBits(GPIOB, GPIO_Pin_6);   //Clock
      Delay(125L);
      GPIO_ResetBits(GPIOB, GPIO_Pin_6); 
      GPIO_SetBits(GPIOB, GPIO_Pin_7);   //SDA 1
      Delay(125L);
    }
  }
}

[(prx) A. K. (prx)]

Die Initialisierungssequenz aus 10 Takten fehlt.

Beide Pins werden als PushPull Ausgänge definiert. Die Datenleitung ist 
aber bidirektional und muss als Open Drain definiert werden.

Die Pins werden als AF definiert, aber korrekterweise als programmierte 
I/Os genutzt. AF verbindet statt dessen mit dem I2C Controller, folglich 
passiert überhaupt nichts.

Siehe Beitrag "Sensirion SHT11 Code".

[erhardd (Gast)]

...du setzt und resetzt die Pins als GPIO's:
wäre es nicht günstiger, sie auch so zu config. ?
void I2C_Configuration(void)
{

  GPIO_InitTypeDef  GPIO_InitStructure;
  /* Configure SCCB pins: PE4->SCL and PE5->SDA */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOE, ENABLE);
  GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_4 | GPIO_Pin_5;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  //     4  50
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;

  GPIO_Init(GPIOE, &GPIO_InitStructure);
}

[erhardd (Gast)]

...ups, er war schneller..

[erhardd (Gast)]

...und es ist SCCB;

[(unknown) (Gast)]

Danke erhardd und A.K. Ich bin dabei, den Code anzupassen und eure 
Inputs einzupflegen.

Kurze Rückfrage:

Ich definiere die GPIO Pins PB6 und PB7 als OUT, Open Drain und NoPull. 
Wenn ich die Startsequenz im Debugger laufen lasse kann ich schön sehen, 
wie die Spannung rauf und runtergeht an den zwei PINS. (jaja KO wär 
schön)

Muss ich den Datenpin PB7 umdefinieren (zu IN), wenn ich vom Sensor die 
Messwerte empfangen will (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7)), 
oder geht das auch bei einem auf GPIO_Mode_OUT gesetzten Pin?

Danke echt nochmals, ihr rettet mir hier wirklich den Tag.

[(prx) A. K. (prx)]

Reto Lüchinger schrieb:
> Muss ich den Datenpin PB7 umdefinieren (zu IN), wenn ich vom Sensor die
> Messwerte empfangen will

Nein. es reicht aus, den Ausgang auf high zu setzen, damit der Open 
Drain Treiber inaktiv ist.

[erhardd (Gast)]

Reto Lüchinger schrieb:
> Muss ich den Datenpin PB7 umdefinieren (zu IN), wenn ich vom Sensor die
> Messwerte empfangen will (GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_7)),
> oder geht das auch bei einem auf GPIO_Mode_OUT gesetzten Pin?

...aus meiner Kameraanwendung für das F4-Discovery:
static int I2C_ReceiveByte(void)
{
    uint8_t i=8;
    uint8_t ReceiveByte=0;

    SDA_H;
    while(i--)
    {
      ReceiveByte<<=1;
      SCL_L;
      I2C_delay();
    SCL_H;
      I2C_delay();
      if(SDA_read)
      {
        ReceiveByte|=0x01;
      }
    }
    SCL_L;
    return ReceiveByte;
}
- und aus der SCCB.h:
/* Private define 
------------------------------------------------------------*/
#define SCL_H         GPIO_SetBits(GPIOE , GPIO_Pin_4)   /* 
GPIOB->BSRRL = GPIO_Pin_8  */
#define SCL_L         GPIO_ResetBits(GPIOE , GPIO_Pin_4)  /* 
GPIO_ResetBits(GPIOB , GPIO_Pin_10) */

#define SDA_H         GPIO_SetBits(GPIOE , GPIO_Pin_5) /* 
GPIO_SetBits(GPIOB , GPIO_Pin_11)   */
#define SDA_L         GPIO_ResetBits(GPIOE , GPIO_Pin_5)   /* 
GPIO_ResetBits(GPIOB , GPIO_Pin_11) */

#define SCL_read      GPIOE->IDR  & GPIO_Pin_4   /* 
GPIO_ReadInputDataBit(GPIOB , GPIO_Pin_10) */
#define SDA_read      GPIOE->IDR  & GPIO_Pin_5 /* 
GPIO_ReadInputDataBit(GPIOB , GPIO_Pin_11) */

#define ADDR_OV7725   0x42 // 2a

[erhardd (Gast)]

...lies mal nach RM0090 6.3.10 Output configuration:

Zitat:"When the I/O port is programmed as output:
● The output buffer is enabled:
– Open drain mode: A “0” in the Output register activates the N-MOS 
whereas a “1”
in the Output register leaves the port in Hi-Z (the P-MOS is never 
activated)
...
...
● The data present on the I/O pin are sampled into the input data 
register every AHB1
clock cycle
● A read access to the input data register gets the I/O state
" /Zitat

[Andreas (Gast)]

Vielleicht hilft das hier auch: 
http://pic-projekte.de/phpBB3/viewtopic.php?f=39&t=94

[Daniel B. (dbuergin)]

So wie ich das sehe, verwendest Du das I2C subsystem oder ?

Bin nicht sicher, ob das wirklich gut kommt. Die älteren SHT Sensoren
sht11, sht15, sht71 und sht75 sind nicht wirklich I2C Sensoren.
Erst die neuen Dinger sht21 und sht25 haben offizielle I2C 
Schnittstellen.

Ich würde ganz normale Pins nehmen, und eines der vorhandenen Beispiele
hier im Forum anpassen.

z.B. Beitrag "Tempertur/Feuchte Display/Logger mit ATMega128  SHT75  SD-Karte" ;-)

Daniel

[(unknown) (Gast)]

Danke Leute,

Ich habs hinbekommen. Muss mal echt festhalten, dass das hier ein 
verd***t geiles Forum ist. Alle eure Hinweise waren nützlich für mich! 
Falls jemand mit einem ähnlichen Problem durchkommt, häng ich mal noch 
den Code der main Routine an.

Teile darin sind aus dem Blinky- Beispiel, ein Teil aus dem EXTI - 
Beispiel, welches mit dem STM32F4Discovery Board geliefert wird. Ich 
benötige die Standard Peripheral Libraries (v.a. rcc, exti und gpio) und 
stm32f4_discovery.c.

/**
  ******************************************************************************
  * @file    main.c 
  * @author  Reto Lüchinger
  * @version V0.0.0
  * @date    30-May-2012
  * @brief   Main Programm, Initialisieren des STM32F4Discovery Boards
  ******************************************************************************
* Dieses Programm liest einen SHT71 FT Sensor aus und lässt LED blinken,       
* Am Pushbutton hängt ein Interrupt
*
*
******************************************************************************  
  */ 

/* Includes ------------------------------------------------------------------*/
#include "stm32f4xx.h"
#include "stm32f4xx_conf.h"
#include "stm32f4_discovery.h"
/* Private typedef -----------------------------------------------------------*/
GPIO_InitTypeDef  GPIO_InitStructure, GPIO_SHT;
EXTI_InitTypeDef   EXTI_InitStructure;
/* Private define ------------------------------------------------------------*/
#define TMP_ADRESS 0x03
#define HUM_ADRESS 0x05
#define SDA_read      GPIOB->IDR  & GPIO_Pin_7 /*GPIO_ReadInputDataBit(GPIOB , GPIO_Pin_7) */
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
uint8_t i;
/* Private function prototypes -----------------------------------------------*/
void setup_I2C(void);
void EXTILine0_Config(void);
int16_t read_SHT71(uint8_t adr);
void Delay(__IO uint32_t nCount);
void nop1(void);
static void scl_pulse(void);
static void  scl_hi(void);
static void  scl_lo(void);
static void  sda_hi(void); 
static void  sda_lo(void);
static uint8_t  sda_val(void);
static uint8_t crc_value;
static uint8_t send(uint16_t b);
static uint8_t recv_data(void);
static uint8_t recv_crc(void);
static void start_SHT(void);
uint8_t sht71_start_temp(void);
uint8_t sht71_start_humid(void);
uint8_t sht71_ready(void);
static int16_t result(void);

/* Private functions ---------------------------------------------------------*/


void Delay(__IO uint32_t nCount) { while(nCount--) {  } }
void nop1(void){ Delay(5000L); }

/**
  * @brief  Main program
  * @param  None
  * @retval None
  */
int main(void) {
  float acttemp, acthum, humlin;
  int16_t mytemp;
  int16_t myhum;
  /*  Setup of the I2C Interface to SHT71 Sensor */
  setup_I2C();
  
   /* Initialize LEDs mounted on STM32F4-Discovery board */
  STM_EVAL_LEDInit(LED3);
  STM_EVAL_LEDInit(LED4);
  STM_EVAL_LEDInit(LED5);
  STM_EVAL_LEDInit(LED6);
  
  /* Configure EXTI Line0 (connected to PA0 pin = Pushbutton) in interrupt mode */
  EXTILine0_Config();

  /* Generate software interrupt: simulate a rising edge applied on EXTI0 line */
  EXTI_GenerateSWInterrupt(EXTI_Line0);
 
  
  
  while (1) {
    /*   Feuchte und Temperatur lesen */
    mytemp = read_SHT71(TMP_ADRESS);
    
    acttemp = 0.01 * mytemp - 39.6; 
    
    myhum =  read_SHT71(HUM_ADRESS);
    
    humlin = 0.0367 * myhum - 2.0468 - 0.0000015955*myhum*myhum;
    acthum = (acttemp-25)*(0.01+0.00008*myhum)+humlin;
    acthum = acthum + 1 -1; // Debugger zeigt Wert nur an, wenn er verwendet wird
    
    
    
    
    /* lässt LEDs rotieren
    *
    * Dies soll Basis werden für Ampelsteuerung
    */
    
    /* Set Green LED */
    STM_EVAL_LEDOn(LED4);
    /* Reset Orange, Red, and Blue LED*/
    STM_EVAL_LEDOff(LED3);
    STM_EVAL_LEDOff(LED5);
    STM_EVAL_LEDOff(LED6);
    Delay(25000000L);
 
    /* Set Orange LED */
    STM_EVAL_LEDOn(LED3);
    /* Reset Green, Red, and Blue LED*/
    STM_EVAL_LEDOff(LED4);
    STM_EVAL_LEDOff(LED5);
    STM_EVAL_LEDOff(LED6);
    Delay(25000000L);
 
    /* Set Red LED */
    STM_EVAL_LEDOn(LED5);
    /* Reset Green, Orange, and Blue LED*/
    STM_EVAL_LEDOff(LED4);
    STM_EVAL_LEDOff(LED3);
    STM_EVAL_LEDOff(LED6);
    Delay(25000000L);
 
    /* Set Blue LED */
    STM_EVAL_LEDOn(LED6);
    /* Reset Green, Orange and Red LED*/
    STM_EVAL_LEDOff(LED4);
    STM_EVAL_LEDOff(LED3);
    STM_EVAL_LEDOff(LED5);
    Delay(25000000L);
  }
}

void setup_I2C(void)
{
  /*  GPIO Setup  
      Initialise Pins PB6 and PB7*/
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
  GPIO_SHT.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
  GPIO_SHT.GPIO_Mode = GPIO_Mode_OUT;
  GPIO_SHT.GPIO_OType = GPIO_OType_OD;
  GPIO_SHT.GPIO_Speed = GPIO_Speed_2MHz;
  GPIO_SHT.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_Init(GPIOB, &GPIO_SHT);
  
  sda_hi(); scl_lo(); // Initial conditions
}

static void scl_pulse(void)    { scl_hi();  nop1(); scl_lo();}
static void  scl_hi(void)      { GPIO_SetBits(GPIOB, GPIO_Pin_6); }
static void  scl_lo(void)      { GPIO_ResetBits(GPIOB, GPIO_Pin_6); }
static void  sda_hi(void)      { GPIO_SetBits(GPIOB, GPIO_Pin_7); }
static void  sda_lo(void)      { GPIO_ResetBits(GPIOB, GPIO_Pin_7); }
static uint8_t  sda_val(void) { 
  uint8_t v = 0x00;
  if(SDA_read) {v|=0x01;}
  return v;
  }

/* calculate CRC value*/
static void crc8(uint8_t b) {
  for (i = 0; i < 8; ++i) {
    if ((crc_value ^ b) & 0x80) {
      crc_value <<= 1;
      crc_value ^= 0x31;
    } 
    else crc_value <<= 1;
    b <<= 1;
  }
}

static uint8_t send(uint16_t b) {
  uint8_t ack;
  crc8(b);  
  // data
  for (i = 0; i < 8; ++i) {
    if (b & 0x80) sda_hi();
    else sda_lo();
    b <<= 1;
    nop1();
    scl_pulse();
  }

  // read acknowledge (low)
  nop1();
  scl_hi();  nop1();
  ack = sda_val();
  scl_lo();
  return ack;
}

static uint8_t recv_data(void) {
  // data
  uint8_t b;
  b  = 0;
  for (i = 0; i < 8; ++i) {
    // data is transmitted MSB first
    b <<= 1;
    if (sda_val()) b |= 1;
    scl_pulse();
    nop1();
  }

  // lo acknowledge
  sda_lo();
  nop1();
  scl_pulse();
  sda_hi();
  nop1();

  crc8(b);
  return b;
}

static uint8_t recv_crc(void) {
  // data
  uint8_t b;
  b = 0;
  for (i = 0; i < 8; ++i) {
    // CRC is transmitted LSB first
    b >>= 1;
    if (sda_val()) b |= 0x80;
    scl_pulse();
    nop1();
  }

  // hi acknowledge
  sda_hi();
  nop1();
  scl_pulse();
  nop1();
  return b;
}

static void start_SHT(void) {
  sda_hi(); scl_lo(); // Initial conditions
  crc_value = 0x00;
  nop1();
  
  // reset communication, 10 clock pulses
  for (i = 0; i < 10; ++i) { scl_pulse(); nop1(); }

  /* "Start" Sequence
  *       __   __
  * SCL _/  \_/  \_
  *     ___     ___ 
  * SDA    \___/  
  */
  scl_hi();  nop1();  sda_lo(); nop1(); 
  scl_lo();  nop1(); scl_hi();  nop1();
  sda_hi();  nop1();  scl_lo();  nop1(); 
}

uint8_t sht71_start_temp(void)  { start_SHT(); return send(TMP_ADRESS) == 0; }
uint8_t sht71_start_humid(void) { start_SHT(); return send(HUM_ADRESS) == 0; }

static int16_t result(void) {
  int16_t v;
  uint8_t crc;
  // if (!sht71_ready()) return 0;
  // read senor data high byte, low byte
  v = recv_data() << 8; v |= recv_data();
  crc = recv_crc();
  if (crc != crc_value) return 0;
  return v;
}

int16_t read_SHT71(uint8_t adr) {
  int16_t data;
  
  // Start Transmission
  start_SHT();
  
  /* Send Adress
  * Temperature = 000 00011
  * Humidity    = 000 00101
  */
  if (send(adr) != 0x00) return 0xFFFF;
  while(SDA_read) {     }
  data = result();
  return data;
}

void EXTILine0_Config(void)
{
  
  GPIO_InitTypeDef   GPIO_InitStructure;
  NVIC_InitTypeDef   NVIC_InitStructure;

  /* Enable GPIOA clock */
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  /* Enable SYSCFG clock */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
  
  /* Configure PA0 pin as input floating */
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  /* Connect EXTI Line0 to PA0 pin */
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA, EXTI_PinSource0);

  /* Configure EXTI Line0 */
  EXTI_InitStructure.EXTI_Line = EXTI_Line0;
  EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
  EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;  
  EXTI_InitStructure.EXTI_LineCmd = ENABLE;
  EXTI_Init(&EXTI_InitStructure);

  /* Enable and set EXTI Line0 Interrupt to the lowest priority */
  NVIC_InitStructure.NVIC_IRQChannel = EXTI0_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x01;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x01;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);
}

/****END OF FILE****/