Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi
Foros Registrarse ¿Olvidaste tu contraseña?
02/01/2014 #1

Avatar de george.manson.69

Development Kits (Arduino, FS, STM,ARM,TI)
Hola Todos,

En este espacio compartiré el uso de los Development kits con videos y codigos, tales como:

1.- Arduino Leonardo
2.- Freescale KL25Z
3.- DiscoveryF0
4.- LaunchPad
5.- ARM LPC Cortex Development Board ((Cortex-M3, LQFP100))

Y tambien usaremos los siguientes IDE de cada compañia:

1.- Arduino(Leonardo)
2.- CodeWarrior (Freescale)
4.- Keil (ST,ARM)
5.- Code Composer(Texas Intruments)

Por ahora les paso tres ejemplos con Arduino Leonardo:


Código:
//Simple Switch con Led
const int buttonPin = 2;     // Definimos el Pin de entrada
const int ledPin =  12;      // Definimos el Pin de Salida

//Definimos una variable de lectura del interruptor
int buttonState = 0;         

//Funcion de Configuracion
void setup() {
  //Inicializamos el pin 12 como salida
  pinMode(ledPin, OUTPUT);      
  //Inicializamos el Pin 2 como entrada
  pinMode(buttonPin, INPUT);     
}

//Funcion que correo en un ciclo infinito
void loop(){
  //Leemos el estado del interruptor
  buttonState = digitalRead(buttonPin);

  //Si es presionado entonces prende el Led
  if (buttonState == HIGH) {     
    digitalWrite(ledPin, HIGH);  
  } 
  else {
    //Sino lo apaga
    digitalWrite(ledPin, LOW); 
  }
}



Código:
//Definimos pines de trabajo
int sensorPin=0;
int ledPin=13;

//Funcion de configuracion

void setup(){
   Serial.begin(9600);
   while(!Serial);
}

void loop(){
  //Graba en una variable el dato leido del ADC0
  int sensorValue=analogRead(sensorPin);
  //Conviete a voltaje
  float volts=((float)sensorValue*5)/1023;

  //Imprime
  Serial.println(volts,3);
  //Retardo 1s
  delay(1000);
}


Código:
//Control de Servo HD-1440A
#include<Servo.h>

Servo myservo; //Creamos un objeto de Servo 

//Funcion de Configuracion

void setup(){
  myservo.attach(9); //Conifguramos el Pin 9 como salida para Servo
  Serial.begin(9600);//Se configura el serial port a 9600
  while(!Serial);
}

//Funcion principal
void loop(){
  int pot=analogRead(0);      //Leemos Entrada Analoga 0 
  float grados=((float)pot*180)/1023;  //Convertimos a Grados de rango de 0 a 180
  
  Serial.println(grados,1);   //Imprimimos en que posicion esta
  pot=map(pot,0,1023,0,179);  //Mapeamos el valor del pot a 0 a 180
  myservo.write(pot);         //Esablecemos el Servo en la posicion actual
  delay(350);
}
05/01/2014 #2

Avatar de george.manson.69

Ti launch pad
Hola a todos,

En este video veremos una pequeña instroduccion al development kit de texas instruments.

Saludos!


Código:
/*
 * Codigo para encender los Pines de salida con un switch
 * Compañia: ucursos.blogspot.com
 */

#include <msp430g2553.h>

//Definiciones de Funciones
void _delay(unsigned long t);

//Definiciones Globales
#define Led0	BIT0
#define Led6	BIT6


//Definiciones de Variables Globales
const int True=1;


/*
 * main.c
 * Funcion Principal
 */
int main(void) {

    WDTCTL = WDTPW | WDTHOLD;						// Stop watchdog timer

    P1DIR|=(Led0 + Led6);							//Definimos pines de Salida P1.0 y P1.6 como salida
    P1REN|=BIT3;									//Definimos la resistencias pullups en el PIN3

    while(True){									//Ciclo Infinito
    	if((P1IN&0x08)==0){							//P1.3 = 1? Entra a para enceder las salidas 0 y 6
    		P1OUT|=(Led0 + Led6);					//Se espera tiempo suficiente para que no halla repobotes
    		_delay(1000000);
    	}else{
    		P1OUT&=~(Led0 + Led6);					//Si P1.3 = 0? Entonces apaga las salidas correspondientes
    		_delay(1000000);
    	}
    }
}


//Funcion de retrasos
void _delay(unsigned long t){
	while(--t>0);
}
13/01/2014 #3

Avatar de thunder2

Hola, estoy realizando una board con el STM32F103c8T6, que solicite de muestra a STMicrolectronics, la idea es empezar con estos micros. Pero tambien tengo Stellaris launchpad LM4F120.
A ver si realizo la placa y a ver como me queda. Saludos.
04/02/2014 #4

Avatar de george.manson.69

TI LaunchPad: Shift Leds
Hola a todos,

Aqui les comparto otro codigo para el MSP430.

https://www.youtube.com/watch?v=FDyx...ature=youtu.be

Código:
/*
 * Codigo par hacer un corrimiento de led
 * Compañia: ucursos.blogspot.com
 */

#include <msp430g2553.h>
#include "delay.h"

/*
 * Definimos Varibales globales
 */

volatile unsigned char inc=0;

/*
 * @PARAM = shift -> Variable que maneja el corrimiento de led
 * 		  =   0  ->Corrimiento hacia la derecha
 * 		  =	  1  ->Corrimiento hacia la Izquierda
 */

void shift_leds(unsigned char shift){

	if(shift==1){

		if((P1OUT&0x10)==0X10){
			P1OUT=0x01;
		}else{
			P1OUT<<=1;
		}

	}else{

		if((P1OUT&0x01)==0x01){
			P1OUT=0x10;
		}else{
			P1OUT>>=1;
		}

	}
}

/*
 * main.c
 */
void main(void) {
    WDTCTL = WDTPW | WDTHOLD;	// Stop watchdog timer

    /*
     * Se calibra la velocidad del cristal interno
     * a 1 Mhz
     */
    if(CALBC1_1MHZ == 0xFF || CALDCO_1MHZ == 0xFF){
    	while(1);
    }

    BCSCTL1 = CALBC1_1MHZ;
    DCOCTL	= CALDCO_1MHZ;

    /*
     * Inicializa los P1.0 al P1.7 como salida
     * Inicializa Apagado
     */
    P1DIR|=0xFF;
    P1OUT=0x00;
    P1REN=0x00;
    /*
     * Inicializa el pin P2.0 como entrada
     * P2.0 - Pullup
     */
    P2DIR&=~(BIT0);
    P2OUT|=(BIT0);
    P2REN|=(BIT0);

    /*
     * Inicializa Puerto 2
     */
    P1OUT=0x01;

    while(1){

    	if(!(P2IN&0x01)){

    		inc=1;

    	}else{

    		inc=0;
    	}

		shift_leds(inc);

		delay(10000);
    }

}


Saludos!
09/02/2014 #5

Avatar de ls2k

Hola compadre, estoy pensando en comprar el launchpad y el frrescale frdm kl25z que me recomiendas? me los compro o no?
10/02/2014 #6

Avatar de george.manson.69

ls2k dijo: Ver Mensaje
Hola compadre, estoy pensando en comprar el launchpad y el frrescale frdm kl25z que me recomiendas? me los compro o no?
Comprate los dos, ya que launchPad esta facil la programacion en Code Composer Studio 5. Y tambien el de freescale, aun no empezado con freescale pero te aseguro que tambien esta facil!!
12/02/2014 #7

Avatar de thunder2

KL25 freedom vs Launchpad Stellaris
Me gusta stellaris, por que no dependo de internet para el IDE, pero sin embargo es grande el ecosistema de mbed. Se que con la launchpad stellaris puedo utilizarlo como progrmador (LMFlash) de texas instruments. Pero con freescale desconozco si pueda utilizarse como programador.
Creo que se pueden portar la librerias de mbed a arduino.

Gracias y buen día
17/02/2014 #8

Avatar de george.manson.69

Manual para TI:MSP430
Hola a Todos,

Les comparto un pequeño manual relacionado a los Microcontroladores Texas Intruments, es un pequeña guía del cual el usuario podrá empezar a programar en Code Composer Studio.

Saludos!!!
Archivos Adjuntos
Tipo de Archivo: pdf Iniciando con los Microcontroladores Texas Intruments.pdf (1,51 MB (Megabytes), 52 visitas)
03/03/2014 #9

Avatar de george.manson.69

ARM Cortex M0
Hola Todos,

Les comparto el video de introduccion a los ARM CORTEX M0, y tambien el uso del software de KEIL.

Saludos!


04/03/2014 #10

Avatar de thunder2

Hola George, serias tan amable si tendrás por ahí un tutorial para otro ARM Cortex M0, el STM32F0 (board STM32F0discovery). Compre esta board y pues entiendo poco la programación en compiladores ARM.

Muchas gracias y buen día.
07/03/2014 #11

Avatar de george.manson.69

thunder2 dijo: Ver Mensaje
Hola George, serias tan amable si tendrás por ahí un tutorial para otro ARM Cortex M0, el STM32F0 (board STM32F0discovery). Compre esta board y pues entiendo poco la programación en compiladores ARM.

Muchas gracias y buen día.
Hola Thunder,

Yo compre un STM32F0 del cual empezare a usarlo cuando termine el Manual para ARM CORTEX M0 de la compañia de NXP el LPC1114/302 que usa el procesador ARM CORTEX M0.

Despues seguira el ARM CORTEX M3 LPC1768, Freescale y por ultimo los ARM CORTEX A9 (CubieBoard)

Saludos Cordiales!
08/03/2014 #12

Avatar de george.manson.69

Arm Cortex: Sistema de Oscilador
Hola a Todos,

Les comparto como configurar el oscilador externo + PLL.

Código:
#include <lpc11xx.h>

uint32_t TimeTick=0;


void SysTick_Handler(void)					  
{
	TimeTick++;
}

/** 
Funcion para establecer a 48Mhz el Microcontrolador.
*/

void SetClockTo48Mhz(void){
	volatile uint32_t i;
	
	/*
		Prendemos el Sistema de oscilador
		
	*/
	LPC_SYSCON->PDRUNCFG&=~(1<<5);
	/*
		BYPASS -> 0
		FREQRANGE -> 0 [1 A 20Mhz]
	*/
	LPC_SYSCON->SYSOSCCTRL = 0x00000000;
	for (i = 0; i < 200; i++) __NOP();
	
	/**
		Seleccionamos Oscilador
	
		System Oscillator como fuente principal
	*/
	
	
	LPC_SYSCON->SYSPLLCLKSEL = 0x00000001;
	LPC_SYSCON->SYSPLLCLKUEN &=~(1<<0);
	LPC_SYSCON->SYSPLLCLKUEN |=(1<<0);
	
	/*
		Prendemos Sistema de PLL
		SYSPLL_PD = 0
		Modo de operacion : Normal
		
		M=FCLKOUT/FCLKIN
		FCLKOUT=48Mhz <- Deseable
		FCLKIN=12Mhz<- Cristal que Uso
		M=4
		
		FCC0=2xPxFCLKOUT
		156<FCC0<320Mhz
		P=2
		FCC0=192Mhz <-Esta en rango
		
		MYPASS = 0
		DIRECT = 0
		
		Espero para que la frecuencia se estabilize
	*/
	
	LPC_SYSCON->PDRUNCFG&=~(1<<7);
	LPC_SYSCON->SYSPLLCTRL = 0x00000023;
	while(!(LPC_SYSCON->SYSPLLSTAT&0x01));
	/**
		Seleccionamos Principal que es Salida de Sistema PLL
		
		MAINCLKSEL=System PLL Clock out
		
	*/
	LPC_SYSCON->MAINCLKSEL = 0x00000003;
	LPC_SYSCON->MAINCLKUEN &=~(1<<0);
	LPC_SYSCON->MAINCLKUEN |=(1<<0);
}

/**
	Funcion de retardo usando el Hardware de SysTick
*/

void delay_ms(uint32_t ms){
	
	/**
		Calcula el tiempo si ms=1
	
		Tick = (1/48,000,000 hz)
		
		Retardo = ((48000*ms)-1)x Tick
		Retardo =  0.0009999s ~ 1mS
	*/
	
	SysTick->LOAD = ((48000)*ms)-1;
	SysTick->VAL = 0;
	SysTick->CTRL = (1<<0)|(1<<1); 
	
	while(!TimeTick);
	TimeTick=0;
	SysTick->CTRL = 0;
	
}


/*
	Funcion de Inicializar Salidas y entradas
*/
void SetIOs(void){
	LPC_GPIO0->DIR |=(1<<8); 
}

/*
	Funcion Principal
*/
int main(void){

	SetClockTo48Mhz();
	SetIOs();
	
	while(1){
		LPC_GPIO0->DATA &=~(1<<8);
		delay_ms(500);
		LPC_GPIO0->DATA |=(1<<8);
		delay_ms(500);
	}
	
	
}
Archivos Adjuntos
Tipo de Archivo: pdf UCURSOS 1.1.pdf (194,2 KB (Kilobytes), 19 visitas)
12/03/2014 #13

Avatar de george.manson.69

Arm Cortex: UART
Hola ,

Les paso el manual para configurar el UART del LPC1114/302 de NXP.

Código:
#include <lpc11xx.h>
#include <stdio.h>


uint16_t _index;
uint32_t TimeTick=0;

/** 
Funcion para establecer a 48Mhz el Microcontrolador.
*/

void SetClockTo48Mhz(void){
	volatile uint32_t i;
	
	/*
		Prendemos el Sistema de oscilador
		
	*/
	LPC_SYSCON->PDRUNCFG&=~(1<<5);
	/*
		BYPASS -> 0
		FREQRANGE -> 0 [1 A 20Mhz]
	*/
	LPC_SYSCON->SYSOSCCTRL = 0x00000000;
	for (i = 0; i < 200; i++) __NOP();
	
	/**
		Seleccionamos Oscilador
	
		System Oscillator como fuente principal
	*/
	
	
	LPC_SYSCON->SYSPLLCLKSEL = 0x00000001;
	LPC_SYSCON->SYSPLLCLKUEN &=~(1<<0);
	LPC_SYSCON->SYSPLLCLKUEN |=(1<<0);
	
	/*
		Prendemos Sistema de PLL
		SYSPLL_PD = 0
		Modo de operacion : Normal
		
		M=FCLKOUT/FCLKIN
		FCLKOUT=48Mhz <- Deseable
		FCLKIN=12Mhz<- Cristal que Uso
		M=4
		
		FCC0=2xPxFCLKOUT
		156<FCC0<320Mhz
		P=2
		FCC0=192Mhz <-Esta en rango
		
		MYPASS = 0
		DIRECT = 0
		
		Espero para que la frecuencia se estabilize
	*/
	
	LPC_SYSCON->PDRUNCFG&=~(1<<7);
	LPC_SYSCON->SYSPLLCTRL = 0x00000023;
	while(!(LPC_SYSCON->SYSPLLSTAT&0x01));
	/**
		Seleccionamos Principal que es Salida de Sistema PLL
		
		MAINCLKSEL=System PLL Clock out
		
	*/
	LPC_SYSCON->MAINCLKSEL = 0x00000003;
	LPC_SYSCON->MAINCLKUEN &=~(1<<0);
	LPC_SYSCON->MAINCLKUEN |=(1<<0);
}


/**
	Funcion de retardo usando el Hardware de SysTick
*/

void SysTick_Handler(void)					  
{
	TimeTick++;
}


void delay_ms(uint32_t ms){
	
	/**
		Calcula el tiempo si ms=1
	
		Tick = (1/48,000,000 hz)
		
		Retardo = ((48000*ms)-1)x Tick
		Retardo =  0.0009999s ~ 1mS
	*/
	
	SysTick->LOAD = ((48000)*ms)-1;
	SysTick->VAL = 0;
	SysTick->CTRL = (1<<0)|(1<<1); 
	
	while(!TimeTick);
	TimeTick=0;
	SysTick->CTRL = 0;
	
}


/**
Funcion que adquiere 1 byte de la memoria de RX
*/
int UART_getc(void){
	while(!(LPC_UART->LSR & (1<<0)));
	return LPC_UART->RBR;
}

/**
Funcion de enviar 1 byte de la memoria de TX
*/

void UART_putc(uint8_t _dt){
	while(!(LPC_UART->LSR & (1<<5)));
	LPC_UART->THR = _dt;
}


void SetUartTo(uint32_t br){
	
	uint32_t DL_Value;
	uint32_t bufcl=bufcl;

	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<16); 		//Habilita Reloj para configurar Pines E/S
	LPC_IOCON->PIO1_6 &=~0x07;						
	LPC_IOCON->PIO1_6 =(1<<0);								//Configuramos el bit 6 del puerto 1 Como funcion RX
	
	LPC_IOCON->PIO1_7 &=~0x07;						
	LPC_IOCON->PIO1_7 =(1<<0);								//Configuramos el bit 7 del puerto 1 Como funcion TX
	LPC_SYSCON->SYSAHBCLKCTRL &= ~(1<<16); 		//Deshabilita Reloj para configurar Pines E/S
	
	LPC_SYSCON->UARTCLKDIV = 0x01;						//Divisible por 1
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<12); 		//Habilita Reloj para configurar el UART
	LPC_UART->LCR=0x83;												//8-N-1 , Habilita el Acceso para Divisor de Latches
	
	DL_Value=48000000/(16*br);
	
	
	LPC_UART->DLM = DL_Value/256;
	LPC_UART->DLL = DL_Value % 256;
	
	LPC_UART->LCR = 0x03;											//8-N-1 , Deshabilita el Acceso para Divisor de Latches
	LPC_UART->FCR = 0X07;											//Habilita la Alta actividad para ambos TX,RX y Acceso
																						//U0FCR[1:7]
																						//RXFIFO Limpia todos los bytes del FIFO
																						//TXFIFO Limpia todos los bytes del FIFO
}

/*
	Funcion de Inicializar Salidas y entradas
*/
void SetIOs(void){
	LPC_GPIO0->DIR |=(1<<8); 
}

int main(void){
	
	SetClockTo48Mhz();
	SetUartTo(115200);
	SetIOs();
	
	while(1){
		
		for(_index=0;_index<100;_index++){
			
			printf("%u\r\n",_index);
			LPC_GPIO0->DATA &=~(1<<8);
			delay_ms(250);
			LPC_GPIO0->DATA |=(1<<8);
			delay_ms(250);
			
		}

	}

}
Manual Aqui

Saludos!
Archivos Adjuntos
Tipo de Archivo: pdf UCURSOS 1.2.pdf (334,1 KB (Kilobytes), 9 visitas)
15/03/2014 #14

Avatar de george.manson.69

ARM Cortex: ADC
Hola,


Subo un manual para configurar el ADC del Microcontrolador LPC1114/302.


Código:
#include	<LPC11xx.h>
#include	"SetClock48Mhz.h"
#include	"TickTimer.h"
#include	"SetUart.h"

#define	ANALOG_INPUTS			0x03
#define MAX_BAUDRATE			115200
#define	MAX_ADC_CLOCK			2400000


uint16_t _index;
uint16_t	ADC_BUFFER[2];


uint32_t Read_ADC(uint8_t ch){

	LPC_ADC->CR |= (0x01 << ch)|(1<<24);
	
	while(!(LPC_ADC->STAT&(1<<ch)));
	LPC_ADC->CR &=~(0x01 << ch);

	return ((LPC_ADC->DR[ch] >> 6) & 0x3FF);
}


void SetADC(uint8_t Set_ADC_In,uint32_t AdcClk){

	
	LPC_SYSCON->PDRUNCFG &= ~(0x1<<4);				//Habilita el Reloj hacia el ADC 

	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<13); 		//Habilita Reloj para configurar ADC
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<16); 		//Habilita Reloj para configurar Pines E/S
	
	if((Set_ADC_In&(1<<0x00))){
		
		LPC_IOCON->R_PIO0_11 = 0x02;
		
	}
	if((Set_ADC_In&(1<<0x01))){

		LPC_IOCON->R_PIO1_0 = 0x02;

	}
	if((Set_ADC_In&(1<<0x02))){

		LPC_IOCON->R_PIO1_1 = 0x02;

	}
	if((Set_ADC_In&(1<<0x03))){

		LPC_IOCON->R_PIO1_2 = 0x02;

	}
	
	LPC_ADC->CR |= (1<<1)| (((48000000/AdcClk)-1)<<8) | (0<<16)| (0<<17) | (0<<24);
	
	LPC_SYSCON->SYSAHBCLKCTRL &= ~(1<<16); 		//Deshabilita Reloj para configurar Pines E/S

}

/*
	Funcion de Inicializar Salidas y entradas
*/
void SetIOs(void){
	LPC_GPIO0->DIR =(1<<8) + (1<<9); 
}

int main(void){
	
	SetClockTo48Mhz();
	SetUartTo(MAX_BAUDRATE);
	SetADC(ANALOG_INPUTS,MAX_ADC_CLOCK);
	SetIOs();
	
	LPC_GPIO0->DATA &=~(1<<9);
	delay_ms(1000);
	LPC_GPIO0->DATA |=(1<<9);
	
	while(1){
		
		for(_index=0;_index<sizeof(ADC_BUFFER);_index++){
			
			printf("%u\r\n",Read_ADC(_index));
			LPC_GPIO0->DATA &=~(1<<8);
			delay_ms(250);
			LPC_GPIO0->DATA |=(1<<8);
			delay_ms(250);
			
		}

	}
	
}



Saludos!
Archivos Adjuntos
Tipo de Archivo: pdf UCURSOS 1.3.pdf (168,5 KB (Kilobytes), 13 visitas)
19/03/2014 #15

Avatar de george.manson.69

ARM Cortex: Timer0 16 bits
Hola,

Les comparto miniManual para configurar el timer 0 (que tambien sirve para el timer 1) de 16 bits.

Código:
#include <lpc11xx.h>
#include "SetClock48Mhz.h"


void Timer16b1_ms(uint16_t _ms1_){

		LPC_SYSCON->SYSAHBCLKCTRL |= (1<<8);
		LPC_TMR16B1->TCR = 0x02;
		LPC_TMR16B1->PR	 = 48000;
		LPC_TMR16B1->MR0 = _ms1_;
		LPC_TMR16B1->IR	 = 0x01;
		LPC_TMR16B1->MCR |= (1<<2);
		LPC_TMR16B1->TCR = 0x01;
		
		while(LPC_TMR16B1->TCR & 0x01);

}


void Timer16b0_ms(uint16_t _ms0_){

	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<7);
	LPC_TMR16B0->TCR = 0x02;
	LPC_TMR16B0->PR	 = 48000;
	LPC_TMR16B0->MR0 = _ms0_;
	LPC_TMR16B0->IR	 = 0x01;
	LPC_TMR16B0->MCR |= (1<<2);
	LPC_TMR16B0->TCR = 0x01;
	
	while(LPC_TMR16B0->TCR & 0x01);

}

/*
	Funcion de Inicializar Salidas y entradas
*/
void SetIOs(void){
	LPC_GPIO0->DIR =(1<<8); 
}

int main(void){

	SetClockTo48Mhz();
	SetIOs();
	
	while(1){

			LPC_GPIO0->DATA &=~(1<<8);
			Timer16b0_ms(1000);
			LPC_GPIO0->DATA |=(1<<8);
			Timer16b0_ms(1000);

	}

}

Saludos!
Archivos Adjuntos
Tipo de Archivo: pdf UCURSOS 1.4.pdf (144,1 KB (Kilobytes), 13 visitas)
23/03/2014 #16

Avatar de Nuyel

Me gusta este tema, tengo la KL25Z, un Arduino Uno R3 y LaunchPad (G2, F5529 y Stellaris) solo hay que remarcar que la Stellaris está descontinuada, hay que mudarse a la Tiva C, en general con la programación no debería haber muchas diferencias (me parece que solo un par de funciones cambiaron de nombre), solo que el chip de la nueva LaunchPad Tiva C no es reemplazo equivalente, tiene otras capacidades adicionales.

Y otra cosa, en CCStudio para está la función intrínseca __delay_cycles(); en MSP43GCC hay que llamar intrinsics.h para poder implementarla, y si planeas usar cabeceras no estándares (como delay.h que declaras en un ejemplo) no olvides incluirlas, por ejemplo destellar un LED puede quedar en
Código:
#include <msp430.h>			// La configuración define el chip
void main(void) {
	WDTCTL = WDTPW | WDTHOLD;	// Detener vigilante
	P1DIR |= 0x01;			// Establecer P1.0 como salida

	while(1) {
		P1OUT ^= 0x01;		// Intercambiar P1.0 con XOR
		__delay_cycles(500000);	// Retrazo de 500 000 ciclos
	}
}
Les aporto mi AirMouse con la KL25Z, lo programé en mbed, no se necesita nada mas que lo integrado a la placa.
Código:
#include "mbed.h"
#include "MMA8451Q.h"
#include "USBMouse.h"
#include "TSISensor.h"

//Hardware definitions
#define MMA8451_I2C_ADDRESS (0x1d<<1)
#define LED_OFF 1
#define LED_ON 0

//Constructors
USBMouse mouse;
TSISensor tsi;
MMA8451Q acc(PTE25, PTE24, MMA8451_I2C_ADDRESS);
DigitalOut rled(LED_RED);
DigitalOut gled(LED_GREEN);
DigitalOut bled(LED_BLUE);

void ShowLed(int ButtonPressed, int mode){
	if (ButtonPressed & MOUSE_LEFT) rled.write(mode);
	if (ButtonPressed & MOUSE_RIGHT) gled.write(mode);
	if (ButtonPressed & MOUSE_MIDDLE) bled.write(mode);
}
int main(void) {
    
	rled.write(LED_OFF);
	gled.write(LED_OFF);
	bled.write(LED_OFF);
    bool TSI_Pressed = false;
    bool Clic_Hold = false;
    int ButtonPressed = 0; //1=MOUSE_LEFT 2=MOUSE_RIGHT 4=MOUSE_MIDDLE
    unsigned int TSI_Press_Time = 0;

    while (true) {
        if (TSI_Pressed == true){
            TSI_Press_Time++;
            if (tsi.readPercentage() < 0.01) { //TSI release
                if (TSI_Press_Time < 250) {
                    mouse.click(ButtonPressed);
                } else {
                    mouse.release(ButtonPressed);
                    Clic_Hold = false;
                }
                TSI_Pressed = false;
                TSI_Press_Time = 0;
				ShowLed(ButtonPressed, LED_OFF);
                ButtonPressed = 0;
            }
            if ((TSI_Press_Time > 250) && (Clic_Hold == false)){
                mouse.press(ButtonPressed);
                Clic_Hold = true;
            }
        } else { //TSI Is not press
            if (tsi.readPercentage() < 0.01) {} 	//Nothing is pressed
            else if (tsi.readPercentage() < 0.25) { //Right is pressed
                TSI_Pressed = true;
                ButtonPressed = MOUSE_RIGHT;
            }
            else if (tsi.readPercentage() < 0.75) { //Center is pressed
                TSI_Pressed = true;
                ButtonPressed = MOUSE_MIDDLE;
            } else { 						//Left is pressed
                TSI_Pressed = true;
                ButtonPressed = MOUSE_LEFT;
            }
			ShowLed(ButtonPressed, LED_ON);
        }
        float AccX = acc.getAccX() * 8;
        float AccY = acc.getAccY() * 6;
        signed char x = AccX * AccX;
        signed char y = AccY * AccY;
		if (AccX < 0) x *= -1;
		if (AccY < 0) y *= -1;
        mouse.move(x, y);
        wait(0.001);
    }
}
Aquí el código para compilar con GCC ARM Embedded por si no quieren/pueden usar el compilador online de mbed.
Archivos Adjuntos
Tipo de Archivo: zip AirMouse.zip (579,2 KB (Kilobytes), 9 visitas)
24/03/2014 #17

Avatar de george.manson.69

Arm Cortex: Timer Interrupcion
Nuyel dijo: Ver Mensaje
Me gusta este tema, tengo la KL25Z, un Arduino Uno R3 y LaunchPad (G2, F5529 y Stellaris) solo hay que remarcar que la Stellaris está descontinuada, hay que mudarse a la Tiva C, en general con la programación no debería haber muchas diferencias (me parece que solo un par de funciones cambiaron de nombre), solo que el chip de la nueva LaunchPad Tiva C ...

Hola Nuyel,

Excelente proyecto, espero que subas mas sobre como programar los Freescale, ya que yo personalmente no le he movido para nada, y eso que tengo un KL25L aun lado mio

-----------

Bueno regresando a la programacion de LPC1114/302, les comparto un codigo para la interrupcion por timer 0 de 16 bits.

Código:
#include <lpc11xx.h>
#include "SetClock48Mhz.h"

uint16_t cont;

void Timer16b1_ms(uint16_t _ms1_)
{

		LPC_SYSCON->SYSAHBCLKCTRL |= (1<<8);
		LPC_TMR16B1->TCR = 0x02;
		LPC_TMR16B1->PR	 = 48000;
		LPC_TMR16B1->MR0 = _ms1_;
		LPC_TMR16B1->IR	 |= (1<<0);
		LPC_TMR16B1->MCR |= (1<<2);
		LPC_TMR16B1->TCR = 0x01;
	
		while((LPC_TMR16B1->TCR & 0x01));	

}


void Timer16b0_ms(uint16_t _ms0_)
{

	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<7);
	LPC_TMR16B0->TCR = 0x02;
	LPC_TMR16B0->PR	 = 48000;
	LPC_TMR16B0->MR0 = _ms0_;
	LPC_TMR16B0->IR	|= (1<<0);
	LPC_TMR16B0->MCR |= (1<<2);
	LPC_TMR16B0->TCR = 0x01;
	
	while(LPC_TMR16B0->TCR & 0x01);

}

/*
	Funcion de Inicializar Salidas y entradas
*/
void SetIOs(void)
{
	LPC_GPIO0->DIR |=(1<<8) + (1<<9); 
	LPC_GPIO1->DIR |=(1<<10) + (1<<11);
}

void TIMER16_0_IRQHandler(void)
{
	
	if((LPC_TMR16B0->IR & 0x01)==1){

		LPC_GPIO0->DATA  ^= (1<<8);
		cont++;
	}

	LPC_TMR16B0->IR = 0x1F;
}

void TIMER16_1_IRQHandler(void)
{
	
	if((LPC_TMR16B1->IR & 0x01)==1){

		LPC_GPIO0->DATA  ^= (1<<9);
		
	}

	LPC_TMR16B1->IR = 0x1F;
}

void TIM16B0_INT_init(uint16_t ms)
{
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<7);
	LPC_TMR16B0->TCR = 0x02;
	LPC_TMR16B0->PR  = 48000;
	LPC_TMR16B0->MR0 = ms;
	LPC_TMR16B0->IR  = 0x01;		
	LPC_TMR16B0->MCR = 0x03;
	LPC_TMR16B0->TCR = 0x01;
	NVIC_EnableIRQ(TIMER_16_0_IRQn);
}

void TIM16B1_INT_init(uint16_t ms)
{
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<8);
	LPC_TMR16B1->TCR = 0x02;
	LPC_TMR16B1->PR  = 48000;
	LPC_TMR16B1->MR0 = ms;
	LPC_TMR16B1->IR  = 0x01;		
	LPC_TMR16B1->MCR = 0x03;
	LPC_TMR16B1->TCR = 0x01;
	NVIC_EnableIRQ(TIMER_16_1_IRQn);
}

int main(void)
{

	SetClockTo48Mhz();
	SetIOs();

	TIM16B0_INT_init(500);
	TIM16B1_INT_init(250);
	
	while(1){
		
		switch(cont){
			
			case 2:
				LPC_GPIO1->DATA  ^= (1<<10);
				break;
			
			case 4:
				LPC_GPIO1->DATA  ^= (1<<11);
				cont=0;
				break;
			
		}
		
	}
	
}


Saludos!
Archivos Adjuntos
Tipo de Archivo: pdf UCURSOS 1.5.pdf (187,2 KB (Kilobytes), 14 visitas)
25/03/2014 #18

Avatar de Nuyel

Honestamente no entendí al Code Warrior y la LauchPad Stellaris es bastante simple con sus librerías de periféricos, cuando tenga tiempo me meto con la FRDM-KL25Z.
27/03/2014 #19


msp launchpad
bueno compañeros les comparto un codigo para parpadear los dos leds del launchpad para MSP,
se utiliza el msp430g2553, el cual tiene timer A0, y timer A1, en esta ocasion solo use el timerA1 para generar una interrupccion cada 1s usando el TACCR0 en modo Up, para la fuente del reloj del timer se uso un cristal de 32.768 kHz conctado al ACLK el codigo es bastante sencillo y trate de explicarlo lo mejor que se pudo, espero haber sido claro y les sirva de ayuda hasta luego
p.d. el codigo fue hecho en CCS version 5.5.

Código:
#include <msp430.h> 


int main(void) {
    WDTCTL = WDTPW | WDTHOLD; //apagar el watchdog

    P1DIR = 0x41;  //acitvar las salidas del led 1 y led dos del launchpad

    TA0CTL = TACLR; //borrar el registro del timerA0 y detenerlo  restear los dividores de frecuencia y la fuente de reloj del timer
    TA0CTL |= 0x0100; // seleccionar el Auxiliary clock como fuente de reloj
    TA0CTL |= 0x0010; // seleccionar UP Mode para que el timer cuente hasta TACCRO

    TA0CCR0 = 32767; // contar hasta 32767 para que la interrupcion se produzca cada 1s ya que usa un cristal de 32.768 kHz
    					// escribiendo en este registro un valor diferente de cero automaticamente el timer empieza a contar
    TA0CCTL0 |= CCIE; // activar la interrupcion del TACCRO del timer A0




	return 0;
}


#pragma vector=TIMER0_A0_VECTOR
__interrupt void timerA0interrupción (void)
{
  P1OUT ^= 0x41;  // parpadear led1 y led2 del launchpad auna frecuencia de 1 Hz, no se necesita borrar el flag ya que este
  	  	  	  	  // se resetea por hardware
}
28/03/2014 #20

Avatar de Nuyel

recomendación: agrega el LPM3; antes del return y manda a dormir el CPU y reloj principal, ahorras energía además no se que es lo que hará el MCU despues de ejecutar el return, no se a donde regresará, como extra no te olvides de los capacitores de carga para el cristal, a menos de que los hayas soldado, si usas el cristal incluido debes emplear BCSCTL3 |= XCAP_3; para activar los capacitores internos en configuración de 12.5pf (verifiquen siempre el datasheet del chip para ver la configuración y la carga necesaria para el cristal).

Aquí había publicado un semáforo con MSP430 como ven hay una función llamada "esperar()" emplea un contador con el temporizador y manda a dormir al chip la mayor parte del tiempo, una ves que se prepara el tiempo a esperar el chip duerme, el temporizador lo despierta y verifica si puede continuar de lo contrario vuelve a dormir.
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Arduino y Raspberry Pi

Cerrar
Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos » Arduino y Raspberry Pi

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.