Panier

article (vide)

Aucun produit

Expédition 0,00 €
Total 0,00 €

Commander

Boutique

Notre équipe à votre service

Question pré-achat ? Besoin de support ?
> Visitez notre forum <

Vous avez besoin d'un devis ?
> Contactez-nous <

Vous souhaitez commander par courrier ?
> Téléchargez un bon de commande <

Renvoyez le complèté avec votre paiement à :
Devtronic SARL
21 rue Jean-Jacques Rousseau
92150 SURESNES

Modes de paiement

Exemples de codes : Communication UART (basé sur AVRlib)

Introduction

L'exemple de communication UART est assez simple puisque nous utilisons la librairie AVRlib qui contient des fonctions prête à l'emploi pour communiquer sur l'UART. Cette librairie UART est basée sur l'utilisation des interruptions.
Un pré-requis est donc d'avoir la librairie installée et configurée sur votre PC (voir le tutoriel).

Cet exemple de code est adapté aux microcontrôleurs AVR ne possèdant qu'un seul UART. Sachez cependant que la librairie AVRlib comporte également un groupe de fonctions pour les AVR à plusieurs UART, nous vous conseillons de vous référez à la documenation de la librairie pour plus d'informations.

Description rapide la librairie

Les fonctions suivantes sont disponibles pour la communication uart dans AVRlib :void uartInit (void) void uartInitBuffers (void) void uartSetRxHandler (void(*rx_func)(unsigned char c)) void uartSetBaudRate (u32 baudrate) cBuffer * uartGetRxBuffer (void) cBuffer * uartGetTxBuffer (void) void uartSendByte (u08 data) int uartGetByte (void) u08 uartReceiveByte (u08 *data) u08 uartReceiveBufferIsEmpty (void) void uartFlushReceiveBuffer (void) u08 uartAddToTxBuffer (u08 data) void uartSendTxBuffer (void) Avant toute communication, il vous faudra donc faire appel aux fonctions uartInit et uartSetBaudRate, la fonction uartInitBuffers étant appelée implicitement.

Les fonctions de réception et d'envoi sont ensuite assez simple d'utilisation. Il faut juste bien comprendre que la librairie fonctionne par interruptions et que les données reçues sont stockées dans un gros buffer dont la taille est définie par l'utilisateur et qu'il ne suffit donc que de venir lire dans ce buffer les octets un à un.

Notre exemple montre l'utlisation des fonctions de cette librairie, vous devriez donc, en le parcourant, comprendre comment utiliser cette librairie.

Téléchargez les fichiers

Les fichiers qui suivent ont été testés pour les cartes citées ci-dessous et peuvent trêtre utilisées sur vos propres cartes ou d'autres cartes. Les seules différences à noter entre les deux versions est que le fichier timer de AVRlib utilisé change entre les microcontrôleurs de la gamme ATmegax8 et le microcontrôleur ATmega8 de la carte myAVR ainsi que la fréquence de fonctionnement (F_CPU dans le fichier global.h). Le changement de fréquence est plus une particularité inhérente aux cartes utilisés pour les tests, à vous de régler ce paramètre selon vos utilisations.

Téléchargement ATmega8 (mySmartControl M8 ou myAVR Board avec ATmega8) : Télécharger
ATmega168 ou autre microcontrôleur de la gamme ATmegax8 (mySmartControl M168) : Télécharger

Source (.c)

//------------------------------------------------------------------------------
// Titre         : Test UART
//------------------------------------------------------------------------------
// Fonction      : Exemple d'utilisation de la librairie UART AVRlib
//------------------------------------------------------------------------------
// Langage       : C
// Date          : 04/09/2008
// Version       : 1.0
// Auteur        : Devtronic SARL
//------------------------------------------------------------------------------

// Inclusions
#include "uart.h"
#include "rprintf.h"

// Redéfinition des tailles max des buffers de réception et d'émission (en octets)
#define UART_RX_BUFFER_SIZE   0x000F // 15 octets en réception
#define UART_TX_BUFFER_SIZE   0x000A // 10 octets en émission

void gestion_reception(unsigned char c);

int main(void)
{
	u08 octet;
	int compteur;
	
	// Initialisation de l'UART
    uartInit();
	
	// Configuration du débit
    uartSetBaudRate(57600);
	
	// Envoi d'une chaîne de caractère en utilisant la fonction rprintf
    rprintfInit(uartSendByte);
    rprintf("Bonjour myAVR !\r\n");
    rprintf("Entrez un caractere : ");	
	
	// Attente de réception d'un caractère (buffer non vide)
	while (uartReceiveBufferIsEmpty())
		;
	
	// Récupération du caractère dans le buffer
	octet = uartGetByte();
	
	// Renvoi du caractère reçu avec retour à la ligne avant et après
	rprintf("\r\n");
	uartSendByte(octet);
	rprintf("\r\n");
	
	// Stockage d'octets jusqu'à remplissage dans le buffer TX
	for (compteur = 0;compteur < UART_TX_BUFFER_SIZE; compteur++)
	{
		octet = compteur + '0'; // Ajout de '0' pour conversion int - ASCII
		uartAddToTxBuffer(octet);
	}

// Envoi du contenu du buffer TX
	uartSendTxBuffer();
	rprintf("\r\n");
	
	// Assignation d'une fonction spécifique de traitement en réception
	uartSetRxHandler(gestion_reception);
	
	while (1);

return 0;
}

void gestion_reception(unsigned char c)
{
	// Renvoi du caractère reçu sur l'UART
	uartSendByte(c);
}

Header (.h) global (ATmega8)

//*****************************************************************************
//
// File Name	: 'global.h'
// Title		: AVR project global include 
// Author		: Pascal Stang
// Created		: 7/12/2001
// Revised		: 9/30/2002
// Version		: 1.1
// Target MCU	: Atmel AVR series
// Editor Tabs	: 4
//
//	Description : This include file is designed to contain items useful to all
//					code files and projects.
//
// This code is distributed under the GNU Public License
//		which can be found at http://www.gnu.org/licenses/gpl.txt
//
//*****************************************************************************

#ifndef GLOBAL_H
#define GLOBAL_H

// global AVRLIB defines
#include "avrlibdefs.h"
// global AVRLIB types definitions
#include "avrlibtypes.h"

// project/system dependent defines

// CPU clock speed
//#define F_CPU        20000000               		// 16MHz processor
//#define F_CPU        16000000               		// 16MHz processor
//#define F_CPU        14745000               		// 14.745MHz processor
//#define F_CPU        8000000               		// 8MHz processor
//#define F_CPU        7372800               		// 7.37MHz processor
//#define F_CPU        4000000               		// 4MHz processor
#define F_CPU        3686400               		// 3.69MHz processor
#define CYCLES_PER_US ((F_CPU+500000)/1000000) 	// cpu cycles per microsecond

#endif

Header (.h) global (ATmegax8)

#ifndef GLOBAL_H
#define GLOBAL_H

// global AVRLIB defines
#include "avrlibdefs.h"
// global AVRLIB types definitions
#include "avrlibtypes.h"

// project/system dependent defines

// CPU clock speed
#define F_CPU        20000000               		// 16MHz processor
//#define F_CPU        16000000               		// 16MHz processor
//#define F_CPU        14745000               		// 14.745MHz processor
//#define F_CPU        8000000               		// 8MHz processor
//#define F_CPU        7372800               		// 7.37MHz processor
//#define F_CPU        4000000               		// 4MHz processor
//#define F_CPU        3686400               		// 3.69MHz processor
#define CYCLES_PER_US ((F_CPU+500000)/1000000) 	// cpu cycles per microsecond

#endif

Makefile (ATmega8)

# Makefile for AVR function library development and examples
# Author: Pascal Stang
#
# For those who have never heard of makefiles: a makefile is essentially a
# script for compiling your code.  Most C/C++ compilers in the world are
# command line programs and this is even true of programming environments
# which appear to be windows-based (like Microsoft Visual C++).  Although
# you could use AVR-GCC directly from the command line and try to remember
# the compiler options each time, using a makefile keeps you free of this
# tedious task and automates the process.
#
# For those just starting with AVR-GCC and not used to using makefiles,
# I've added some extra comments above several of the makefile fields which
# you will have to deal with.

########### change this lines according to your project ##################
#put the name of the target mcu here (at90s8515, at90s8535, attiny22, atmega603 etc.)
#	MCU = atmega8515
	MCU = atmega8
#	MCU = atmega323
#	MCU = atmega161
#	MCU = atmega128

#put the name of the target file here (without extension)
#  Your "target" file is your C source file that is at the top level of your code.
#  In other words, this is the file which contains your main() function.

TRG = test_uart

#put your C sourcefiles here 
#  Here you must list any C source files which are used by your target file.
#  They will be compiled in the order you list them, so it's probably best
#  to list $(TRG).c, your top-level target file, last.

SRC = $(AVRLIB)/buffer.c $(AVRLIB)/uart.c $(AVRLIB)/rprintf.c $(AVRLIB)/timer.c $(AVRLIB)/vt100.c $(TRG).c

#put additional assembler source file here
#  The ASRC line allows you to list files which contain assembly code/routines that
#  you would like to use from within your C programs.  The assembly code must be
#  written in a special way to be usable as a function from your C code.

ASRC =

#additional libraries and object files to link
#  Libraries and object files are collections of functions which have already been
#  compiled.  If you have such files, list them here, and you will be able to use
#  use the functions they contain in your target program.

LIB	=

#additional includes to compile
	INC	=

#assembler flags
	ASFLAGS = -Wa, -gstabs

#compiler flags
	CPFLAGS	= -g -Os -Wall -Wstrict-prototypes -I$(AVRLIB) -Wa,-ahlms=$(<:.c=.lst)

#linker flags
	LDFLAGS = -Wl,-Map=$(TRG).map,--cref
#	LDFLAGS = -Wl,-Map=$(TRG).map,--cref -lm

########### you should not need to change the following line #############
include $(AVRLIB)/make/avrproj_make
		  
###### dependecies, add any dependencies you need here ###################
#  Dependencies tell the compiler which files in your code depend on which
#  other files.  When you change a piece of code, the dependencies allow
#  the compiler to intelligently figure out which files are affected and
#  need to be recompiled.  You should only list the dependencies of *.o 
#  files.  For example: uart.o is the compiled output of uart.c and uart.h
#  and therefore, uart.o "depends" on uart.c and uart.h.  But the code in
#  uart.c also uses information from global.h, so that file should be listed
#  in the dependecies too.  That way, if you alter global.h, uart.o will be
#  recompiled to take into account the changes.

buffer.o		: buffer.c		buffer.h
uart.o		: uart.c			uart.h		global.h
uart2.o		: uart2.c		uart2.h		global.h
rprintf.o	: rprintf.c		rprintf.h
a2d.o			: a2d.c			a2d.h
timer.o		: timer.c		timer.h		global.h
pulse.o		: pulse.c		pulse.h		timer.h	global.h
lcd.o			: lcd.c			lcd.h			global.h
i2c.o			: i2c.c			i2c.h			global.h
spi.o			: spi.c			spi.h			global.h
swpwm.o		: swpwm.c		swpwm.h		global.h
servo.o		: servo.c		servo.h		global.h
swuart.o		: swuart.c		swuart.h		global.h
tsip.o		: tsip.c			tsip.h		global.h
nmea.o		: nmea.c			nmea.h		global.h
vt100.o		: vt100.c		vt100.h		global.h
gps.o			: gps.c			gps.h			global.h
$(TRG).o		: $(TRG).c						global.h

Makefile (ATmegax8)

########### change this lines according to your project ##################
#put the name of the target mcu here (at90s8515, at90s8535, attiny22, atmega603 etc.)
#	MCU = atmega8515
	MCU = atmega168
#	MCU = atmega323
#	MCU = atmega161
#	MCU = atmega128

TRG = test_uart_x8

SRC = $(AVRLIB)/buffer.c $(AVRLIB)/uart.c $(AVRLIB)/rprintf.c $(AVRLIB)/timerx8.c $(AVRLIB)/vt100.c $(TRG).c