DK7IH HF Radio Engineering

Abstract

This uni of our online tutorial will cover the implementation, configuration and usage of I2C communication with the STM32F4 MCUs. Later we will show practical examples, that can be used for driving an SH1106 OLED display for example or a 24C65 external EEPROM.

I2C basics

I2C (spoken “I square C” for inter-integrated circuit) has been developed by Philips Company in the beginning of the 1980s. It is a two-wire serial bus system with one master and one or multiple slaves connected to a common bus. With ATMEL this is called TWI (“two wire interface” due to copyright reasons).

SCL (Serial Clock) is a permanent clock signal and SDA (Serial DAta) is the data line. Each slave is identified by a unique 7-bit address. Thius often is coded as

uint8_t device_addr = 0x78; //I2C_DEVICE_ADDRESS; here for OLED SH1106

The remaining bit (LSBit) indicates to the slave either the it should receive data from or transmit data to the master.

In practical circuits it is important that the two lines (SCL and SDA) must be pulled up with resistors (2.7 to 4.7 kOhms) to VDD to make sure that the ports of the ICs used for master and slave can pull down the lines when data or clock is transmitted. This system generates the mandatory voltage swing between 0V and VDD on the 2 lines.

I2C on STM32F4

I2C uses ports by applying “alternate function” mode (AF) to the respective pins. In this demonstration we will use ports B6 as SCL and B9 as SDA.

First we have to enable the related clock for I2C communication:

As we want to activate I2C interface 1 (I2C1) we have to set high the corresponding clock by setting bit 21 as “1”:

RCC->APB1ENR |= (1 << 21);

The following sequence does the port definition as alternate function with open drain output (we are about to use pull up resistors, please remember!)

//Setup I2C PB6 and PB9 pins
RCC->AHB1ENR |= (1 << 1);
GPIOB->MODER &= ~(3 << (6 << 1)); //PB6 as SCK
GPIOB->MODER |= (2 << (6 << 1)); //Alternate function
GPIOB->OTYPER |= (1 << 6); //open-drain
GPIOB->MODER &= ~(3 << (9 << 1)); //PB9 as SDA
GPIOB->MODER |= (2 << (9 << 1)); //Alternate function
GPIOB->OTYPER |= (1 << 9); //open-drain

Based on the table above and having prepared PB6 and PB9 for AF use we have to program AF4 (0b0100) for PB6 in AFRL (aka AFR[0] in CMSIS) and PB9 in AFRH (aka AFR[1] in CMSIS):

//Choose AF4 for I2C1 in Alternate Function registers
GPIOB->AFR[0] |= (4 << (6 << 2)); // for PB6 SCK
GPIOB->AFR[1] |= (4 << ((9-8) << 2)); // for PB9 SDA

The next steps perform a software reset of the register and subsequently reset this I2C configuration register:

//Reset and clear register
I2C1->CR1 = I2C_CR1_SWRST;
I2C1->CR1 = 0;

The last steps are defining the clock frequency for the I2C bus based on APB hub frequency and enabling I2C interface:

//Set I2C clock
I2C1->CR2 |= (10 << 0); //10Mhz peripheral clock
I2C1->CCR |= (50 << 0);
I2C1->TRISE |= (11 << 0); //Set TRISE to 11 eq. 100khz
I2C1->CR1 |= I2C_CR1_PE; //Enable i2c
//I2C init procedure accomplished. 

As you can see from CR2 register description that peripheral is defined in I2C->CR2 register (bits 5:0) and bits 11:0 in CCR register. It is strongly recommended to take a view in the reference manual chapters 18.6.2 (CR2 register) and 18.6.8 (CCR register). The same is valid for TRISE definition:

Sending and receiving data via I2C

Sending 1 byte of data

Before we define the a function for sending 1 byte of data we may look like first to 2 functions to  be defined to start and stop an I2C data transfer:

void i2c_start(void) 
{
    I2C1->CR1 |= (1 << 8);
    while(!(I2C1->SR1 & (1 << 0)));
}

void i2c_stop(void) 
{
    I2C1->CR1 |= (1 << 9);
    while(!(I2C1->SR2 & I2C_SR2_BUSY));
}

Next we program the transmit function:

void i2c_write_1byte(uint8_t regaddr, uint8_t data) 
{
    //Start signal
    i2c_start();

    //Send chipaddr to be targeted
    I2C1->DR = DeviceAddr;
    while (!(I2C1->SR1 & I2C_SR1_ADDR)); //Wait until transfer done
    //Perform one read to clear flags etc.
    (void)I2C1->SR2; //Clear address register

    //Send operation type/register 
    I2C1->DR = regaddr;
    while (!(I2C1->SR1 & I2C_SR1_BTF)); //Wait until transfer done

    //Send data
    I2C1->DR = data;
    while (!(I2C1->SR1 & I2C_SR1_BTF)); //Wait until transfer done

    //Send stop signal
    i2c_stop();
}

When we wish to  write more than one byte we have to hand over a pointer to the data we want to transmit as well as the number ob bytes to be transmitted:

//Multiple number of bytes (2+)
void i2c_write_nbytes(uint8_t *data, uint8_t n) 
{
    int t1 = 0;

    //Send start signal
    i2c_start();

    //Send device address
    I2C1->DR = device_addr; 
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    //Perform one dummy read to clear flags
    (void)I2C1->SR2;

    for(t1 = 0; t1 < n; t1++)
    {
        //Send data
        I2C1->DR = data[t1];
        while (!(I2C1->SR1 & I2C_SR1_BTF));
    } 

    //Send stop signal
    i2c_stop();
}

And if you wish to receive data from the I2C system, here 2 examples how to do this. The 1st one calls a one-byte address and returns the 8 bit value for register, the 2nd one can address a word register (16 bits) an return the containing byte for example in EEPROMs like the 24C65 IC.

//Address a byte register, return one byte
uint8_t i2c_read1(uint8_t regaddr) 
{
    uint8_t reg;

    //Start communication
    i2c_start();

    //Send device address
    I2C1->DR = DeviceAddr;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    //Dummy read to clear flags
    (void)I2C1->SR2; //Clear addr register

    //Send operation type/register 
    I2C1->DR = regaddr;
    while (!(I2C1->SR1 & I2C_SR1_BTF));

    //Restart by sending stop & start sig
    i2c_stop();
    i2c_start();

    //Do it again!
    I2C1->DR = DeviceAddr | 0x01; // read
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    (void)I2C1->SR2; //Dummy read

    //Wait until data arrived in receive buffer
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    //Read value
    reg = (uint8_t)I2C1->DR;

    //Send stop signal
    i2c_stop();

    return reg;
}

//Address a word register, return one byte
uint8_t i2c_read2(uint16_t regaddr) 
{
    int8_t reg;
    int16_t r_msb, r_lsb;

    r_msb = (regaddr & 0xFF00) >> 8;
    r_lsb = regaddr & 0x00FF;

    //Start communication
    i2c_start();

    //Send device address
    I2C1->DR = device_addr;
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    //Dummy read to clear flags
    (void)I2C1->SR2; //Clear addr register

    //Send operation type/register MSB
    I2C1->DR = r_msb;
    while (!(I2C1->SR1 & I2C_SR1_BTF));

    //Send operation type/register LSB
    I2C1->DR = r_lsb;
    while (!(I2C1->SR1 & I2C_SR1_BTF));

    //Restart by sending stop & start sig
    i2c_stop();
    i2c_start();

    //Repeat
    I2C1->DR = device_addr | 0x01; // read
    while (!(I2C1->SR1 & I2C_SR1_ADDR));
    (void)I2C1->SR2;

    //Wait until data arrived in receive buffer
    while (!(I2C1->SR1 & I2C_SR1_RXNE));
    //Read value
    reg = I2C1->DR;

    //Send stop signal
    i2c_stop();

    return reg;
}

Full code example can be downloaded here.

What can be seen as a useful homework: Reprogram the functions in a way that you can write one byte to a word register for EEPROMs like 24C65.

Thanks and hope to see u again!

vy 73 de Peter (DK7IH)

by Peter Baier (DK7IH)

Abstract

In this article we will discuss pulse width modulation (PWM), how the respective signals are produced and how we can use them to control motor, light bulbs, LEDs etc.

PWM in short

When current consuming devices like motors, light bulbs, LEDs etc. have to be controlled concerning their intensity you can either control the voltage driving the device (using Ohms law) or you can control the energy transmitted per time unit that powers the device. PWM uses the latter possibility.

PWM takes advantage of square waves, continously “flipping” between two extreme values: Max. power and zero power. The longer the time power is transferred (compared to the time slice where no power is transferred, the greater the total energy coming to the connected device will be:

You can see three different waveforms with different so called duty cycles. No. 1 features relative low “on” time and a very much larger time span “off”. Thus the total amount of energy transferred to the connected device is fairly low. No. 2 has about 50% on- vs. off-time each and no. 3 has a large amount of “on” time and relative low time “off”. In the latter case energy brought to the load is higher than in the other two examples.

One advantage of this method is that the driving circuit dissipates very much lower amounts of thermal energy because its resistance is nearly equal to zero when switched and very high when not conducting. Thus, according to Ohms law and power calculation (P = V x I in DC circuits), the amount of thermal energy produced by the semiconductor is minimized.

Usually for practical applications you can not connect the load directly to the microcontroller because it an output port is not capable of driving more than some milliamps. Deduced from this fact one or more driver stages have to be involved. We will talk about this issue later.

PWM generation in the STM32F4

PWM in an MCU is generated by using a timer. This is the ideal tool because PWM has got a lot of things in common with timing as you can see from the graph above.

To achieve our goal we first have to perform a setup sequence for a timer if we intend using it for PWM. In the following example we will use timer 3 (TIM3) in the STM32 MCU device to drive output port PA6 with an adjustable waveform between 0 and 100% duty cycle.

//////////////////////////////////////////
//Setup TIMER3 for PWM control
//////////////////////////////////////////
RCC->AHB1ENR |= (1 << 0); //Enable GPIOA clock
GPIOA->MODER |= (0x02 << 12); //Set PA6 to AF mode
GPIOA->AFR[0] |= (0b0010 << 24); //Choose Timer3 as AF2 for Pin PA6 LED
RCC->APB1ENR |= (1 << 1); //Enable TIM3 clock (Bit1)

Enabling the respective GPIO port (here “A”), setting PA6 to “alternate function” (AF) mode, setting PA6 as AF mapped to TIM3 are the first things to be done. Here the procedure is the same as described before. Check out the “alternate function” table in datasheet starting from p. 62, check out the device you want to have the application for (TIM3 in this case the 3rd column in that table) and check out the port that is going to be used:

As we intend to use PA6 we have to select AFRL6 in “alternate function” register AFRL which is named in CMSIS as AFR[0]. Don’t get confused, register names are sometimes not matching data sheet or reference manual by 100%!

(Source: STM32F4 reference manual p. 285)

The last line of our code example above switches TIM3 clock to “on” so we can use it later.

The next 4 lines refer to the timer settings which have to be defined:

TIM3->PSC = 499; //fCK_PSC / (PSC[15:0] + 1) -> 50 Mhz / (499 + 1) = 100 khz timer clock speed
TIM3->ARR = MAXPERIOD; //Set period max. value
TIM3->CCR1 = duty_cycle;; //Set duty cycle
TIM3->CCMR1 |= (0x06 << 4); //Set OC1 mode as PWM (0b110 (0x06) in Bits 6:4)

First we set the prescaler that is deduced from system clock speed. In the example SYSCLK is set to 100MHz. To learn how to set SYSCLK please refer to unit 3. The prescaler determines the clock rate the counter counts up (or down if you use a downcounter). The respective formula is given in the comment line.

The next register is the ARR (auto reload register) register that sets the “ceiling” the counter will count to before it will be reset. We use 255 as max. value.

In CCR1 register a value is preloaded that sets the initial setting of the timer. That is the value the timer starts to count with. Here we use it to define the current duty cycle.

With CCMR1 we set the timer “output compare” mode:

By writing 0b110 (dec. 6) we define “110”: “PWM mode 1” for this counter.

The next block of instructions defines compare mode and interrupt status:

TIM3->CCMR1 |= (1 << 3); //Enable OC1 preload (Bit3)
TIM3->CCER |= (1 << 0); //Enable capture/compare CH1 output
(TIM3->DIER |= (1 << 0); //Enable update interrupt)

First instruction OC1PE: sets “Output compare 1 preload enable” in CCMR1 enabling us to use the preload register.

Second instruction hands the signal out on the corresponding output pin.

Last instruction (in parenthesis) enables triggering the interrupt when TIM6 or 7 are used. Here, with TIM3, this is not necessary.

By the end of the setup sequence we have to activate interrupt usage and activate TIM3.

NVIC_SetPriority(TIM3_IRQn, 2); // Priority level 2
NVIC_EnableIRQ(TIM3_IRQn); //Enable TIM3 IRQ via NVIC
TIM3->CR1 |= (1 << 0); //Switch on TIM3

As always the handler function has to be defined and declared correctly. If you compile using “C++” option you must declare/define the function as extern”C” to get the correct idnetifier of the handler function. The only use of this function is to clear interrupt status after timer overflow has occurred and interrupt has been fired.

//////////////////////////////////
// TIM3 INT Handler (PWM)       //
//////////////////////////////////
extern "C" void TIM3_IRQHandler(void)
{
    //Clear interrupt status
    if((TIM3->DIER & 0x01) && (TIM3->SR & 0x01))
    {
        TIM3->SR &= ~(1U << 0);
    }
}

Setting the duty cycle

Setting the desired duty cycle depends on the driver stage you are about to use, i. e. inverting vs. non-inverting. You can either try:

TIM3->CCR1 = duty_cycle; //Set duty cycle

or

TIM3->CCR1 = 255 - duty_cycle; //Set duty cycle

A word about driver stages

As we pointed out before, you can not connect most loads directly to the output pins. A driver stage is mandatory in this case. These stages can be realized either by using bipolar or field effect transistors. Or you can use integrated circuits. Some examples can be found just by using a search engine.

If you intend using a MOSFET driver it is important to keep in mind that with most power MOSFETs gate voltage must be very much higher than the 3.3 Volts you can expect from the MCU’s output port to drive the semiconductor adequately. In these cases you can use a “low voltage” MOSFET specially intended for these purposes or you can switch in an intermediate driver stage equipped with a bipolar transistor. This is due to the fact that bipolar transistors are current driven wheres MOSFETs are voltage driven. The bipolar semiconductor will switch with a base current around some microamperes and then switch the voltage of the MOSFET gate provided the voltage in your application is high enough.

So, that’s all for today. See you later and “thanks for watching”!

73 de Peter (DK7IH)

by Peter Baier (DK7IH)

Abstract

Today’s lesson will cover a topic that the software developer will encounter sooner or later: The need to decode the signals from a rotary encoder. We will discuss that and deliver a simple and easy-to-use solution for this problem.

Theory

A rotary encoder is a set of two mechanical or optical switches driven by a rotating axle, a “shaft”. Both switches are connected to the same GND potential, thus these encoders have two outputs (usually called “A” and “”B”) and a share common ground (GND). Sometimes they also are equipped with an additional push button (S):

Function in brief

When the encoder is rotated, the two switches A and B change their status from “open” to “closed” with a certain phase delay bet ween outputs A and B:

You can see from the picture that clockwise rotation (CW) is present when signal “A” is high and signal “B” presents a rising edge while signal “A” preserves its status (1). In contrast, when the shaft is turned counterclockwise (CCW), signal “A” is high again but “B” shows a falling edge (2). By decoding these two signals as a function of time you can clearly distinguish between CW and CCW rotation.

Reading the rotary encoder in software

Polling the two output lines of the encoder and subsequent decoding is one method to find out about rotor’s status but that wastes a large amount of processor time. The best way to get the rotation direction of this type of encoder is to use interrupts. Signal “A” triggers an interrupt and simultaneously signal “B” is measured.

For example you can trigger an interrupt when “A” represents a falling edge, meaning that it has been “high” right before, and signal “B” will not have changed its status yet. So you can clearly discern the direction of the rotating shaft.

Reading a rotary encoder with STM32F4

Due to the fact that these encoders are widely used in modern electronics, the STM32F4 has integrated functions to read out such devices. But we will use a different method, the well known one from AVRs. That means using something that is called “pin change interrupt”. This type of triggering interrupts also is available in the STM32 MCUs when you write a piece of code for it.

Step 1: Define the input ports and the interrupt

In this example we want to read out a rotary encoder that is connected to pin PB0 and PB1 of an STM32F411 on a “Black Pill”-board. Thus we have to define ports first:

//Set PB0, PB1 as input pins
RCC->AHB1ENR |= (1 << 1); //GPIOB power up
GPIOB->MODER &= ~((3 << (0 << 1))|(3 << (1 << 1))); //PB0 und PB1 Input
GPIOB->PUPDR |= (1 << (0 << 1))|(1 << (1 << 1)); //Pullup PB0 und PB1

First we power up port GPIOB, second we set PB0 and PB1 as inputs by writing 0b11 (dec. 3) into the respective bits of the MODER register. Next step: We set pull-up resistors because the input pins must have some electrical potential to be decoded when pulled to ground or left open.

Interrupt programming

Now we enable the System Configuration Controller in APB2ENR register (Bit 14), which, among other functions, controls the interrupt mapping from GPIO pins to the desired interrupt sources.

 RCC->APB2ENR |= (1 << 14); //Enable SYSCFG clock (APB2ENR: bit 14)

The next 3 steps are related directly to the interrupt function we are about to use. The first line involves the EXTI0 (external interrupt 0) mapped  to PB0. This is an essential step we have to explain more detailed:

In the STM32F4 MCU external interrupts are organized in so called “lines”. There are 16 of them. The special thing, if you want to say so, for former AVR developers is that all pins having the same number of the various MCU ports share the same “line”. This means, for example, that PA0, PB0, PC0 etc. share the same multiplexed interrupt bus and therefore only one external pin of this set can be used to trigger an interrupt in the respective line. There is a minor exception from this rule (concerning PA5 iirc) but generally this rule sticks for the whole system of external interrupts.

To map a certain pin to an interrupt the EXTICR registers have been designed. In the reference manual you can find them defined beginning with page 291. There are 4 of them:

• EXTICR1 (called EXTICR[0] in CMSIS header file)
• EXTICR2 (called EXTICR[1] in CMSIS header file)
• EXTICR3 (called EXTICR[2] in CMSIS header file)
• EXTICR4 (called EXTICR[3] in CMSIS header file)

As you can see, once again the identifiers in STM32F4 software package are different from datasheet! So care must be taken!

As an example (and for our code here) we take a closer look on EXTICR1 (EXTICR[0]).

This definitely requires explanation: As we desire to use a pin with number “0” in its name, we have to use the group of pins (“line”) with “0” in the description. This line is represented in the EXTI0 bits [3:0] which also are bits 3:0 of this register. As it is PB0 we want to trigger the interrupt, we have to take the second line from the text block: 0001: PB[x]. This is because our “x” here is 0, so we write 0b0001 into the first 4 bits of this register:

SYSCFG->EXTICR[0] |= 0x0001; //Write 0001 to map PB0 to EXTI0

The remaining instructions define that we want to set up something in AVRs we would call “pin change interrupt”:

EXTI->RTSR |= 0x00001; //Enable rising edge trigger on EXTI0

And last we have to exclude EXTI0 from the interrupts that are not fired on an event:

EXTI->IMR |= 0x01; //Mask EXTI0 in IMR register

The two remaining steps are defining interrupt priority and activating the interrupt:

NVIC_SetPriority(EXTI0_IRQn, 1); //Set Priority

Please note: Priority in interrupts is defined in a way, that the low numbers stand for high priority!

NVIC_EnableIRQ(EXTI0_IRQn); //Enable EXT0 IRQ from NVIC

So, again we are ready to go!

Last we have to set up the function that handles the interrupt once it is fired and deals with the pin data from the encoder: Declaration first

extern "C" void EXTI0_IRQHandler(void);
int16_t rotate = 0;
int16_t laststate = 0; //Last state of rotary encoder

and definition:

extern "C" void EXTI0_IRQHandler(void)
{
    uint16_t state;

    //Check first if the interrupt is triggered by EXTI0
    if(EXTI->PR & (1 << 0))
    {
        state = GPIOC->IDR & 0x03; //Read pins
        if(state & 1)
        {
            if(state & 2)
            {
                 //Turn CW
            }
            else
            {
                //Turn CCW
            }
        } 

        //Clear pending bit
        EXTI->PR = (1 << 14);
}

Here again we have to declare the function as ‘extern “C”‘ because when compiled under C++ settings the handler name will be altered by the compiler therefore the handler will not be recognized and your program will crash as soon as the interrupt is triggered.

Thanks for being here! Hope you enjoyed this lesson!

vy 73 de Peter (DK7IH)

by Peter Baier (DK7IH)

Abstract

This unit will cover the basic usage of the Analog-Digital-Converter (ADC) in the STM32F4 MCU. We will develop a simple procedure to read multiple ADC values from various input pins and have these data ready for further processing.

ADC in STM32F4 in brief

The Analog-Digital-Converter in the STM32F4 MCU uses the basic principles of function like most ADCs in other digital circuits: The process of successive approximation. An internal generator (a Digital-Analog-Converter) produces a variable DC signal with different voltage and this is compared to the input signal in a way that in the end the voltages of the two sources (internal DC and external signal voltage) match, so they are equal. By reading the respective DAC data we get the digital equivalent of the externally applied voltage. This process involves a certain time (thus defining a sampling rate) and varies in bit width of the detecting process.

In contrast to AVRs, where the ADC usually has 10bits width, the ADC in the STM32F4 unit can be switched to a maximum of 12 bits processing width. There are up to 3 different ADCs in one MCU depending on the exact model you have in use. They are numbered as “ADC1”, “ADC2” and “ADC3”, if present. They can be connected to certain input pins but not all combinations are possible.

Setting up the ADC

As always to start with a functional unit, this unit inside the MCU has to be configured before we can use it. First we have to have the reference manual at hand. The “ADC”-section starts with page 388. The registers can be found beginning from page 415. Lets directly stick to that part because from the vast set of possibilities to make use of the ADC we will select a really simple approach to avoid confusion.

Some general annotations before we start:

You as a developer can assign certain pins to certain ADC. But not all combinations are possible as mentioned before. They are limited as shown in the following table:

This table is deduced from an entry in datasheet, the “Pinouts and pin description” section table starting on page 50. You can learn how a given input pin can be assigned to a certain ADC channel.In the “additional functions” sections you can see the pins assignable to certain ADC channels.

For ADC1 we, to start in in simple way into this more or less complex field, want to use pin PB0 as an input for analog voltage. From the config table above we deduce that PB0 can either be assigned to ADC1 or ADC2 as input channel #8. We will use ADC1. The further steps of configuration are:

//Port config
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOBEN; //Power up PORTB
GPIOB->MODER |= (3 << (0 << 1)); //Set PB0 to analog mode

As you can see PB0 is switched to analog mode which requires writing 0b11 to the respective bits in MODER register.

Next the ADC will have to be set up:

//ADC config sequence
RCC->APB2ENR |= (1 << 8); //Enable ADC1 clock (Bit8) 
ADC1->CR1 &= ~(1 << 8); //SCAN mode disabled (Bit8)
ADC1->CR1 &= ~(3 << 24); //12bit resolution (Bit24,25 0b00)
ADC1->SQR1 |= (1 << 20); //Set number of conversions projected (L[3:0] 0b0001) -> 1 conversion
ADC1->SQR3 &= ~(0x3FFFFFFF); //Clear whole 1st 30bits in register
ADC1->SQR3 |= (0b01 << 3); //1st conversion in regular sequence: SQ1: PB0 as ADC1_IN8
ADC1->CR2 &= ~(1 << 1); //Single conversion
ADC1->CR2 &= ~(1 << 11); //Right alignment of data bits bit12....bit0
ADC1->SMPR2 |= (7 << 0); //Sampling rate 480 cycles. 16MHz bus clock for ADC. 1/16MHz = 62.5ns. 480*62.5ns=30us
ADC1->CR2 |= (1 << 0); //Switch on ADC1

The first 3 lines switch the ADC clock signal to “on” (thus power the ADC, disables scan mode which means that the ADC will not automatically run thru the configured channels and do (unnecessary) conversion for our simple example and we set the resolution to the maximum of 12 bits.

Steps from #4 (“Set number of conversions…“) and beyond have to be explained in a more detailed way:

In the STM32F4 ADC the signals to be used for conversions of analog signals are organized in so called “sequences”. There are “regular” and “injected” sequences (we are about to define a “regular” one) and they can contain up to 16 different inputs served sequentially. So, a “chain” must contain at least 1 and may contain 16 channels max.

How many channels are held in a sequence is defined in the SQR1 register (“sequence register”) , namely in bits 23:20:

Because we only want to read one input by one time, we write decimal “1” into this set of bits:

ADC1->SQR1 |= (1 << 20); 

The next step is to fix what channel will be used (first, if you have more). The sequence to be processed is defined beginning with SQR3, SQR2 and the remaining bits of SQR1 register. As we only have conversion channel projected we directly got to SQR3 register:

Here bits 4:0 (SQ1) define the first (and in our example only) channel to be read.

ADC1->SQR3 |= (0b01 << 3); 

As we want to use channel 8 we shift 0b01 by 3 bits to the left. Another possible (maybe even better) notation would have been “0b01000”. This says that channel 8 will be assigned as first (and int this case only) channel to be processed.

The remaining 4 lines of code define the way of conversion (we perform only a single conversion when called), define adjustment of the data bits (right alignment, so we don’t have to care about actual number of bits appearing after the conversion) we set a sampling rate and, last but not least, we switch on the ADC. Please refer to the reference manual to make clear what these bits are intended for in the respective register!

With this sequence of defintiions the ADC now is “ready to use”.

To read an analog value from PB0 the ADC’s “DR” (data register) has to be read. First we start a conversion by writing the value of “1” into bit 30 of ADC->CR2 register and then get the corresponding digital value from the “DR” register.

uint16_t adcval = 0;

ADC1->CR2 |= (1 << 30); //Start 1st conversion SWSTART
while(!(ADC1->SR & (1 << 1))); //Wait until conversion is complete
adcval = ADC1->DR; //Read value from register

Using multiple input pins

In case you wish to extend this example to, let’s say, two different input pins this can be easily done. You have to redefine the start of the sequence (actually we only have one channel to read, so there is no “sequence”). Let’s say we want to read channel 8 AND channel 9 (PB0 and PB1) of port B.

First: Don’t forget to set PB1 as previously done with PB0 by the begin of the initialization sequence:

GPIOB->MODER |= (3 << (1 << 1)); //Set PB1 to analog mode

Then, before reading a a channel we must reset the respective “begin” of the sequence in SQR3 register. For PB0 we have shown it before, for PB1 it is slightly different:

ADC1->SQR3 = (0b01001); //Set 1st conversion in regular sequence: SQ1: PB1 as ADC1_IN9

After that you can again read the ADC, this time connected to PB9.

Hint: Please note the the usual “|=” operator frequently used for register definition does not apply here! This is because if you try to reset the bits by simply “or-ing” them, their total value will remain unchanged in this case. If you have multiple bits and want to redefine only some of them,  first use the “&= ~” operator to reset the bits you are about to modify.

Example code

On my Github repo you can find two files. One to demonstrate the reading of the internal temperature sensor, the second one to show the usage of PB0 as analog input like discussed before. For this example a 4×20 LCD module has been connected to the MCU to give you a detailed reading of data.

Thanks for today an c u!

73 de Peter (DK7IH)

by Peter Baier (DK7IH)

SPI (serial peripheral interface) is a communication interface between electronic devices like microcontrollers, displays, DDS generators and many other electronic circuits. It is widely used, thus the manufacturers of microcontrollers have implemented predefined SPI functions into their hardware. On the other hand, it is possible (and easy) to write these functions on your own. Sometimes this is the even preferably way because debugging is easier and faster. But today we will focus on using the integrated SPI hardware found in the STM32 MCUs.

SPI: The basics in brief

SPI uses 3 or 4 lines between the so called “host” (often called ‘master’) and the peripheral device (often named “slave”).

(from Wikipedia)

In the datasheet of any SPI device you can find something that is called “timing diagram”. They all look much or less the same, SPI is standardized to a very high degree.

(from datasheet AD9834, an Analog Devices DDS synthesizer)

The first line represents the so called “clock signal”, it switches from low to high, indicating that the current data bit is to be read right in that very moment (line #3). The data stream that goes from master to slave is called MOSI” (“master out, slave in”).

The remaining signal to be explained is called “CS” (for “chip select”, sometimes named differently like “FSYNC” in that case or “NSS” for “negative slave select” in ST’s language). It indicates that the master has got data now for the peripheral device and that it should listen to it. If you have more than one “slave” device in your circuitry you must have a separate CS line for every “slave” in case you do not use cascaded slaves. CS, by the way, is an “active low” signal line.

A fourth line is the “MISO” (master in slave out) line which transfers data from “slave” to “master”, if requested.

Setting up SPI in the STM32 microcontroller

There are up to 3 SPI devices in the STM32F4 MCU and they are controlled, again, using the “alternate function” mapping.

Hint: A warning is given in the reference manual by STM because some SPI pins interfere with other essential functions like the JTAG interface for example. See page 873 of the reference manual for details!

In our following code discussion we will use SPI2 which is not prone for any of these conflicts.

Setting up the peripheral SPI structure

Here you can recognize that the relevant pins are PB15:PB12. Thus we have to start with powering and clocking the respective port, i. e. GPIOB as well as clocking the SPI

//////////////////////////////////////////
// Setup SPI
//////////////////////////////////////////
//PB12:CS; PB13:SCK; PB14:MISO; PB15:MOSI
RCC->AHB1ENR |= (1 << 1); //GPIOB power clock enable
RCC->APB1ENR |= (1 << 14); //Enable SPI2 clock, bit 12 in APB2ENR

Next we set up port B:

//Alternate function ports
GPIOB->MODER &= ~(0b11111111U << (12 << 1)); //Reset bits 15:12
GPIOB->MODER |= (0b01 << (12 << 1)); //PB12 (CS) as output
GPIOB->MODER |= (0b101010U << (13 << 1)); //Set bits 15:13 to 0b101010 for alternate function (AF5)
GPIOB->OSPEEDR |= (0b11111111 << (12 << 1)); //Speed vy hi PB15:PB12

//Set AF5 (0x05) for SPI2 in AF registers (PB13:PB15)
GPIOB->AFR[1] |= (0x05 << (20)); //PB13
GPIOB->AFR[1] |= (0x05 << (24)); //PB14
GPIOB->AFR[1] |= (0x05 << (28)); //PB15

There is some confusion about the CS line in many publications. It is recognized that SPI is little bit faulty in the STM32s. This affects CS (NSS) signal. A workaround is to define this line as “normal” output and switch it by software when transmitting data.

The second block sets the “alternate function registers” according to the table above an the AFR[1] register. If you aren’t quite clear about this technique, please refer to lesson 4 where AF usage is explained in detail.

After having done port configuration the last remaining step is to specify the working conditions  for the SPI interface:

//Set SPI2 properties
SPI2->CR1 |= (1 << 2); //Master mode
SPI2->CR1 |= SPI_CR1_SSM; //Software slave management enabled
SPI2->CR1 |= SPI_CR1_SSI; //Internal slave select The value of this bit is 
//forced onto the NSS pin and the IO value of the NSS pin is ignored.
SPI2->CR1 |= SPI_CR1_SPE; //SPI2 enable

With this you are done with preparing the SPI interface and can start transmitting data:

void spi_write(uint8_t data)
{
    GPIOB->ODR &= ~(1 << 12); //CS low
    SPI2->DR = data; //Write data to SPI interface
    while (!(SPI2->SR & (1 << 1))); //Wait till TX buf is clear
    GPIOB->ODR |= (1 << 12); //CS high
} 

As code examples there are three files to illustrate basic SPI application:

#1: The basic procedure that can be seen above and that has been explained (hopefully) to the details (Link to file)

#2 An example that shows the basic driving functions for a typical SPI LCD (IL9341). This code lacks extensive functions, it just holds an initialization and a clearscreen routine. (Link to file)

#3 A full display driver for the ILI9341 containing all the functions you need to drive this display in text mode (including various character sizes) (Link to file)

Have a good one! 73 de Peter (DK7IH)