Quellcode

main.c:

/**
  ******************************************************************************
  * @file    main.c
  * @author  Boris Wasserstrom und Alexander Lange
  * @version V1.0.0
  * @date    16-Mai-2013
  * @brief   Main program body
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "i2c.h"

//#define DEVICE_ADDRESS ((uint8_t)0x29)
#define DEVICE_ADDRESS ((uint8_t) 0x50)
/* Optionen für das Konfigurationsregister vom ADC
 * Das Register besteht aus 8 Bits: D7 D6 D5 D4 D3 D2 D1 D0
 * D7-D4 : Ch1 - Ch4
 * D3    : REF_SEL = Referenz festlegen (1-Versorgungsspannung als Referenz)
 * 										(2-Externe Referenzspannung)
 * D2    : FLTR = ist Filterung von SDA aktiviert(1) oder nicht(0)
 * D1	 	 : Bit trial delay
 * D0    : Sample delay
 */
#define ADC_CH1 ((uint8_t)0x80) 
#define ADC_CH2 ((uint8_t)0x40)
#define ADC_CH3 ((uint8_t)0x20)
#define ADC_CH4 ((uint8_t)0x10)
#define ADC_SUPPLYVOL_REF ((uint8_t)0x00) // Versorgungsspannung als Referenz verwenden
#define ADC_EXTERNVOL_REF ((uint8_t)0x08) // Externe Referenzquelle verweneden
#define ADC_FLTR_ON ((uint8_t)0x04) // Filterung von SDA ist aktiviert
#define ADC_BD_ON ((uint8_t)0x02) // Bit trial delay aktivieren
#define ADC_SD_ON ((uint8_t)0x01) // Symple delay aktivieren
/**********************************************************************************/

// Arrays für Daten, die ADC sendet
uint8_t arrDataCh1[2];
uint8_t arrDataCh2[2];
uint8_t arrDataCh3[2];
uint8_t arrDataCh4[2];
	
// Konfigurationsbytes für die Kanäle
uint8_t cfg_ch1;
uint8_t cfg_ch2;
uint8_t cfg_ch3;
uint8_t cfg_ch4;

// Array mit Endwerten
float arrPrepData[4];

// Funktion zum Warten
void myDelay (__IO uint16_t cntr)
{
	while(cntr--);
}
/**********************************************************************************/

// Funktion zum Ausrechnen von Dezimalwerten
// Aus 2 8-Bit-Werten wird der gemessene Wert bestimmt
float calcValue (uint8_t* rawVal)
{
	__IO float temp; // aktueller Wert ohne Umrechnung (dec)
	__IO float u_ref; // Referenzspannung vom AD-Wandler
	__IO float u_cc;  // Versorgungsspannung von den Sensoren
	__IO float outputADC; //
	__IO float measuredCurrent;
	
  uint16_t fuu =  (rawVal[0] & 0x0F ) << 8;
	u_ref = 4460; // Referenzspannung vom ADC in mV
	u_cc = 4662; // Versorgungsspannung von den Sensoren in mV

// aus 2 empfangenen Bytes wird der eigentliche Messwert berechnet
	temp = (float)(fuu+rawVal[1]);	
	
	outputADC = temp/4096*u_ref; // den berechenten Wert in mV umrechnen
	measuredCurrent = (outputADC - u_cc/2)*200/u_cc/2; // Umwandlung: Spannung in Strom

return measuredCurrent;
	
}

int main(void)
{
	//Variable
	uint8_t len;					//Len: Number of data received (in bytes)
	uint8_t comBuf[100];	//Buf: Buffer of data to be received
	//uint8_t test = 'B';
	int32_t toSend;
	uint8_t usedFields;
	I2CBus_Init();

/* Konfigurationsbytes für die ADC Kanäle
	 * man kann einzelne Optionen, die bereits oben erwähnt wurden, durch ODER verknüpfen
	 */

cfg_ch1 = ADC_CH1 | ADC_EXTERNVOL_REF; //ADC_CH1;
	cfg_ch2 = ADC_CH2 | ADC_EXTERNVOL_REF; //ADC_CH2;
	cfg_ch3 = ADC_CH3 | ADC_EXTERNVOL_REF; //ADC_CH3;
	cfg_ch4 = ADC_CH4 | ADC_EXTERNVOL_REF; //ADC_CH4;

// Initialize USB in Serial Virtual Comm Mode (CDC)
	USBD_Init(&USB_OTG_dev,     
            USB_OTG_FS_CORE_ID, 
            &USR_desc, 
            &USBD_CDC_cb, 
            &USR_cb);
	
	initUSART();	
	
  //Main - Loop
  while(1)
  {
		    	/* Channel 1 vom ADC abfragen */
    	/***************************************************************************************/
    	// I2C1 aktivieren, ADC ansprechen und festlegen, dass der Master Daten übertragen wird
    	I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Transmitter);
    	// 1 Byte mit den Konfig an ADC senden
    	I2C_write(I2C2, cfg_ch1);
    	// I2C1 anhalten und den Bus freigeben
    	I2C_stop(I2C2);

// I2C1 aktivieren, ADC ansprechen und festlegen, dass der Master auf Daten wartet
    	I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Receiver);
    	// Das 1. Byte vom ADC empfangen und mit ACK bestätigen
    	arrDataCh1[0] = I2C_read_ack(I2C2);
    	// Das 2. Byte(das letzte) vom ADC empfangen und mit NACK bestätigen
    	arrDataCh1[1] = I2C_read_nack(I2C2);
    	// I2C anhalten und den Bus freigeben
    	I2C_stop(I2C2);
    	/***************************************************************************************/

/* Channel 2 vom ADC abfragen */
    	/***************************************************************************************/
    	I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Transmitter);
    	I2C_write(I2C2, cfg_ch2);
    	I2C_stop(I2C2);

I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Receiver);
    	arrDataCh2[0] = I2C_read_ack(I2C2);
    	arrDataCh2[1] = I2C_read_nack(I2C2);
    	I2C_stop(I2C2);
    	/***************************************************************************************/

/* Channel 3 vom ADC abfragen */
    	/***************************************************************************************/
    	I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Transmitter);
    	I2C_write(I2C2, cfg_ch3);
    	I2C_stop(I2C2);

I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Receiver);
    	arrDataCh3[0] = I2C_read_ack(I2C2);
    	arrDataCh3[1] = I2C_read_nack(I2C2);
    	I2C_stop(I2C2);
    	/***************************************************************************************/

/* Channel 4 vom ADC abfragen */
    	/***************************************************************************************/
    	I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Transmitter);
    	I2C_write(I2C2, cfg_ch4);
    	I2C_stop(I2C2);

I2C_start(I2C2, DEVICE_ADDRESS, I2C_Direction_Receiver);
    	arrDataCh4[0] = I2C_read_ack(I2C2);
    	arrDataCh4[1] = I2C_read_nack(I2C2);
    	I2C_stop(I2C2);
    	/***************************************************************************************/

/* Messwerte umrechnen und in 1 Array speichern */
    	
    	arrPrepData[0] = calcValue(arrDataCh1);
    	arrPrepData[1] = calcValue(arrDataCh2);
    	arrPrepData[2] = calcValue(arrDataCh3);
    	arrPrepData[3] = calcValue(arrDataCh4);
    	/************************************************/

myDelay(10000);
			
		//Received message via PC?	
		len = VCP_get_char(comBuf);			//len == length of comBuf
		if(len)												  //Received Message via USB?
		{ 
				if(comBuf[0]=='1')
				{
					
					toSend = (int32_t) (arrPrepData[1]*1000);
					usedFields = inttohex(toSend, comBuf);
					comBuf[usedFields] = 0x3B; // Tab Einfügen
					VCP_send_byte(comBuf, usedFields+1);
				}
								if(comBuf[0]=='2')
				{
					
					toSend = (int32_t) (arrPrepData[2]*1000);
					usedFields = inttohex(toSend, comBuf);
					comBuf[usedFields] = 0x3B; // Tab Einfügen
					VCP_send_byte(comBuf, usedFields+1);
				}
								if(comBuf[0]=='3')
				{
					
					toSend = (int32_t) (arrPrepData[3]*1000);
					usedFields = inttohex(toSend, comBuf);
					comBuf[usedFields] = 0x0D; // Enter Einfügen
					VCP_send_byte(comBuf, usedFields+1);
				}
			}
	
	}
}
 
void initUSART(void)
{
	//Send Data
  //   while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET);
	//			USART_SendData(USART3, test);
	//Receive Data				
  //  while (USART_GetFlagStatus(USART3, USART_FLAG_RXNE) == RESET);
	//			test = USART_ReceiveData(USART3);
	
	USART_InitTypeDef USART_InitStructure;	//Used to change USART settings
  //NVIC_InitTypeDef NVIC_InitStructure;		//Used for Interrupt settings - not in use
  GPIO_InitTypeDef GPIO_InitStructure;		//Used for GPIO settings
	
	//Konfiguration USART 2 und 3:
	//Enable peripheral clock using the following functions:
	//------------------------------------------------------
  //RCC_APB2PeriphClockCmd(RCC_APB2Periph_USARTx, ENABLE) for USART1 and USART6 
  //RCC_APB1PeriphClockCmd(RCC_APB1Periph_USARTx, ENABLE) for USART2, USART3, UART4 or UART5.
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);	//Enable Clock for USART2
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);	//Enable Clock for USART3
	
	//According to the USART mode, enable the GPIO clocks using 
  //RCC_AHB1PeriphClockCmd() function. (The I/O can be TX, RX, CTS, or/and SCLK). 
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);		//Configure clock for GPIO
	RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);		//Configure clock for GPIO
    
	//Example - Enable GPIO clock
	//RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOC, ENABLE);	
	//Example - USART clock	
  //RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
		
		
	//Peripheral's alternate function: 
	//--------------------------------
  //Connect the pin to the desired peripherals' Alternate Function (AF) using 
	//GPIO_PinAFConfig() function
  GPIO_PinAFConfig(GPIOA,GPIO_PinSource2,GPIO_AF_USART2);
  GPIO_PinAFConfig(GPIOA,GPIO_PinSource3,GPIO_AF_USART2);
	
	//GPIO_PinAFConfig(GPIOD, GPIO_PinSource8, GPIO_AF_USART3);
  //GPIO_PinAFConfig(GPIOD, GPIO_PinSource9, GPIO_AF_USART3);
	
	//Example - Connect USART pins to AF7
  //GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_USART3);
  //GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_USART3);
	
	
	//Configure the desired pin in alternate function by:
  //GPIO_InitStruct->GPIO_Mode = GPIO_Mode_AF
	//Select the type, pull-up/pull-down and output speed via 
  //GPIO_PuPd, GPIO_OType and GPIO_Speed members
	//Call GPIO_Init() function
	
	//a) USART2
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	
	GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
	
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
  GPIO_Init(GPIOA , &GPIO_InitStructure);
	
	//b) USART3
	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
 	//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
	
	//GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  //GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
	//GPIO_Init(GPIOD, &GPIO_InitStructure);
	
  //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
  //GPIO_Init(GPIOD , &GPIO_InitStructure);
	
  //Example - Configure USART Tx and Rx as alternate function push-pull
	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
  //GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
  //GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  //GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
  //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  //GPIO_Init(GPIOC, &GPIO_InitStructure);
  //GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
  //GPIO_Init(GPIOC , &GPIO_InitStructure);

//In order to reach higher communication baudrates, it is possible to
  //enable the oversampling by 8 mode using the function USART_OverSampling8Cmd().
  //This function should be called after enabling the USART clock (RCC_APBxPeriphClockCmd())
  //and before calling the function USART_Init().

//Example - Enable the USART OverSampling by 8
  USART_OverSampling8Cmd(USART2, ENABLE);
  //USART_OverSampling8Cmd(USART3, ENABLE);    
  
	//Program the Baud Rate, Word Length , Stop Bit, Parity, Hardware 
  //low control and Mode(Receiver/Transmitter) using the 
	//USART_Init()function.
	//Maximum BaudRate that can be achieved when using the Oversampling by 8
	//is: (USART APB Clock / 8) 
	//	 - (USART3 APB1 Clock / 8) = (42 MHz / 8) = 5250000 baud
	//   - (USART1 APB2 Clock / 8) = (84 MHz / 8) = 10500000 baud
	//Maximum BaudRate that can be achieved when using the Oversampling by 16
	//is: (USART APB Clock / 16) 
	//   -  (USART3 APB1 Clock / 16) = (42 MHz / 16) = 2625000 baud
	//   -  (USART1 APB2 Clock / 16) = (84 MHz / 16) = 5250000 baud

//Speed tested: 9600 / 115200
  USART_InitStructure.USART_BaudRate = 5250000;	//5250000
  USART_InitStructure.USART_WordLength = USART_WordLength_8b;
  USART_InitStructure.USART_StopBits = USART_StopBits_1;
  USART_InitStructure.USART_Parity = USART_Parity_No;
  USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
  USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
  USART_Init(USART2, &USART_InitStructure);
	//USART_Init(USART3, &USART_InitStructure);
	
  //Enable the NVIC and the corresponding interrupt using the function 
  //USART_ITConfig() if you need to use interrupt mode. 
	//Example - NVIC configuration
  //Configure the Priority Group to 2 bits
  //NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
	//Enable the USARTx Interrupt
  //NVIC_InitStructure.NVIC_IRQChannel = USARTx_IRQn;
  //NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  //NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  //NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  //NVIC_Init(&NVIC_InitStructure);
	
	
  //When using the DMA mode 
  //Configure the DMA using DMA_Init() function
  //Active the needed channel Request using USART_DMACmd() function
   
  //Enable the USART using the USART_Cmd() function.
  USART_Cmd(USART2, ENABLE); //Enable USART2
  //USART_Cmd(USART3, ENABLE); //Enable USART3
}
/**
  * @brief  MEMS accelerometre management of the timeout situation.
  * @param  None.
  * @retval None.
  */
uint32_t LIS302DL_TIMEOUT_UserCallback(void)
{
  /* MEMS Accelerometer Timeout error occured */
  while (1)
  {   
  }
}

/**
  * @brief  Decrements the TimingDelay variable.
  * @param  None
  * @retval None
  */
void TimingDelay_Decrement(void)
{
  if (TimingDelay != 0x00)
  { 
    TimingDelay--;
  }
}

uint8_t inttohex(int32_t czahl, uint8_t chex[])
{
				uint32_t teiler = 1000000000;		//Unit 32 max 10 digits
			  uint8_t i = 0;									//counter
				uint8_t j = 0;									//counter
				uint8_t k = 0;									//counter
				int8_t zw[10];									//Array
				uint8_t negative = 0;
		
				// Check if negative
				if ( czahl < 0 )
				{
					czahl = -1*czahl;
					negative = 1;
				}
	
				//Conversion
			  while (i<10)
				{	
					chex[i] = czahl/teiler + 0x30;//e.g. next digit = 231/100 = 2 equals 32 hex	
					czahl %= teiler;							//e.g. rest = 231%100 = 31
					teiler /= 10;									//for next digit 100 -> 10.. 31/10=3.. 31%10=1.. 
					i++;													
				}			
				//Delete leading zero e.g 0001242 -> 1242
				i = 0;													//reset
				while (chex[i] == 0x30)					//count leading zeros?
				{
					i++;													//count leading zeros
				}
				j = 0;													//reset
				while (i<10)			
				{	
					zw[j] = chex[i];							//write actual number to 2nd array
					i++;
					j++;
				}

i = j;													//save number of digits
				k = 0;
				j = 0;

if (negative == 1)
				{
					chex[0] =0x2D; //insert minus
					i++;												
				  j++;
				}

while (k<=i)
				{
					if ( j == (i-3))
					{
						chex[j] = 0x2E;
						j++;
					}
					chex[j]=zw[k];
					j++;
					k++;
				}	
				
				return ++i;
}

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

main.h:

/** ****************************************************************************** * @file main.h * @author Lukas Berger * @version V1.0.0 * @date 18-Oktober-2012 * @brief Header for main.c module ****************************************************************************** */ /* Define to prevent recursive inclusion -------------------------------------*/ #ifndef __STM32F4_DISCOVERY_DEMO_H #define __STM32F4_DISCOVERY_DEMO_H /* Includes ------------------------------------------------------------------*/ #include <stdio.h> #include "stm32f4xx_conf.h" #include "stm32f4_discovery.h" #include "stm32f4_discovery_lis302dl.h" #include "usbd_cdc_core.h" #include "usbd_usr.h" #include "usbd_desc.h" #include "usbd_cdc_vcp.h" /* Exported types ------------------------------------------------------------*/ /* Exported constants --------------------------------------------------------*/ /* Exported macro ------------------------------------------------------------*/ #define ABS(x) (x < 0) ? (-x) : x #define MAX(a,b) (a < b) ? (b) : a /* Exported functions ------------------------------------------------------- */ void TimingDelay_Decrement(void); void Delay(__IO uint32_t nTime); void Fail_Handler(void); /* Private typedef -----------------------------------------------------------*/ #pragma pack(push) /* push current alignment to stack */ #pragma pack(1) /* set alignment to 1 byte boundary */ #pragma pack(pop) /* set default */ /* Private define ------------------------------------------------------------*/ /* Private macro -------------------------------------------------------------*/ /* Private variables ---------------------------------------------------------*/ #ifdef USB_OTG_HS_INTERNAL_DMA_ENABLED #if defined ( __ICCARM__ ) /*!< IAR Compiler */ #pragma data_alignment = 4 #endif #endif /* USB_OTG_HS_INTERNAL_DMA_ENABLED */ __ALIGN_BEGIN USB_OTG_CORE_HANDLE USB_OTG_dev __ALIGN_END; __IO uint32_t TimingDelay; void initUSART(void); uint8_t inttohex(int32_t czahl, uint8_t chex[]); #endif /* __STM32F4_DISCOVERY_DEMO_H */ /******************* (C) COPYRIGHT 2011 STMicroelectronics *****END OF FILE****/

i2c.c:

/* File: i2c.c * Date: 18.04.13 * Author: Boris Wasserstrom * Description: This file contains functions for I2C1-Bus of STM32F4xx */ #ifndef _I2C_C #define _I2C_C #include <i2c.h> // Initialisierungsstruktur für IO-Ports anlegen GPIO_InitTypeDef GPIO_InitStruct; // Initialisierungsstruktur für I2C1 anlegen I2C_InitTypeDef I2C_InitStruct; uint8_t data; void I2CBus_Init (void) { // Clock für die notwendigen Pins einschalten RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE); // Pins für I2C1 konfigurieren // PB11 = SDA // PB10 = SCL GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11; GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF; GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStruct.GPIO_OType = GPIO_OType_OD; GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP; GPIO_Init(GPIOB, &GPIO_InitStruct); // Aktivierte Pins für I2C1 (AF) freischalten GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_I2C2); GPIO_PinAFConfig(GPIOB, GPIO_PinSource11, GPIO_AF_I2C2); // Clock für I2C1 einschalten RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE); // I2C konfigurieren I2C_InitStruct.I2C_ClockSpeed = 100000; I2C_InitStruct.I2C_Mode = I2C_Mode_I2C; I2C_InitStruct.I2C_DutyCycle = I2C_DutyCycle_2; I2C_InitStruct.I2C_OwnAddress1 = 0x00; I2C_InitStruct.I2C_Ack = I2C_Ack_Disable; // Im Lesemodus ACK deaktivieren I2C_InitStruct.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit; I2C_Init(I2C2, &I2C_InitStruct); // I2C aktivieren I2C_Cmd(I2C2, ENABLE); } /**********************************************************************************/ void I2C_start(I2C_TypeDef* I2Cx, uint8_t addr, uint8_t direction) { // warten bis die I2C-Leitung frei wird while(I2C_GetFlagStatus(I2Cx, I2C_FLAG_BUSY)); // START-Bedingung I2C_GenerateSTART(I2Cx, ENABLE); // Warten bis Slave mit ACK bestätigt hat while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_MODE_SELECT)); // Adresse vom Slave senden I2C_Send7bitAddress(I2Cx, addr, direction); // Warten bis Slave den Master als Empfänger bzw. Sender bestätigt hat if(direction == I2C_Direction_Transmitter){ while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED)); } else if(direction == I2C_Direction_Receiver){ while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED)); } } /**********************************************************************************/ // Sendet 1 Byte an den Slave und wartet auf die Bestätigung void I2C_write(I2C_TypeDef* I2Cx, uint8_t data) { I2C_SendData(I2Cx, data); while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_TRANSMITTED)); } /**********************************************************************************/ // Diese Funktion empfängt 1 Byte vom Slave und bestätigt den Empfang mit ACK // (notwendig, falls weitere Bytes mit Daten folgen) uint8_t I2C_read_ack(I2C_TypeDef* I2Cx) { // ACK aktivieren I2C_AcknowledgeConfig(I2Cx, ENABLE); // warten bis 1 Byte empfangen wurde while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_RECEIVED) ); // Daten ausm Register lesen data = I2C_ReceiveData(I2Cx); return data; } /**********************************************************************************/ // 1 Byte empfangen und Mit NACK bestätigen // (zum Empfangen vom letzten Byte) uint8_t I2C_read_nack(I2C_TypeDef* I2Cx) { // ACK deaktivieren I2C_AcknowledgeConfig(I2Cx, DISABLE); // warten bis 1 Byte empfangen wurde while(!I2C_CheckEvent(I2Cx, I2C_EVENT_MASTER_BYTE_RECEIVED) ); // Daten ausm Register lesen data = I2C_ReceiveData(I2Cx); return data; } /**********************************************************************************/ // STOP-Bedingung, gibt den Bus frei void I2C_stop(I2C_TypeDef* I2Cx) { I2C_GenerateSTOP(I2Cx, ENABLE); } /**********************************************************************************/ #endif /*_I2C_C*/

i2c.h:

/* File: i2c.h * Date: 18.04.13 * Author: Boris Wasserstrom * Description: This file contains prototypes for i2c.c */ #ifndef _I2C_H #define _I2C_H #include <stm32f4xx.h> #include <stm32f4xx_gpio.h> #include <stm32f4xx_rcc.h> #include <stm32f4xx_i2c.h> void I2CBus_Init(void); void I2C_start(I2C_TypeDef*, uint8_t, uint8_t); void I2C_write(I2C_TypeDef*, uint8_t); uint8_t I2C_read_ack(I2C_TypeDef*); uint8_t I2C_read_nack(I2C_TypeDef*); void I2C_stop(I2C_TypeDef*); #endif /*_I2C_H*/

Datenblatt ADC