Generating a signal triangulair Using DAC

/** SABRI OUESALTI**/


program :

#include <stm32f4xx_gpio.h>
#include <stm32f4xx_rcc.h>
#include "stm32f4xx_dac.h"

void DACconfig( )
{
GPIO_InitTypeDef GPIO_InitStructure;
  DAC_InitTypeDef DAC_InitStructure;
    TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;

  /* Enable DAC and GPIOC clock */
    
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_DAC | RCC_APB1Periph_TIM2, ENABLE);

  /* Configure PA.04 (DAC) as output -------------------------*/
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOA, &GPIO_InitStructure);


  /* TIM2 Configuration */
  TIM_TimeBaseStructInit(&TIM_TimeBaseStructure);
  TIM_TimeBaseStructure.TIM_Period = 0xF;
  TIM_TimeBaseStructure.TIM_Prescaler = 0xF;
  TIM_TimeBaseStructure.TIM_ClockDivision = 0x0;
  TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
  TIM_TimeBaseInit(TIM2, &TIM_TimeBaseStructure);

  /* TIM2 TRGO selection */
  TIM_SelectOutputTrigger(TIM2, TIM_TRGOSource_Update);

  /* DAC channel1 Configuration */
  DAC_InitStructure.DAC_Trigger = DAC_Trigger_T2_TRGO;
  DAC_InitStructure.DAC_WaveGeneration =  DAC_WaveGeneration_Triangle;
  DAC_InitStructure.DAC_LFSRUnmask_TriangleAmplitude = DAC_TriangleAmplitude_4095;
  DAC_InitStructure.DAC_OutputBuffer = DAC_OutputBuffer_Disable;
  DAC_Init(DAC_Channel_1, &DAC_InitStructure);


  DAC_Cmd(DAC_Channel_1, ENABLE);

  /* TIM2 enable counter */
  TIM_Cmd(TIM2, ENABLE);

}


int main()
{
 DACconfig();

while(1){

}
}

STM32F4: External interrupt EXTI and LEDs

This  is a simple program to configure an external interrupt exactly the blue boutton in the STM32 card that is linked to the PA0 pin and controlling the functionality of the LEDs.
main program: turn on the LEDs PD12, PD13.
interrupt routine: turn on the LEDs PD14, PD15.

The next picture shows you the interrupt scheme: we will use the EXTI0

/**
  ******************************************************************************
  * @prg     STM32F4
  * @file    External interrupt :Button A0
  * @author  SABRI OUESALTI
  * @site    http://electronicsabriart.blogspot.com/
  *****************************************************************************/  

#include "stm32f4xx.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"


void button_A0 (void) {
   RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA,ENABLE) ;
   GPIO_DeInit(GPIOA) ;
   GPIO_InitTypeDef  GPIO_Initconfiguration ;
   GPIO_Initconfiguration.GPIO_Mode = GPIO_Mode_IN ;
   GPIO_Initconfiguration.GPIO_OType =GPIO_OType_PP ;
   GPIO_Initconfiguration.GPIO_Speed =GPIO_Speed_2MHz ;
   GPIO_Initconfiguration.GPIO_PuPd =GPIO_PuPd_NOPULL ;
   GPIO_Initconfiguration.GPIO_Pin = GPIO_Pin_0 ;
   GPIO_Init(GPIOA ,&GPIO_Initconfiguration) ;
}

void EXTI_init(void) {
   SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOA,EXTI_PinSource0);
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG,ENABLE) ; //clock of interruption//
   EXTI_InitTypeDef EXTI_InitStructure ;
  
   EXTI_InitStructure.EXTI_Line =EXTI_Line0 ;
   EXTI_InitStructure.EXTI_Mode =EXTI_Mode_Interrupt ;
   EXTI_InitStructure.EXTI_Trigger =EXTI_Trigger_Rising_Falling ;
   EXTI_InitStructure.EXTI_LineCmd = ENABLE ;
   EXTI_Init(&EXTI_InitStructure) ; }

void NVIC_init ( void) {
   NVIC_InitTypeDef NVIC_InitStructure ;
   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) ;
}



void led_init(void) {
  
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD,ENABLE) ;
  GPIO_DeInit(GPIOD) ;
  GPIO_InitTypeDef  GPIO_Initconfiguration ;
  
   GPIO_Initconfiguration.GPIO_Mode = GPIO_Mode_OUT ;
   GPIO_Initconfiguration.GPIO_OType =GPIO_OType_PP ;
   GPIO_Initconfiguration.GPIO_Speed =GPIO_Speed_2MHz ;
   GPIO_Initconfiguration.GPIO_PuPd =GPIO_PuPd_NOPULL ;
   GPIO_Initconfiguration.GPIO_Pin =          GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15 ;
   GPIO_Init(GPIOD ,&GPIO_Initconfiguration) ;
}

int main(void)
{

led_init() ;
button_A0() ;
EXTI_init() ;
NVIC_init() ;
  while (1)
  {
    GPIO_SetBits(GPIOD,GPIO_Pin_12) ;  
    GPIO_SetBits(GPIOD,GPIO_Pin_13) ;  
    GPIO_ResetBits(GPIOD,GPIO_Pin_14) ;
    GPIO_ResetBits(GPIOD,GPIO_Pin_15) ;

  }
}


======================================================
in the interrupt program stm32f4xx_it. you must write the following function
======================================================

#include "stm32f4xx_it.h"
void EXTI0_IRQHandler(void) {
  
//pending that interrupt flag is set//
  if(EXTI_GetITStatus(EXTI_Line0) != RESET){
  GPIO_SetBits(GPIOD,GPIO_Pin_14) ;
  GPIO_SetBits(GPIOD,GPIO_Pin_15) ;
  GPIO_ResetBits(GPIOD,GPIO_Pin_12) ;
  GPIO_ResetBits(GPIOD,GPIO_Pin_13) ;
  Delay1(8000000);
  } 
    EXTI_ClearITPendingBit(EXTI_Line0) ;  //clear interrupt flag//
}

STM32F4 ADC_Potentiometer_LED

This program was created to test the voltage from a potentiometer on LED diodes Using ADC .
if:      v < 1      => PD12_ON
         1 < v < 2  => PD12_PD12_ON
         2 < v < 3  => PD12_PD13_PD14_ON
         3 < v < 5  => PD12_PD13_PD14_PD15_ON .



/**
 *    STM32F4 Discovery
 *    @author     OUESALTI SABRI
 *    @email        sabrioueslati1@gmail.com
 *    @website    http://electronicsabriart.blogspot.com/
 *    @ide        IAR Workbench
 */

#include "stm32f4xx.h"
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_tim.h"
void delais (int t){
  int i ;
  for (i=0;i<t*10000;i++) {}
}
void InitializeLEDs()
{
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

    GPIO_InitTypeDef gpioStructure;
    gpioStructure.GPIO_Pin = GPIO_Pin_12|GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15;
    gpioStructure.GPIO_Mode = GPIO_Mode_OUT;
    gpioStructure.GPIO_Speed = GPIO_Speed_50MHz;
    gpioStructure.GPIO_OType=GPIO_OType_PP ;
    gpioStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
    GPIO_Init(GPIOD, &gpioStructure);
}

void adc_config()
{  
  ADC_DeInit();
RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
ADC_InitTypeDef ADC_Initstructure ;
ADC_Initstructure.ADC_Resolution=ADC_Resolution_8b ;
ADC_Initstructure.ADC_ScanConvMode=DISABLE ;
ADC_Initstructure.ADC_ContinuousConvMode=DISABLE;
ADC_Initstructure.ADC_ExternalTrigConvEdge=ADC_ExternalTrigConvEdge_None;
ADC_Initstructure.ADC_ExternalTrigConv=ADC_ExternalTrigConv_T1_CC1 ;
ADC_Initstructure.ADC_DataAlign=ADC_DataAlign_Right;
ADC_Initstructure.ADC_NbrOfConversion= 1 ;

ADC_Cmd(ADC1,ENABLE);
ADC_Init(ADC1,&ADC_Initstructure);
ADC_RegularChannelConfig(ADC1,ADC_Channel_0,1,ADC_SampleTime_56Cycles);
}

int adc_convert () {
  ADC_SoftwareStartConv(ADC1);
  while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));//Processing the conversion
  return ADC_GetConversionValue(ADC1); //Return the converted data
}
void adc_pin()
{
    RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef gpioStructure;
    gpioStructure.GPIO_Pin = GPIO_Pin_0;
    gpioStructure.GPIO_Mode = GPIO_Mode_AN;
    gpioStructure.GPIO_Speed = GPIO_Speed_50MHz;
    gpioStructure. GPIO_PuPd=GPIO_PuPd_NOPULL ;
    GPIO_Init(GPIOA, &gpioStructure);
}

int main()
{
 double value,result =0 ;
    InitializeLEDs();  
    adc_pin() ;
    adc_config() ;
    while(1){
     result =(double) adc_convert() ;
     value=(result*3)/241 ;
     
     if(value<1 ) 
{
GPIO_SetBits(GPIOD,GPIO_Pin_12);
GPIO_ResetBits(GPIOD,GPIO_Pin_13);
GPIO_ResetBits(GPIOD,GPIO_Pin_14);
GPIO_ResetBits(GPIOD,GPIO_Pin_15);
}
else if(value>=1 && value<2) 
{
GPIO_SetBits(GPIOD,GPIO_Pin_12);
GPIO_SetBits(GPIOD,GPIO_Pin_13);
GPIO_ResetBits(GPIOD,GPIO_Pin_14);
GPIO_ResetBits(GPIOD,GPIO_Pin_15);
}
else if(value>2&& value<3) 
{
GPIO_SetBits(GPIOD,GPIO_Pin_12);
GPIO_SetBits(GPIOD,GPIO_Pin_13);
GPIO_SetBits(GPIOD,GPIO_Pin_14);
GPIO_ResetBits(GPIOD,GPIO_Pin_15);
}
else if(value>3&& value<5) 
{
GPIO_SetBits(GPIOD,GPIO_Pin_12);
GPIO_SetBits(GPIOD,GPIO_Pin_13);
GPIO_SetBits(GPIOD,GPIO_Pin_14);
GPIO_SetBits(GPIOD,GPIO_Pin_15);
}

    }

}

STM32 ADC Configuration

#include "stm32f4xx_gpio.h"
#include "stm32f4xx_rcc.h"
#include "led.h"
#include "stm32f4_discovery.h"
#include "stm32f4xx_tim.h"
#include "stm32f4xx_dac.h"


void adc_configure(){

ADC_InitTypeDef ADC_init_structure; //Structure for adc confguration
 GPIO_InitTypeDef GPIO_initStructre; //Structure for analog input pin
 //Clock configuration
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1,ENABLE);//The ADC1 is connected the APB2 peripheral bus thus we will use its clock source
 RCC_AHB1PeriphClockCmd(RCC_AHB1ENR_GPIOCEN,ENABLE);//Clock for the ADC port!! Do not forget about this one ;)
 //Analog pin configuration
GPIO_StructInit(&GPIO_initStructre);
 GPIO_initStructre.GPIO_Pin = GPIO_Pin_0;//The channel 10 is connected to PC0
 GPIO_initStructre.GPIO_Mode = GPIO_Mode_AN; //The PC0 pin is configured in analog mode
 GPIO_initStructre.GPIO_PuPd = GPIO_PuPd_NOPULL; //We don't need any pull up or pull down
 GPIO_Init(GPIOE,&GPIO_initStructre);//Affecting the port with the initialization structure configuration
 //ADC structure configuration
 ADC_DeInit();
 ADC_init_structure.ADC_DataAlign = ADC_DataAlign_Right;//data converted will be shifted to right
 ADC_init_structure.ADC_Resolution = ADC_Resolution_12b;//Input voltage is converted into a 12bit number giving a maximum value of 4096
 ADC_init_structure.ADC_ContinuousConvMode = ENABLE; //the conversion is continuous, the input data is converted more than once
 ADC_init_structure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_T1_CC1;// conversion is synchronous with TIM1 and CC1 (actually I'm not sure about this one :/)
 ADC_init_structure.ADC_ExternalTrigConvEdge = ADC_ExternalTrigConvEdge_None;//no trigger for conversion
 ADC_init_structure.ADC_NbrOfConversion = 1;//I think this one is clear :p
 ADC_init_structure.ADC_ScanConvMode = DISABLE;//The scan is configured in one channel
 ADC_Init(ADC1,&ADC_init_structure);//Initialize ADC with the previous configuration
 //Enable ADC conversion
 ADC_Cmd(ADC1,ENABLE);
 //Select the channel to be read from
 ADC_RegularChannelConfig(ADC1,ADC_Channel_10,1,ADC_SampleTime_144Cycles);
}

int adc_convert(){
 ADC_SoftwareStartConv(ADC1);//Start the conversion
 while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC));//Processing the conversion
 return ADC_GetConversionValue(ADC1); //Return the converted data
}



int main(void){
                adc_configure();//Start configuration
                //dac_configure();


     while(1)
                {//loop while the board is working
                        ConvertedValue = adc_convert();//Read the ADC converted value
                        //DAC_Ch1_WaveConfig();
                }

PWM example for STM32F4 Discovery

/*PWM example for STM32F4 Discovery@author     OUESLATI SABRI@email        sabrioueslati1@gmail.com@ide        Keil uVision 5 -- IAR Embedded workbech   i will set the PWM using the timer 4 that is located on PD12   and we will see its signal on the diode PD12*/

#include "stm32f4xx.h"

#include "stm32f4xx_rcc.h"

#include "stm32f4xx_gpio.h"

#include "stm32f4xx_tim.h"

void InitializeTimer(void){ 

 RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);  

  TIM_TimeBaseInitTypeDef timerInitStructure;  

  timerInitStructure.TIM_Prescaler = 40000;  

  timerInitStructure.TIM_CounterMode = TIM_CounterMode_Down; 

   timerInitStructure.TIM_Period = 1050;    

timerInitStructure.TIM_ClockDivision = TIM_CKD_DIV1;  

  timerInitStructure.TIM_RepetitionCounter = 0; 

   TIM_TimeBaseInit(TIM4, &timerInitStructure);   

 TIM_Cmd(TIM4, ENABLE);

}

void InitializePWMChannel()

{ 

  TIM_OCInitTypeDef outputChannelInit = {0,};

    outputChannelInit.TIM_OCMode = TIM_OCMode_PWM1;

    outputChannelInit.TIM_Pulse = 524; 

   outputChannelInit.TIM_OutputState = TIM_OutputState_Enable; 

   outputChannelInit.TIM_OCPolarity = TIM_OCPolarity_High;

    TIM_OC1Init(TIM4, &outputChannelInit);   

 TIM_OC1PreloadConfig(TIM4, TIM_OCPreload_Enable);

    GPIO_PinAFConfig(GPIOD, GPIO_PinSource12, GPIO_AF_TIM4);

}

void InitializeLEDs() {   

 RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);

    GPIO_InitTypeDef gpioStructure;  

  gpioStructure.GPIO_Pin = GPIO_Pin_12;  

  gpioStructure.GPIO_Mode = GPIO_Mode_AF; 

   gpioStructure.GPIO_Speed = GPIO_Speed_50MHz; 

   GPIO_Init(GPIOD, &gpioStructure);

}

int main()  {    

InitializeLEDs(); 

   InitializeTimer();   

 InitializePWMChannel();  

  for (;;)    {    }

}

Discovery kit for STM32F407/417 lines

Key Features

• STM32F407VGT6 microcontroller featuring 32-bit ARM Cortex-M4F core, 1 MB Flash, 192 KB RAM in an LQFP100 package
• On-board ST-LINK/V2 with selection mode switch to use the kit as a standalone ST-LINK/V2 (with SWD connector for programming and debugging)
• Board power supply: through USB bus or from an external 5 V supply voltage
• External application power supply: 3 V and 5 V
• LIS302DL or LIS3DSH ST MEMS 3-axis accelerometer
• MP45DT02, ST MEMS audio sensor, omni-directional digital microphone
• CS43L22, audio DAC with integrated class D speaker driver
• Eight LEDs:
• LD1 (red/green) for USB communication
• LD2 (red) for 3.3 V power on
• Four user LEDs, LD3 (orange), LD4 (green), LD5 (red) and LD6 (blue)
• 2 USB OTG LEDs LD7 (green) VBus and LD8 (red) over-current
• Two push buttons (user and reset)
• USB OTG FS with micro-AB connector
• Extension header for all LQFP100 I/Os for quick connection to prototyping board and easy probing

GPIO on the STM32

General Purpose Input Output (GPIO)
The STM32 is well served with general purpose
IO pins, having typically 80 bidirectional IO pins.
The IO pins are arranged as five ports each
having 16 IO lines.

Configuration Registers

The STM32 has four configuration registers for each of the ports.

Port mode register – GPIOx_MODER

Output type register – GPIOx_OTYPER

Speed register – GPIOx_OSPEEDR

Pull-up/Pull-down register – GPIOx_PUPDR

Each of these registers is 32-bits wide although not all of the bits are used in all of the registers.

• GPIO_Mode: Mode of pins operation
  • GPIO_Mode_IN: Set pin to input
  • GPIO_Mode_OUT: Set pin to be an output
  • GPIO_Mode_AF: Set pin to alternating function (to use with peripheral ex. SPI, USART, etc)
  • GPIO_Mode_AN: Set pin to be an analog (ADC or DAC)
  • 
    
• GPIO_OType: Mode for pin’s output type
  • GPIO_OType_PP: Output type is push-pull
  • GPIO_OType_OD: Output type is open drain
  • 
    
• GPIO_PuPd: Select pull resistors or disable it
  • GPIO_PuPd_UP: Enable pull up resistor
  • GPIO_PuPd_DOWN: Enable pull down resistor
  • GPIO_PuPd_NOPULL: Disable pull resistor
  • 
    
• GPIO_Speed: Select GPIO speed
  • GPIO_Speed_100MHz
  • GPIO_Speed_50MHz
  • GPIO_Speed_25MHz
  • GPIO_Speed_2MHz

 EXEMPLE :