Details

Elektronik

Hits: 7521

Mein neuestes Spielzeug sind die kleinen 15/16Bit ADCs ADS1115 von Texas Instruments. Wunderbare Bausteine die man für wenig Geld an jeder Ecke bekommt. Nachfolgend eine Zusammenfassung wie man diese einfach ansteuert, sowie ein kleines Beispielprogram in C für den STM32.

Im Web finden sich viele der folgenden Platinen, aber obacht - manchmal ist nur ein 12 Bit Chip aufgelötet und man wundert sich warum sich die unteren Bits nie ändern.

Der Chip kann per I2C-Bus angesteuert werden und liefert über 4-Kanäle sogar 15/16bit Auflösung. Ein eingebauter programmierbarer Verstärker ermöglicht Messbereiche von:

0: +-6.144V

1:+-4.096V

2:+-2,048V

3: +-1,024V

4: +-0.512V

5: +-0.256V

Der Baustein kann leider keine negativen Spannungen in Bezug auf GND messen, das geht nur im differentiellen Mode wenn man zwischen zwei Eingängen misst. Daher rührt dan auch die echte Auflösung von 15 Bit im single-ended Mode.

Für die Verwendung mit dem STM32F103 Prozessor habe ich nachfolgend eine kleine I2C- C Library entwickelt. Hier werden die wesentlichen Funktionen des ADS1115 abgebildet. Die Threshold und Interruptfunktion habe ich nicht umgesetzt. Falls ich das irgendwann mal brauche füge ich es noch hinzu.

Im nachfolgenden ZIP-File befinden sich die I2C Lib, die ADS1115 Lib und ein kleines Testprogram. Das Testprogramm kann über ein RS232 Terminalprogramm (115200baud) einfach bedient werden. ? oder --h eintippen und man erhält ein Hilfemenü. Das Testprogramm programmiert den PGA (Programmable Gain Amplifier), sowie den Eingangsbereich und gibt die gemessene Spannung in mV aus.

Hier das Beispielprogram zum Download.

Details

Elektronik

Hits: 35456

Oft muss man Taster oder andere Eingaben in einen Microcontroller einlesen um Aktionen auszulösen. Leider sind Taster "nicht ideale" Schalter, da diese prellen und mitunter erst nach einigen 10ms einen stabilen Logikpegel einnehmen. Man muss Signale also entprellen oder debouncen.

Liest man diese Signale in einen Controller ein, kommt es sicher zu einem Prellen des Signals. Will man eigentlich nur einmal einen Taster betätigen, kann es wahrscheinlich sein, dass mehrere Tastendrücke erkannt werden. Dies ist aber nicht erwünscht. Lösen kann man dies auf zwei Arten. In Hardware durch vorschalten eines Tiefpasses oder Schmitttriggers oder einfacher durch die logische Auswertung der Signale in Software. Dies nennt man auch "debouncen". In Software gibts auch verschiedene Verfahren die alle auch Ihre Nachteile haben. Man könnte z.B. einfach immer ein paar mal den Taster einlesen und bis zu 100ms warten, bevor man den Taster endgültig auswertet. Der Nachteil ist, man muss immer warten ob und wie lange der Taster gedrückt wurde. Warten ist für Controller immer nachteilig, weil der in der Zeit zumeist nicht anderes tun kann.
Hier folgt jetzt ein Programm welches ich von Peter Danneger übernommen habe der diese Debounce Routine für den ATMEGA geschrieben hat. Diese funktioniert wunderbar, ist klein und kompakt. Ich habe diese Routine nur auf den STM32 angepasst.
Wer mehr wissen will kann hier die Details nachlesen.

#include <stdio.h>
#include "stm32f10x_rcc.h"
#include "stm32f10x_gpio.h"
#include <stddef.h>
#include "stm32f10x.h"
#include "stm32f10x_conf.h"
#include <string.h>
#include <misc.h>
#include "stm32f10x_tim.h"
#include "stm32f10x_usart.h"

/*
 * Program to test the TIM2, TIM4 timer and interrupt function for STM32F103RB to read debounced keys press
 * tested with OLIMEXINO STM32 (F103RB)  Board
 * **********************
 * Wolfram Koerver - 2013
 * **********************
 * The Port C is used to read in button pressed events. This uses TIM4 for counting with 10ms.
 * The debounce functions - I have modified to work with STM32 IOs - are invented originally by Peter Danneger
 *
 * Hardware STM32 Olimexino Connections:
 * A0/D15/PC0 == Switch to GND = SW1
 * A1/D16/PC1 == Switch to GND = SW2
 * Serial Port connected to USART2
 * D0 = Input -> STM32 UART
 * D1 = Output from <- STM32 UART
 */

void init_LED(void);
void blink_yellow(void);
void init_timer2(void);
void init_timer4(void);

void delay_us(uint32_t time_us);
void delay_ms(uint32_t time_ms);

void TIM2_IRQHandler(void);
void init_sys_tick(void);

void RCC_Init(void);

void InitUart2(void);
void InitUart3(void);
void USART2_SendString(char* data);

void init_keyport(void);

uint8_t get_key_state(uint8_t key_mask);
uint8_t get_key_rpt(uint8_t key_mask);
uint8_t get_key_short(uint8_t key_mask);

#define uchar unsigned char

uint32_t	ti;

volatile 	uchar 		rfid_bits[54];
volatile 	uchar 		rfid_bytes[9];

char bufferRx[256],receiveRx[256];
uint16_t	RxCounter;



uint8_t usart_receive_array[] = {0xAA, 0xAA, 0xAA};

uint8_t		new_rfid=0; 	//flag to tell there is a new rfid token received

uint16_t	start_bit_count=0,seq_bit_no,b,k,rbit;

uchar			rc5_bit;				// bit value
uint8_t			bit_time_cnts;				// counts number of timer cycles during a bit reception
uint16_t		rc5_tmp;					// shift bits in
uchar			rfid_bit;					// actual received logical bit from RFID stream

volatile uint16_t	rc5_data;				// store result
/********************************** Debounce Variables **********************************/

#define KEY_PIN GPIO_ReadInputData(GPIOC)

#define KEY0            0
#define KEY1            1
#define KEY2            2
#define ALL_KEYS        (1<<KEY0 | 1<<KEY1 | 1<<KEY2)

#define REPEAT_MASK     (1<<KEY0 | 1<<KEY1)       // repeat: key1, key2
#define REPEAT_START    50                        // after 500ms
#define REPEAT_NEXT     10                        // every 200ms

volatile uint8_t key_state;                                // debounced and inverted key state:
                                                  // bit = 1: key pressed
volatile uint8_t key_press;                                // key press detect

volatile uint8_t key_rpt;                                  // key long press and repeat

#define sw1	0
#define sw2	1
#define sw3	2
#define sw4	3
/****************************************************************************************/
int main(void)
{

	extern unsigned char			rc5_bit;				// bit value

	char text[10];
	char			out_text[50];

	out_text[49] = '\0';	// make sure string termination

	text[9]	=0x00;
	uint8_t ky;


	SystemInit();					// initialize the core
	RCC_Init();
	InitUart2();
	
	/****************************************/
	/* Watchdog Test - Base frequency 40kHz */
	// These calls initiate the watchdog timer interrupts. If watchdog time expires the CPU is reset
	IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
	IWDG_SetPrescaler(IWDG_Prescaler_256);
	IWDG_SetReload(3000);	// should be about 1/156s * 3000 should be 20s
	IWDG_ReloadCounter();
	IWDG_Enable();
	/****************************************/

	init_LED();						// Init the LED port IO
	init_timer2();					// configure the Timer2 Interrupt
	init_timer4();
	init_keyport();					// configure the key switch input port
	init_extint();					// configure external interrupt

	while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
			USART2_SendString("RFID Test Debounce on STM32\n\r");
	rc5_bit=0;						// init RFID INT

    while(1)
    {
    	blink_yellow();						// let the main program do something
		
		if( get_key_short( 1<<sw1 )){

			sprintf(out_text,"Key sw1 %3d  \r",ky);
			USART2_SendString(out_text);
		}
		if( get_key_short( 1<<sw2 )){
			sprintf(out_text,"Key sw2 %3d  \r",ky);
			USART2_SendString(out_text);
		}
			delay_ms(25);
			IWDG_ReloadCounter();		// Retrigger Watchdog Counter otherwise CPU would be restartet
    }
}

void init_keyport(void){
	GPIO_InitTypeDef GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3; 	// enable the firts 4 bits as key switch inputs
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;						// Pin Floating
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;								//Pin Up
	//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;	//Pin Down
	GPIO_Init(GPIOC, &GPIO_InitStructure);
}


void outuchar(uchar val)
{
	char 	buf[3];
	sprintf(buf,"%02X",val);
	buf[3] = '\0';
	while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
				USART2_SendString(buf);
}
void outbits(uchar val)
{
	char 	buf[2];
	sprintf(buf,"%d",val & 0x1);
	buf[2] = '\0';
	while(USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET);
				USART2_SendString(buf);
}

void RCC_Init(void)
{
	// Route and enable clocks for low and high speed bus
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO | RCC_APB2Periph_GPIOD, ENABLE);
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
}


void TIM2_IRQHandler(void){							// Timer Interrupt handler for TIM2 will be called every 10us
  TIM_ClearITPendingBit(TIM2, TIM_IT_Update);		// Clear interrupt pending bit
  bit_time_cnts++;
}
/**************************************************************************************************************/
///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed. Each pressed key is reported
// only once
//
uint8_t get_key_press( uint8_t key_mask )
{
  key_mask &= key_press;                          // read key(s)
  key_press ^= key_mask;                          // clear key(s)
  return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key has been pressed long enough such that the
// key repeat functionality kicks in. After a small setup delay
// the key is reported being pressed in subsequent calls
// to this function. This simulates the user repeatedly
// pressing and releasing the key.
//
uint8_t get_key_rpt( uint8_t key_mask )
{
  key_mask &= key_rpt;                            // read key(s)
  key_rpt ^= key_mask;                            // clear key(s)
  return key_mask;
}

///////////////////////////////////////////////////////////////////
//
// check if a key is pressed right now
//
uint8_t get_key_state( uint8_t key_mask )

{
  key_mask &= key_state;
  return key_mask;
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_short( uint8_t key_mask )
{
  return get_key_press( ~key_state & key_mask );
}

///////////////////////////////////////////////////////////////////
//
uint8_t get_key_long( uint8_t key_mask )
{
  return get_key_press( get_key_rpt( key_mask ));
}


void USART2_SendString(char* data)
{
	while (*data)
	{
		USART_SendData(USART2, (uint16_t) *data);
		while(USART_GetFlagStatus(USART2, USART_FLAG_TC)==RESET);
		data++;
	}
}

void TIM4_IRQHandler(void){							// Timer Interrupt handler for TIM4 will be called every 10ms
	 static uint8_t ct0, ct1, rpt;					// KEY-PIN will becalled to read in key button pressed events
	  uint8_t i;
  TIM_ClearITPendingBit(TIM4, TIM_IT_Update);		// Clear interrupt pending bit
  i = key_state ^ ~KEY_PIN;                       	// key changed ?
   ct0 = ~( ct0 & i );                             	// reset or count ct0
   ct1 = ct0 ^ (ct1 & i);                          	// reset or count ct1
   i &= ct0 & ct1;                                 	// count until roll over ?
   key_state ^= i;                                 	// then toggle debounced state
   key_press |= key_state & i;                     	// 0->1: key press detect
   if( (key_state & REPEAT_MASK) == 0 )            	// check repeat function
      rpt = REPEAT_START;                          	// start delay
   if( --rpt == 0 ){
     rpt = REPEAT_NEXT;                            	// repeat delay
     key_rpt |= key_state & REPEAT_MASK;
   }
}

void USART2_IRQHandler(void)
{
  uint8_t c;
  if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET)
  {
    /* Read one byte from the receive data register */
	// This routine jsut reads a byte from serial; only for demonstration purposes
    c = USART_ReceiveData(USART2);
   USART_SendData(USART2, c);				//echo byte back
  }
 }

void InitUart2(void)
{
	// Initialize Structs
	GPIO_InitTypeDef GPIO_InitStructure;
	USART_InitTypeDef USART_InitStructure;
	USART_ClockInitTypeDef USART_ClockInitStructure;

	// USART1 RX-Pin initialize PA3
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	// USART1 TX-Pin initialize PA2
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
	GPIO_Init(GPIOA, &GPIO_InitStructure);

	// USART initialize
	USART_ClockStructInit(&USART_ClockInitStructure);
	USART_ClockInit(USART2, &USART_ClockInitStructure);

	USART_InitStructure.USART_BaudRate = 19200;
	USART_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
	USART_InitStructure.USART_Parity = USART_Parity_No;
	USART_InitStructure.USART_StopBits = USART_StopBits_1;
	USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;

	USART_Init(USART2, &USART_InitStructure);
	USART_Cmd(USART2, ENABLE);

	USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

	  NVIC_InitTypeDef NVIC_InitStructure;
	  /* Enable the USART2 Interrupt for reception of bytes */
	  NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
	  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
	  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
	  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	  NVIC_Init(&NVIC_InitStructure);
}

void init_timer2(void)
{
	// SystemCoreClock = 72MHz -> APB1 is maximum 36MHz for TIM2,3,4,5 but will be doubled again to 72MHz when prescaler # 0
	// This example uses TIM2 Timer
	// APB1 clock = SystemCoreClock/2 but s.o.

	TIM_TimeBaseInitTypeDef TIM_TimeBase_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
	TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
	TIM_TimeBase_InitStructure.TIM_Period 			= 9;		// count up to 999 = 1000
	TIM_TimeBase_InitStructure.TIM_Prescaler		= 71;		//72(MHz) -1 Divided by 72
	TIM_TimeBase_InitStructure.TIM_CounterMode 		= TIM_CounterMode_Up;
	// 9,71 = 10us Cycle Time
	// 999,71 = 1ms
	// 1MHz / 500 = 2000 Hz.
	// SystemCoreClock = 72MHz / 72 => 1 MHz Clock with this clock the timer counts up to 999 = 1000 counts =
	// 1/1000 --> 1000 Hz = 1ms cycle time

	TIM_TimeBaseInit(TIM2, &TIM_TimeBase_InitStructure);
	TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
	NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
	NVIC_Init(&NVIC_InitStructure);
	TIM_Cmd(TIM2, ENABLE);
}
void init_timer4(void)
{
	// SystemCoreClock = 72MHz -> APB1 is maximum 36MHz for TIM4 but will be doubled again to 72MHz when prescaler # 0
	// This example uses TIM4 Timer
	// APB1 clock = SystemCoreClock/2 but s.o.
	TIM_TimeBaseInitTypeDef TIM_TimeBase_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;

	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);

	TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;

	TIM_TimeBase_InitStructure.TIM_Period 			= 2499;		// count up to 2500
	TIM_TimeBase_InitStructure.TIM_Prescaler		= 143;		//72(MHz) -1 Divided by 144
	TIM_TimeBase_InitStructure.TIM_CounterMode 		= TIM_CounterMode_Up;
	// 9,71 = 10us Cycle Time
	// 999,71 = 1ms
	//2499/143 = 10ms
	// 1MHz / 500 = 2000 Hz.
	// SystemCoreClock = 72MHz / 72 => 1 MHz Clock with this clock the timer counts up to 999 = 1000 counts =
	// 1/1000 --> 1000 Hz = 1ms cycle time

	TIM_TimeBaseInit(TIM4, &TIM_TimeBase_InitStructure);
	TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
	NVIC_InitStructure.NVIC_IRQChannel = TIM4_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
	NVIC_Init(&NVIC_InitStructure);
	TIM_Cmd(TIM4, ENABLE);
}
void delay_us(uint32_t nus)
{
 uint32_t temp;
 SysTick->LOAD 	= nus * 11;
 SysTick->VAL 	= 0x00;
 SysTick->CTRL 	= 0x01 ;
 do
 {
  temp=SysTick->CTRL;
 }
 while(temp&0x01&&!(temp&(1<<16)));
 SysTick->CTRL = 0x00;
 SysTick->VAL = 0X00;
}


void delay_ms(uint32_t time_ms) //Delay in msec
{
  while (time_ms>0)
  {
	delay_us(1000);
    time_ms--;
  }
}

void init_LED(void)
{
	/* Initialize GPIO Structure, configure clock on peripheral bus
	 * Enable GPIO Pin for yellow LED which
	   Configure direction and clock speed */
	GPIO_InitTypeDef  GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
}
void blink_yellow()
{
	GPIOA->BRR = GPIO_Pin_1;						//reset bit
	GPIOA->BSRR = GPIO_Pin_1;					//set bit
	delay_ms(1);
	GPIOA->BRR = GPIO_Pin_1;						//reset bit
}

void toggle_yellow()
{
	GPIOA->ODR ^= GPIO_Pin_7;						// invert pin
}

Das Beispielprogramm zum Download für den STM32 findet sich hier:

Details

Elektronik

Hits: 11291

STM32 Ein- und Ausgabe von digital Informationen

Hier sind die wesentlichen Informationen zur Ein- und Ausgabe von digitalen Werten beim STM32 Prozessor beschrieben.

Hier am Beispiel des STM32F107VC Prozessors. Die Port-Bits fangen bei Pin_0(!) an. GPIO_Pin_0 ist der Prozessorpin 15.

Bitausgabe

Setzen eines einzelnen Bitregisters direkt: (Pin6) auf Port C:

Bit 6 auf logisch 1 setzen: GPIOC->BSRR = GPIO_Pin_6;

Bit 6 auf logisch 0 setzen: GPIOC->BRR = GPIO_Pin_6;

Bit 6 invertieren: GPIOC->ODR ^= GPIO_Pin_6;

oder alternativ die Orginalfunktionen der STM Lib.

Bit 6 auf logisch 1 setzen: GPIO_SetBits(GPIOC,GPIO_Pin6)

Bit 6 auf logisch 0 setzen: GPIO_ResetBits(GPIOC,GPIO_Pin6)

Bit 6 und Bit 9 auf logisch 0 setzen: GPIO_ResetBits(GPIOC, GPIO_Pin6|GPIO_Pin9)

Die direkten Funktionen sind naturgemäß erheblich schneller. Allerdings müsste sich jemand den erzeugten Assembler Code anschauen ob es wirklich so ist.

Portausgabe

Die IO-Ports des STM32 sind jeweils 16 bit breit. Wenn man also einen ganzen Port beschreiben will muss man auch eine Funktion verwenden die 16 Bit variablen verwendet. Dies ist:

Write complete port : GPIO_Write(GPIOC,val);

wobei val eine 16bit variable uint16_t val

sein muss. Oder wieder einzelne Bits setzen mit folgendem Befehl:

GPIO_Write(GPIOC, GPIO_Pin6 | GPIO_Pin9);

Um den Zustand eines Ausgangsports zurückzulesen (weil man nicht weiß wie er gerade gesezt ist) kann man folgende Funktion verwenden:

uint16_t val;

val = GPIO_ReadOutputData(GPIOC, GPIO_Pin6 | GPIO_Pin9);

Achtung diese Funktion liest nur die (!) Setzregister NICHT den Ausgangszustand.

Biteingabe

Einlesen des kompletten Port C:

port_data = GPIO_ReadInputData(GPIOC);

Achtung: Beim Lesen eines Bits kann es passieren dass anscheinend nichts gelesen wird oder das Bit nicht erkannt wird. Die Ursache liegt in den vielfältigen Programmiermöglichkeiten die der STM32 bietet. Man muss vor der Verwendung definieren welche Art der Input sein soll. Hier die dazu benötigten Flags:

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; // Pin Floating
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //Pin with pull up R
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //Pin with pull down R

Pin Floating ist z.B. sinnvoll wenn man externe Widerstände in anderen Schaltungsteilen hat.

Nachfolgend noch ein einfaches Demoprogramm.

/* Wolfram Koerver
 * STM32 Example for OLIMEX STM32P107 Test Board
 * Toggle green and yellow LEDs Test Program this is the "hello world for electronics"
 * 1.1.2013
 */

#include "stm32f10x.h"
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"

void init_GPIO(void);

void delay_nus(uint32_t nus);

int main(void)
{
	init_GPIO();
    while(1)
    {
		/* Toggle LEDs which connected to PC6 and PC7 ; Green/Yellow LEDs from Olimex Board*/
		GPIOC->ODR ^= GPIO_Pin_6;						// invert pin
		delay_nus (100000);								// delay a short time
		GPIOC->ODR ^= GPIO_Pin_7;						// toggle other LED
		delay_nus (100000);
    }
}

void init_GPIO(void)
{
    /* Initialize GPIO Structure, configure clock on peripheral bus
     * Enable GPIO Pins for LED which are connected to PC6,7*/
    /* Configure the GPIO_LED pin  PC6 = Green LED PC7 = Yellow LED
     * Configure direction and clock speed*/

	GPIO_InitTypeDef  GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOC, &GPIO_InitStructure);
}

/***************************************************************************//**
 * @brief     delay in n us
 * @param[in] n:delay value
 * @return    None
*******************************************************************************/
void delay_nus(uint32_t nus)
{
 uint32_t temp;
 SysTick->LOAD = nus * 11;
 SysTick->VAL = 0x00;
 SysTick->CTRL = 0x01 ;
 do
 {
  temp=SysTick->CTRL;

 }while(temp&0x01&&!(temp&(1<<16)));
 SysTick->CTRL = 0x00;
 SysTick->VAL = 0X00;
}

Details

Elektronik

Hits: 22945

Das Olimexino-STM32 Demo Board ist ein sehr preiswertes STM32 Demo-Board für kleine Test- und Bastelanwendungen, aber auch sehr gut um zu lernen wie man denn die STM32 CPUs programmiert. Mit einem Preis von unter 20 Euro kann man dies sicher nicht selbst fertigen.

Hier ist das Board beschrieben. Dort und in vielen Internet-Shops kann man dies sehr preiswert bestellen.

https://www.olimex.com/Products/Duino/STM32/OLIMEXINO-STM32/

Das Bild oben zeigt das Board mit angeschlossenem Programmierstecker, ein RS232/USB-Debug-Board sowie dem angeschlossenen CAN-Bus im unteren Bildbereich. Die Stromversorgung kann über ein einfaches Steckernetzteil von z.B. 12V erfolgen

Ich habe dieses Board als preiswertes Testboard für den CAN-Bus im allgemeinen, aber auch für den Test und als möglicher Ersatz meiner CAN-Jalousie-Controller verwendet.

Wie programmiert man das Board ?

PS: Damit die Timer bzw. delay Funktion richtig funktioniert, muss man darauf achten, dass die Quarzfrequenz richtig eingestellt ist.

Die Frequenz des externen Quarzes im header file stm32f10x.h an folgender Stelle ändern:

#if !defined HSE_VALUE
#ifdef STM32F10X_CL
#define HSE_VALUE ((uint32_t)25000000) /*!< Value of the External oscillator in Hz */
#else
#define HSE_VALUE ((uint32_t)8000000) /*!< Value of the External oscillator in Hz */
#endif /* STM32F10X_CL */
#endif /* HSE_VALUE */

Jetzt folgt nur ein Beispiel wie man den CAN-Bus auf dem Board programmmiert.

/*
 * Wolfram Koerver 2013
 * Demoprogram to test the CAN bus with the OLIMEXINO STM32 board from Olimex.
 * April 2013
 * This program just sends out a few CAN bus telegrams at a CAN bus baud rate of 125kbit/s
 * The sample program is very simple and not optmized in any way.
 */
#include "stm32f10x_gpio.h"
#include "stm32f10x_can.h"
#include "stm32f10x_rcc.h"
void GPIO_Blink(void)
{
    int i;
    /* Initialize LEDs mounted on Olimexino board */
    GPIO_InitTypeDef  GPIO_InitStructure;
    /* Initialize LED which is connected to PC6,9 and enable the clocks*/
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
    /* Configure the GPIO_LED pin */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
	/* Toggle LEDs which is connected to PC6*/
	GPIOA->ODR ^= GPIO_Pin_1;
	/* delay */
	for(i=0;i<0x500000;i++);
	/* Toggle LED which is connected to PC9*/
	GPIOA->ODR ^= GPIO_Pin_1;
	/* delay */
	for(i=0;i<0x500000;i++);
}
void CAN_init(){
	// define structures
	GPIO_InitTypeDef GPIO_InitStructure;
	CAN_InitTypeDef CAN_InitStructure;
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN1, ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO, ENABLE);
	// CAN transceiver is connected to Pin 8 and Pin 9
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_8;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
	GPIO_PinRemapConfig(GPIO_Remap1_CAN1 , ENABLE);
	// **** set the CAN baud rate to 125kHz
	CAN_InitStructure.CAN_Prescaler = 16;
	CAN_InitStructure.CAN_SJW = CAN_SJW_2tq;
	CAN_InitStructure.CAN_BS1 = CAN_BS1_12tq;
	CAN_InitStructure.CAN_BS2 = CAN_BS2_5tq;
	// ****
	CAN_InitStructure.CAN_Mode = CAN_Mode_Normal;
	CAN_InitStructure.CAN_TTCM = DISABLE;
	CAN_InitStructure.CAN_ABOM = DISABLE;
	CAN_InitStructure.CAN_AWUM = DISABLE;
	CAN_InitStructure.CAN_NART = ENABLE;
	CAN_InitStructure.CAN_RFLM = DISABLE;
	CAN_InitStructure.CAN_TXFP = DISABLE;
	CAN_Init(CAN1, &CAN_InitStructure);
}
int main(void)
{
	SystemInit();
	CAN_init();
	CanTxMsg canMessage;		// Define the CAN telegram
	//canMessage.ExtId = 0;
	canMessage.StdId = 0x22;
	canMessage.RTR = CAN_RTR_DATA;
	canMessage.IDE = CAN_ID_STD;
	canMessage.DLC = 8;
	canMessage.Data[0] = 0;
	canMessage.Data[1] = 10;
	canMessage.Data[2] = 20;
	canMessage.Data[3] = 30;
	canMessage.Data[4] = 40;
	CAN_Transmit(CAN1, &canMessage);
	GPIO_Blink();
	canMessage.Data[0] = 0;
	canMessage.Data[1] = 11;
	canMessage.Data[2] = 21;
	canMessage.Data[3] = 31;
	canMessage.Data[4] = 41;
	CAN_Transmit(CAN1, &canMessage);
	GPIO_Blink();
	canMessage.Data[0] = 0;
	canMessage.Data[1] = 12;
	canMessage.Data[2] = 22;
	canMessage.Data[3] = 32;
	canMessage.Data[4] = 42;
	CAN_Transmit(CAN1, &canMessage);
	GPIO_Blink();
}

Dies ist nur ein Minibeispiel um die CAN-Schnittstelle zu konfigurieren und 3 verschiedene CAN-Telegramme auszusenden. Dies auch nur um die grundsätzliche Funktionsweise des CAN Bus mit dem Beagleboard unter LINUX zu testen.

Und so sieht das (TTL)-CAN-Telegram (das letzte) auf dem Logicanalyser aus

SPI1 Schnittstelle

Um einfache Ausgaben auch auf einem kleinen Display auszugeben kann man die SPI-Schnittstelle verwenden. Diese liegt beim Olimexino hier:

SPI1 Pins sind:

SCK : PA5

MISO : PA6

MOSI : PA7

NSS : PA4

Wie das geht steht hier.

Timer und Interrupts

Hier folgt jetzt ein Beispielprogramm wie man die Timer des STM32 programmiert.

#include <stdio.h>
#include "stm32f10x_rcc.h"
#include "stm32f10x_gpio.h"
#include <stddef.h>
#include "stm32f10x.h"
#include "stm32f10x_conf.h"
#include <string.h>
#include <misc.h>
#include "stm32f10x_tim.h"
/*
 * Program to test the TIM2 timer and interrupt function for STM32F103RB
 * tested with OLIMEXINO STM32 Board
 * Wolfram Koerver - 2013
 *
 * Program starts blinking with approx. 5/sec with the yellow LED on port PA1
 * Interrupt is generated every 1000us to flip a signal at PB6 (D5 output)
 */
void init_LED(void);
void blink_yellow(void);
void init_timer(void);
void init_DO(void);
void toggle_do(void);
void toggle_dot(void);
void delay_us(uint32_t time_us);
void delay_ms(uint32_t time_ms);
void TIM2_IRQHandler(void);
void init_sys_tick(void);
int main(void)
{
	SystemInit();					// initialize the core
	init_LED();						// Init the LED port IO
	init_DO();						// init digital output port for digital output signal
	init_timer();					// configure the Timer Interrupt
    while(1)
    {
    	blink_yellow();				// let the main program do something
    	delay_ms(200);
    }
}
void TIM2_IRQHandler(void){			// Timer Interrupt handler for TIM2 will be called every 1ms
  TIM_ClearITPendingBit(TIM2, TIM_IT_Update);	// Clear interrupt pending bit
  toggle_do();						//generate output bit pulse on output
}
void init_timer(void)
{
	// SystemCoreClock = 72MHz -> APB1 is maximum 36MHz for TIM2,3,4,5 but will be doubled again to 72MHz when prescaler # 0
	// This example uses TIM2 Timer
	// APB1 clock = SystemCoreClock/2 but s.o.
	TIM_TimeBaseInitTypeDef TIM_TimeBase_InitStructure;
	NVIC_InitTypeDef NVIC_InitStructure;
	RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM2, ENABLE);
	TIM_TimeBase_InitStructure.TIM_ClockDivision = TIM_CKD_DIV1;
	TIM_TimeBase_InitStructure.TIM_Period 			= 999;		// count up to 999 = 1000
	TIM_TimeBase_InitStructure.TIM_Prescaler		= 71;		//72(MHz) -1 Divided by 72
	TIM_TimeBase_InitStructure.TIM_CounterMode 		= TIM_CounterMode_Up;
	//
	// 1MHz / 500 = 2000 Hz.
	// SystemCoreClock = 72MHz / 72 => 1 MHz Clock with this clock the timer counts up to 999 = 1000 counts =
	// 1/1000 --> 1000 Hz = 1ms cycle time
	TIM_TimeBaseInit(TIM2, &TIM_TimeBase_InitStructure);
	TIM_ITConfig(TIM2, TIM_IT_Update, ENABLE);
	NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x0F;
	NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x0F;
	NVIC_Init(&NVIC_InitStructure);
	TIM_Cmd(TIM2, ENABLE);
}
void delay_us(uint32_t nus)
{
 uint32_t temp;
 SysTick->LOAD 	= nus * 11;
 SysTick->VAL 	= 0x00;
 SysTick->CTRL 	= 0x01 ;
 do
 {
  temp=SysTick->CTRL;
 }
 while(temp&0x01&&!(temp&(1<<16)));
 SysTick->CTRL = 0x00;
 SysTick->VAL = 0X00;
}
void delay_ms(uint32_t time_ms) //Delay in msec
{
  while (time_ms>0)
  {
	delay_us(1000);
    time_ms--;
  }
}
void init_DO(void)
{
	/*
	 * the following statements are for the DO Output Pins to measure
	 * Clock settings. Initialize GPIO Structure, configure clock on peripheral bus
	 * Enable GPIO Pins
	 * Configure direction and clock speed
	 */
	GPIO_InitTypeDef  GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOB, &GPIO_InitStructure);
}
void init_LED(void)
{
	/* Initialize GPIO Structure, configure clock on peripheral bus
	 * Enable GPIO Pin for yellow LED which
	   Configure direction and clock speed */
	GPIO_InitTypeDef  GPIO_InitStructure;
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA, &GPIO_InitStructure);
}
void blink_yellow()
{
	GPIOA->BRR = GPIO_Pin_1;						//reset bit
	GPIOA->BSRR = GPIO_Pin_1;						//set bit
	delay_ms(1);
	GPIOA->BRR = GPIO_Pin_1;						//reset bit
}
void toggle_yellow()
{
	GPIOA->ODR ^= GPIO_Pin_7;						// invert pin
}
void toggle_do()
{
	GPIOB->ODR ^= GPIO_Pin_6;						// invert pin
}
void toggle_dot()
{
	GPIOB->BSRR = GPIO_Pin_6;						//set bit
	GPIOB->BRR = GPIO_Pin_6;						//reset bit
}

Hier jetzt noch der Downloadlink.