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


gracias! nuyel tienes razon se me olvido apagar el CPU para ahorrar energia, lo que pasa es que yo siempre programo en ensamblador y pues ahi si tienes que tener mas cosas en cuenta como inicializar la stack pointer etc. de hecho el codigo que subi es unos de los pocos que hice en C, en cuanto a lo de modificar el BCSCTL3 te comento que lo deje asi intencionalmente por que yo use un cristal diferente al que venia en el kit y el vendedor me dijo que la capacitancia recomendada era 6 pF entonces por eso lo deje asi ya que es la que viene por deafault, buenas tardes y muchos saludos.
31/03/2014 #22

Avatar de george.manson.69

ARM Cortex: I2C & FM24CLxx
Hola a Todos,

Les comparto un manual para el uso el protocolo I2C con el ejemplo con FM24CLxx usando el microcontrolador LPC1114/302.

FM24CLxx

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

#define I2CFrequency	400000
#define READ_PAGE		0xA1
#define WRITE_PAGE	0xA0

/*
Struct to save the baudrate of I2C
*/

struct I2Cbr{

	uint16_t brh;
	uint16_t brl;

}I2CBaudrate = {0};

uint8_t i;

/*
Function Start
*/

void I2C_start(void){

	LPC_I2C->CONCLR =0xFF;
	LPC_I2C->CONSET |= (1<<5)+(1<<6);
	while(!(LPC_I2C->CONSET & (1<<3)));

}

/*
Function SendByte
*/
uint8_t I2C_write(uint8_t _d){
	
	uint8_t stat=0;
	
	LPC_I2C->DAT = _d;
	LPC_I2C->CONCLR = (1<<5)+(1<<3);
	LPC_I2C->CONSET = (1<<6);
	while(!(LPC_I2C->CONSET & (1<<3)));
	stat = LPC_I2C->STAT;
		
	if(stat ==0x18 || stat==0x08 || stat==0x28 || stat==0x40){

		return 1;

	}else{

		return 0;

	}

}

/*
Function Stop
*/

void I2C_stop(void){

	
	LPC_I2C->CONSET |= (1<<4);
	while(!(LPC_I2C->CONSET & (1<<3)));
	LPC_I2C->CONCLR = 0xFF;
}

/*
Function restart
*/

void I2C_restart(void){

	LPC_I2C->CONCLR |= (1<<3);
	LPC_I2C->CONSET |= (1<<5) + (1<<6);
	while(!(LPC_I2C->CONSET & (1<<3)));
}

/*
Function No Ack
*/

uint8_t I2C_recieve(){

	uint8_t stat=0;
	uint8_t I2C_data=0;
	
	LPC_I2C->CONCLR =(1<<2)+(1<<3);
	while(!(LPC_I2C->CONSET & (1<<3)));
	
	stat=LPC_I2C->STAT;
	I2C_data= (uint8_t)LPC_I2C->DAT;
	
	if(stat ==0x58)
		return I2C_data;
	else
		return 0;

}


/*
Function to Set the I2C module
*/

void SetI2Cto(void){
	
	LPC_SYSCON->PRESETCTRL |= (1<<1);
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<5);
	LPC_SYSCON->SYSAHBCLKCTRL |= (1<<16);
	LPC_IOCON->PIO0_4 &= ~0x3F;
	LPC_IOCON->PIO0_4 |= 0x01;
	LPC_IOCON->PIO0_5 &= ~0x3F;
	LPC_IOCON->PIO0_5 |= 0x01;
	LPC_SYSCON->SYSAHBCLKCTRL &= ~(1<<16);
	
	I2CBaudrate.brh = (uint16_t)(48000000/I2CFrequency)/3;
	I2CBaudrate.brl	= (uint16_t)(48000000/I2CFrequency) - I2CBaudrate.brh;

	LPC_I2C->SCLH = I2CBaudrate.brh;
	LPC_I2C->SCLL = I2CBaudrate.brl;

}

uint8_t FM24CLXX_write(uint8_t adr,uint8_t data){
	
	uint8_t	I2C_flag=1;

	I2C_start();
	if(!I2C_write(WRITE_PAGE))
		I2C_flag=0;
	if(!I2C_write(adr))
		I2C_flag=0;
	if(!I2C_write(data))
		I2C_flag=0;
	I2C_stop();

	return I2C_flag;

}

uint8_t FM24CLXX_read(uint8_t adr){

	uint8_t I2C_flag=1;
	uint8_t I2C_rdata=0;
	
	I2C_start();
	if(!I2C_write(WRITE_PAGE))
		I2C_flag=0;
	if(!I2C_write(adr))
		I2C_flag=0;
	I2C_restart();
	if(!I2C_write(READ_PAGE))
		I2C_flag=0;
	I2C_rdata= I2C_recieve();
	I2C_stop();
	
	if(!I2C_flag)
		return 0;
	else
		return I2C_rdata;

}




int main(void){
	
	SetClockTo48Mhz();
	SetUartTo(38400);
	SetI2Cto();

	printf("[DEBUG I2C] -> Init\r\n");
	while(1){

		for(i=0;i<5;i++){

			if(!FM24CLXX_write(i,i*2)){

				printf("[DEBUG I2C] -> Fail\r\n");
				while(1);
			}
				

		}
		
		for(i=0;i<5;i++){

			printf("%u\r\n",FM24CLXX_read(i));
			delay_ms(1000);
		}
		
	}
	
}
Saludos!
08/04/2014 #23

Avatar de george.manson.69

ARM Cortex: SPI & at45db
Hola a Todos,

Les comparto el código necesario para la configuración del SPI tomando como ejemplo el
AT45DBXX, usando el microcontrolador de NXP el LPC1114/302.

Baje Aqui

¿Que es el AT45DB?



El AT45DB041D es un memoria flash con interfaz serial ideal para un gran rango de almacenamiento de datos tanto como voz, imágenes código de programa.

Codigo para leer y escribir:

Código:
uint8_t AT45DBXX_read(uint8_t adr_){
	
	uint8_t rdata;

	ActiveSSP0;
	rdata=SPI_Transmit(0xD4);
	rdata=SPI_Transmit(0xff);
	rdata=SPI_Transmit((uint8_t)(adr_>>8));
	rdata=SPI_Transmit((uint8_t)adr_);
	rdata=SPI_Transmit(0xff);
	rdata=SPI_Transmit(0xff);
	DesActiveSSP0;

	return rdata;

}
Código:
uint8_t AT45DBXX_write(uint8_t adr_,uint8_t data_){

	uint8_t rdata;
	
	ActiveSSP0;
	rdata=SPI_Transmit(0x84);
	rdata=SPI_Transmit(0xff);
	rdata=SPI_Transmit((uint8_t)(adr_>>8));
	rdata=SPI_Transmit((uint8_t)adr_);
	rdata=SPI_Transmit(data_);
	DesActiveSSP0;
	
	return rdata;
	
	
}
Saludos!
19/04/2014 #24

Avatar de george.manson.69

ARM Cortex: LSM303D
Hola,

Les comparto el codigo para usar el acelerometro y magnetrometro de pololu el LSM303D, usando el microcontrolador LPC1114/302 de NXP.

¿Que es el LSM303D?

El LSM303DLHC tiene una aceleración linear de varias escalas como ±2 g,±4g, ±8 g, ±16g,
Y un campo magnético de varias escalas de ±1.3, ±1.9, ±2.5, ±4.0, ±4.7, ±5.6, ±8.1 gaus,
Todas las escalas están disponibles para el usuario.




Código:
#include 	<lpc11xx.h>
#include	<math.h>
#include 	"SetClock48Mhz.h"
#include	"SetUart.h"
#include	"TickTimer.h"
#include 	"I2C.h"

/*address Accelerometer and Magnetic*/

#define	ACCEL_ADR_WRITE	0x32
#define	ACCEL_ADR_READ	0x33
#define	MAG_ADR_WRITE		0x3C
#define MAG_ADR_READ		0x3D

/*---------Register address map*/

/*Accel*/

#define CTRL_REG1_A	0x20
#define CTRL_REG2_A	0x21
#define CTRL_REG3_A	0x22
#define CTRL_REG4_A	0x23
#define CTRL_REG5_A	0x24
#define CTRL_REG6_A	0x25
#define	REFERENCE_A	0x26
#define	STATUS_REG_A	0x27
#define	FIFO_CTRL_REG_A	0x2E
#define	INT1_CFG_A	0x30
#define	INT1_THS_A	0x32
#define	INT1_DURATION_A	0x33
#define	INT2_CFG_A	0x34
#define	INT2_THS_A	0x36
#define	INT2_DURATION_A	0x37
#define	CLICK_CFG_A	0x38
#define	CLICK_SRC_A	0x39
#define	CLICK_THS_A	0x3A
#define	TIME_LIMIT_A	0x3B
#define	TIME_LATENCY_A	0x3C
#define	TIME_WINDOW_A	0x3D


#define	OUT_X_L_A	0x28
#define	OUT_X_H_A	0x29
#define	OUT_Y_L_A	0x2A
#define	OUT_Y_H_A	0x2B
#define	OUT_Z_L_A	0x2C
#define	OUT_Z_H_A	0x2D

/*Magno*/

#define	CRA_REG_M	0x00
#define	CRB_REG_M	0x01
#define	MR_REG_M	0X02

#define	OUT_X_H_M	0x03
#define	OUT_X_L_M	0x04
#define	OUT_Z_H_M	0x05
#define	OUT_Z_L_M	0x06
#define	OUT_Y_H_M	0x07
#define	OUT_Y_L_M	0x08

#define PI	3.141592654



typedef struct axes{

	int16_t	X;
	int16_t	Y;
	int16_t	Z;

}axes;

axes a;
axes m;

float	aX;
float	aY;
float	aZ;
float	mX;
float	mY;
float	mZ;


void _delay_ms(uint8_t t){

	while(t--){

		delay_ms(250);

	}

}

int8_t	LSM303DLHC_Read_mag(){

	int8_t	I2C_flag=-1;
	uint8_t temp[6]={0,0,0,0,0,0};
	uint8_t _i_;

	for(_i_=0;_i_<6;_i_++){
		I2C_start();
		if(!I2C_write(MAG_ADR_WRITE))
			I2C_flag=-2;
		
		if(!I2C_write(OUT_X_H_M+_i_))
			I2C_flag=-2;

		I2C_restart();
		
		if(!I2C_write(MAG_ADR_READ))
			I2C_flag=-2;
		
		temp[_i_] = I2C_recieve();
		
		I2C_stop();
	}
	
	m.X = (int16_t)((temp[0]<<8)+temp[1]);
	m.Y = (int16_t)((temp[4]<<8)+temp[5]);
	m.Z = (int16_t)((temp[2]<<8)+temp[3]);
	return I2C_flag;

}

int8_t	LSM303DLHC_Read_accel(){

	int8_t	I2C_flag=-1;
	uint8_t temp[6]={0,0,0,0,0,0};
	uint8_t _i_;

	for(_i_=0;_i_<6;_i_++){

		I2C_start();
		if(!I2C_write(ACCEL_ADR_WRITE))
			I2C_flag=-2;

		if(!I2C_write(OUT_X_L_A+_i_))
			I2C_flag=-2;

		I2C_restart();
		if(!I2C_write(ACCEL_ADR_READ))
			I2C_flag=-2;

		temp[_i_]=I2C_recieve();

		I2C_stop();

	}
	
	a.X = (int16_t)((temp[1]<<8)+temp[0])>>4;
	a.Y = (int16_t)((temp[3]<<8)+temp[2])>>4;
	a.Z = (int16_t)((temp[5]<<8)+temp[4])>>4;
	
	return I2C_flag;

}

int8_t	LSM303DLHC_reader(){

	int8_t	I2C_flag=-1;

	if(LSM303DLHC_Read_accel()!=-1)
		I2C_flag=-2;
	if(LSM303DLHC_Read_mag()!=-1)
		I2C_flag=-2;
	

	return I2C_flag;

}


int8_t LSM303DLHC_write(uint8_t _type_,uint8_t _adr_,uint8_t _data_){

	int8_t	I2C_flag=-1;
	
	I2C_start();
	if(!I2C_write(_type_))
		I2C_flag=-2;
	if(!I2C_write(_adr_))
		I2C_flag=-2;
	if(!I2C_write(_data_))
		I2C_flag=-2;
	I2C_stop();
	
	return I2C_flag;

}


/*

Function to Init LSM303DLHC

*/

int8_t	LSM303DLHC_init(){
	
	uint8_t value_config=0;
	int8_t	flag_=-1;

	/*Init Accel*/
	value_config |= (1<<5);
	value_config |= 0x07;
	if(LSM303DLHC_write(ACCEL_ADR_WRITE,CTRL_REG1_A,value_config)!=-1)
		flag_=-2;
	
	delay_ms(10);
	
	value_config=0;
	//value_config|=(1<<6);
	value_config|=(1<<3);
	if(LSM303DLHC_write(ACCEL_ADR_WRITE,CTRL_REG4_A,value_config)!=-1)
		flag_=-2;
	
	delay_ms(10);
	
	/*Init Mag*/
	value_config=0;
	value_config|=(4<<2);
	if(LSM303DLHC_write(MAG_ADR_WRITE,CRA_REG_M,value_config)!=-1)
		flag_=-2;
	
	delay_ms(10);
	
	value_config=0;
	value_config|=(1<<5);
	if(LSM303DLHC_write(MAG_ADR_WRITE,CRB_REG_M,value_config)!=-1)
		flag_=-2;
	
	delay_ms(10);
	
	value_config=0;
	if(LSM303DLHC_write(MAG_ADR_WRITE,MR_REG_M,value_config)!=-1)
		flag_=-2;
	
	return flag_;

}


/*

Function to get heading Mag

*/

float LSM303DLHC_getHeading(axes mv){

	float heading = 180*atan2(mv.Y,mv.X)/PI;
	
	if(heading<0)
		heading +=360;
	
	return heading;

}

/*

Function to get Tilt heading Accel + Mag

*/


float LSM303DLHC_getTiltHeading(axes va,axes vm){

	double pitch = 0;
	double roll = 0;
	double xh=0;
	double yh=0;
	//double zh=0;
	double heading =0;
	
	double vax = 0;
	double vay = 0;

	
	aX=(double)va.X;
	aY=(double)va.Y;
	aZ=(double)va.Z;
	
	mX=(double)vm.X;
	mY=(double)vm.Y;
	mZ=(double)vm.Z;
	
	vax = (double)(aX/sqrt(aX*aX+aY*aY+aZ*aZ));
	vay	= (double)(aY/sqrt(aX*aX+aY*aY+aZ*aZ));

	pitch = -asin(vax);
	roll = asin(vay/cos(pitch));
	xh=mX*cos(pitch)+mZ*sin(pitch);
	yh=mX*sin(roll)*sin(pitch)+mY*cos(roll)-mZ*sin(roll)*cos(pitch);

	heading = 180*atan2(yh,xh)/PI;
	
	if(yh>=0)
		return (float)heading;
	else
		return (float)(360 + heading);

}


/*

Main Function

*/

int main(void){
	
	int8_t result=0;

	SetClockTo48Mhz();
	SetUartTo(115200);
	SetI2Cto();
	
	result=LSM303DLHC_init();
	
	printf("AX\tAY\tAZ\tMX\tMY\tMZ\r\n");
	
	
	while(1){
		
		result=LSM303DLHC_reader();

		if(result==-1){
		
				printf("%i\t%i\t%i\t%i\t%i\t%i\r\n",a.X,a.Y,a.Z,m.X,m.Y,m.Z);
				printf("MHeading = %0.3f\r\n",LSM303DLHC_getHeading(m));
				printf("TiltHeading = %0.3f\r\n",LSM303DLHC_getTiltHeading(a,m));
		}
			
		_delay_ms(1);

	}
	
}
Imágenes Adjuntas
Tipo de Archivo: jpg sch.jpg (32,4 KB (Kilobytes), 9 visitas)
01/05/2014 #25

Avatar de george.manson.69

ARM Cortex: Xbee
Hola a Todos,


En este tema vamos haber como configurar dos XBEE y tener una comunicación inalambrica, aunque esto ya lleva varios años en la industria comercial, por ahora yo jamas me había metido en lo que es la comunicación entre XBEE, ahora que empiezo a entender el protocolo les comparto a ustedes lo que llevo entendido.



¿Qué es el Xbee?

El modem de RF Xbee es un transceptor wireless, el Xbee usa un implantación de protocolo completo para la Comunicación de datos que provee características necesarias para una comunicación de red robusta en una red de sensor Inalámbrica (WSN).

Red de punto a Múltiples puntos

En una red simple como se muestra a continuación , todo el trafico es manejado por el nodo central ( Master, base o Coordinador) que tiene la dirección del nodo remoto, enviar datos a ese nodo, y los datos desde el nodo remoto es devuelto al nodo base.





Video:

https://www.youtube.com/watch?featur...&v=uiE4RDMVQCE

Codigo:

Código:
#include	<lpc11xx.h>
#include	"SetClock48Mhz.h"
#include	"TickTimer.h"
#include	"SetUart.h"
 
 
void _delay_s(uint8_t t){
 
	while(--t)
		delay_ms(250);
 
}
 
 
 
int main(void){
 
	SetClockTo48Mhz();
	SetUartTo(9600);
	
	
	_delay_s(4);
	
	while(1){
 
		printf("Hola Mundo\r\n");
		_delay_s(4);
 
	}
 
 
}
Saludos!
13/05/2014 #26

Avatar de george.manson.69

ARM Cortex M3: Inicializacion
Hola,


En este nuevo post, vamos a ver una pequeña instroduccion a la programacion de los microcotroladores LPC1768 que usa como procesador el ARM CORTEX M3.

El kit de desarrollo se usara el que nos proporciona Waveshare, (http://www.wvshare.com/), que tiene las siguientes características:




LPC1768FBD100: the high performance ARM Cortex-M3 LPC MCU which features:
Core: Cortex-M3 32-bit RISC
Operating Frequency: 100MHz Max
Operating Voltage: 2.4-3.6V (3.3V typical)
Package: LQFP100
I/Os: 70
Memories: 512kB Flash, 64kB RAM
Communication Interfaces: 2 x SPI, 2 x SSP, 4 x UART, 3 x I2C, 1 x I2S, 6 x PWM, 8 x ADC, 1 x DAC
Debugging/Programming: supports SWD interfaces, supports ISP through UART
AMS1117-3.3: 3.3V voltage regulator
LM3526-L: USB power switch and over-current protection
Power switch
Power indicator
LEDs: convenient for indicating I/O status and/or program running state
USB communication indicator
Reset button
User keys: for I/O input test and/or program control
Joystick: five positions
12M crystal oscillator: enables the MCU run at 48M frequency by frequency multiplication
32.768K crystal oscillator: for internal RTC, also supports clock calibration
USB HOST port: for connecting USB flash drive, etc.
CAN2 interface: communicates with accessory boards which feature the CAN device conveniently
CAN1 interface: communicates with accessory boards which feature the CAN device conveniently
I2C0 interface: easily connects to I2C peripherals such as I/O expander (PCF8574), EEPROM (AT24Cxx), etc.
SPI0 | SPI1 interface: for connecting SPI peripherals, such as DataFlash (AT45DBxx), SD card, MP3, etc.
Ethernet interface: easily connects the MCU to ethernet network by using an additional ethernet module, such as DP83848 Ethernet Board, etc.
ONE-WIRE interface: easily connects to ONE-WIRE devices (TO-92 package), such as temperature sensor (DS18B20), electronic registration number (DS2401), etc.
I2S interface (including I2C1, I2C2 interfaces): easily connects to I2S and/or I2C peripherals such as Stereo Audio Device (UDA1380), FRAM (FM24CLxx), etc.
LCD interface: combined with an 8-bit to 16-bit adapter, supports connecting the 3.2 inch multi-color touch screen LCD (the adapter and LCD are included in Package A/B)
UART2 | UART3 interface: for connecting UART peripherals, such as RS232, RS485, USB TO UART, etc.
PS/2 interface: easily connects to PS/2 keyboard and/or mouse
Modem interface (including UART1 interface): for connecting Modem and/or UART peripherals, such as RS232, RS485, USB TO UART, etc.
8 I/Os interface (including 3-ch AD, 1-ch DA)
for connecting accessory boards which using I/O control, such as 8 Push Buttons, Motor, etc.
also integrates AD/DA function for AD/DA testing
ISP interface (including UART0 interface): for connecting ISP modules and/or UART peripherals, such as RS232, RS485, USB TO UART, etc.
USB port: communicating with PC
5V DC jack
5V/3.3V power input/output: usually used for power output, and/or common ground with other application board
MCU pins connector: all the MCU pins are accessible on expansion connectors for further expansion
JTAG/SWD interface: for debugging/programming
LEDs jumper
User keys jumper
Joystick jumper
PS/2 jumper

Configurando el Oscilador a 100Mhz.

Para iniciar con la aventura de este gran microcontrolador, configuraremos lo que es el oscilador de trabajo para que opere a 100Mhz.



Como vemos en la imagen de arriba es el block de generador de Reloj de los LPC17xx, para poderlo configurar hay que irnos por pasos.
Existe un registro que nos permite escojer 3 tipos de osciladores como son:

Oscilador Interno
Oscilador Principal
Oscilador RTC

En los siguientes tutoriales vamos a trabajar con el Oscilador principal, este oscilador puede operar en un rango de 1 Mhz a 25 Mhz, pero este se puede multiplicar con la ayuda de un PLL0 y alcanzar una frecuencia maxima del microcontrolador (100Mhz).

Si hemos de trabajar con el Oscilador principal, entonces el primer registro que hay que configurar es el:
Registro SCS (System Controls and Status) y configurarlo de la siguiente Forma:

Código:
	LPC_SC->SCS = (1<<5);          // Run with a External Crystal
	while(!(LPC_SC->SCS & (1<<6)));//External Crystal is ready?
Como hemos entrada ya con el oscilador externo que consta de un cristal de 12 Mhz, ahora hay que configurar el block del PLL0, esto se llega usando el registro CLKSRCSEL, junto con el divisor de CCO.

Código:
	LPC_SC->CCLKCFG = (1<<3);			 // FCCO / 4
	LPC_SC->CLKSRCSEL = (1<<0);		 // PLL0 selected
El registro CCLKCFG nos permite dividir la frecuencia de salida del PLL0, por ejemplo, si la salida del PLL0 es 400 Mhz y seleccionamos un divisor de 4 entonces la salida hacia el CPU y los periféricos sera de 100Mhz.

El siguiente código es la configuración del PLL0 para alcanzar una frecuencia de 400 Mhz, esta frecuencia que queremos debe estar al rango con respecto el fabricante nos diga, el rango es de 275 Mhz

Código:
	// M = (FCCO*N)/(2xFin)
	// Where :
	// N = 6
	// FCC0 = 400 , in range  275 < 400 < 550 Mhz
	// Fin = 12Mhz
	// M = (400Mhz*6)/(2x12Mhz) = 100
	LPC_SC->PLL0CFG = 0x00050063;		
	LPC_SC->PLL0FEED  = 0xAA;				//Sequence to take effect
        LPC_SC->PLL0FEED  = 0x55;				//Sequence to take effect
	
	LPC_SC->PLL0CON	= (1<<0);				//PLL enable
	LPC_SC->PLL0FEED  = 0xAA;				//Sequence to take effect
        LPC_SC->PLL0FEED  = 0x55;				//Sequence to take effect	
	while (!(LPC_SC->PLL0STAT & (1<<26))); //is Lock freq?
	
	LPC_SC->PLL0CON	= (1<<0) + (1<<1); //PLL enable and Connect
	LPC_SC->PLL0FEED  = 0xAA;				//Sequence to take effect
        LPC_SC->PLL0FEED  = 0x55;				//Sequence to take effect		
	while (!(LPC_SC->PLL0STAT & ((1<<26)|(1<<24)))); //is Lock freq?
	
	
	LPC_SC->USBCLKCFG = 0; //USB shutdown
	LPC_SC->CLKOUTCFG = 0; //CLKOUT by  CPU Clock

Pero para obtener esta frecuencia se debe de insertar ciertas variables en unos registros para alcanzar una frecuencia de 400 Mhz con un cristal de 12 Mhz, la formula es:

M = (FCCOxN) / (2 x Fin)

Donde:

M = PLL0 Valor Multiplicador
N = PLL0 Pre-divisor
Fin = Frecuencia de entrada.

Entonces los valores de M y N al obtenerlos se debe de guardar en el registro PLL0CFG.
En el caso de querer una frecuencia de 100Mhz usando 12Mhz, entonces para sacar el valor de M y N, se hace lo siguiente:

M = (400Mhz x 6 ) / (2x12Mhz) = 100

El numero 6 que pertenece a la variable N, lo obtuve buscando un numero entero como resultado y que si lo multiplicamos por 5 tendremos un resultado tipo float (83.333), siempre hay que buscar un numero entero.

Entonces M = 100 y N = 6, entonces el registro quedaria de la siguiente manera:

LPC_SC->PLL0CFG = 0x00050063;
LPC_SC->PLL0FEED = 0xAA; //Sequence to take effect

LPC_SC->PLL0FEED = 0x55; //Sequence to take effect

Como ven he usado un registro llamado PLL0FEED que nos permite mandar una secuencia de bytes para guardar el cambio del registro PLL0CFG.

Los últimos detalles es habilitar el PLL0 y esperar hasta que la frecuencia alcance la frecuencia deseada, el registro para habilitar el PLL0 es PLL0CON y después se manda la secuencia para grabar los cambios.

Nuevamente habilitamos el PLL0 y el bit de Connect para llegara ser el oscilador principal del CPU.
Volviendo al principio con el registro CCLKCFG hemos visto que se ha configurado a un valor de 3 que es definido como divisor de FCC0 por 4, entonces como el PLL0 que hemos obtenido en la formula anterior, cuando esta frecuencia pase por el block divisor nuestra salida sera 400Mhz / 4 = 100 Mhz

Configurando el SysTick

Como sabemos en los Microcontroladores que usan la tecnología Arm como procesador, contiene un block de SysTick que nos provee una temporizacion estandar.
Para la configuracion de este modulo solo hay que usar la siguiente función:

Código:
void SysTick_Handler(void)					  
{
	timer_tick++;
}
 
void delay_ms(uint32_t ms){
 
	
 
	SysTick->LOAD = ((100000*ms)-1);
	SysTick->CTRL |=(1<<0)+(1<<1)+(1<<2);
	
	SysTick->VAL = 0;
	
	while(!timer_tick);
	timer_tick=0;
	SysTick->CTRL =0;
 
}
El primero registro LOAD hemos de cargar un valor de un máximo de 24 bits, al cargar un valor que en ese caso hemos puesto ((100000*ms)-1), si la variable ms es 1 , entonces tendremos como resultado 99,999 ¿Que quiere decir esto? que al contar 99,999 ticks del oscilador (en este caso del oscilador principal) igual a 1 milisegundo obtendremos un evento que puede ser una interrupcion.

Codigo de Ejemplo usando la configuracon del Oscilador Externo + PLL0 y sistemas de retardos con SysTick.

Código:
uint32_t timer_tick;
 
void SetClockto100Mhz(void){
 
	LPC_SC->SCS = (1<<5);          // Run with a External Crystal
	while(!(LPC_SC->SCS & (1<<6)));//External Crystal is ready?
	
	LPC_SC->CCLKCFG = (1<<3);			 // FCCO / 4
	LPC_SC->CLKSRCSEL = (1<<0);		 // PLL0 selected
	
	
	// M = (FCCO*N)/(2xFin)
	// Where :
	// N = 6
	// FCC0 = 400 , in range  275 < 400 < 550 Mhz
	// Fin = 12Mhz
	// M = (400Mhz*6)/(2x12Mhz) = 100
	LPC_SC->PLL0CFG = 0x00050063;		
	LPC_SC->PLL0FEED  = 0xAA;				//Sequence to take effect
  	LPC_SC->PLL0FEED  = 0x55;				//Sequence to take effect
	
	LPC_SC->PLL0CON	= (1<<0);				//PLL enable
	LPC_SC->PLL0FEED  = 0xAA;				//Sequence to take effect
  	LPC_SC->PLL0FEED  = 0x55;				//Sequence to take effect	
	while (!(LPC_SC->PLL0STAT & (1<<26))); //is Lock freq?
	
	LPC_SC->PLL0CON	= (1<<0) + (1<<1); //PLL enable and Connect
	LPC_SC->PLL0FEED  = 0xAA;				//Sequence to take effect
  	LPC_SC->PLL0FEED  = 0x55;				//Sequence to take effect		
	while (!(LPC_SC->PLL0STAT & ((1<<26)|(1<<24)))); //is Lock freq?
	
	
	LPC_SC->USBCLKCFG = 0; //USB shutdown
	LPC_SC->CLKOUTCFG = 0; //CLKOUT by  CPU Clock
 
}
 
void SysTick_Handler(void)					  
{
	timer_tick++;
}
 
void delay_ms(uint32_t ms){
 
	
 
	SysTick->LOAD = ((100000*ms)-1);
	SysTick->CTRL |=(1<<0)+(1<<1)+(1<<2);
	
	SysTick->VAL = 0;
	
	while(!timer_tick);
	timer_tick=0;
	SysTick->CTRL =0;
 
}
 
void delay_us(uint32_t us){
 
	
 
	SysTick->LOAD = ((100*us)-1);
	SysTick->CTRL |=(1<<0)+(1<<1)+(1<<2);
	
	SysTick->VAL = 0;
	
	while(!timer_tick);
	timer_tick=0;
	SysTick->CTRL =0;
 
}
 
 
int main(void){
	
	SetClockto100Mhz();
	
	LPC_GPIO0->FIODIR0 |= (1<<3);
	LPC_GPIO0->FIODIR0 |= (1<<2);
	LPC_GPIO0->FIODIR0 |= (1<<1);
	LPC_GPIO0->FIODIR0 |= (1<<0);
 
	while(1){
 
		LPC_GPIO0->FIOSET0 |= (1<<3);
		LPC_GPIO0->FIOSET0 |= (1<<2);
		LPC_GPIO0->FIOSET0 |= (1<<1);
		LPC_GPIO0->FIOSET0 |= (1<<0);
		delay_ms(250);
		
		LPC_GPIO0->FIOCLR0 |= (1<<3);
		LPC_GPIO0->FIOCLR0 |= (1<<2);
		LPC_GPIO0->FIOCLR0 |= (1<<1);
		LPC_GPIO0->FIOCLR0 |= (1<<0);
		delay_ms(250);
 
 
	}
 
}
Saludos!
27/05/2014 #27

Avatar de george.manson.69

ARM Cortex M3: UltraSonico
Hola,

Les comparto el funcionamiento y la configuración del sensor ultrasonico usando el Microcontrolador LPC1768 de NXP.





https://www.youtube.com/watch?featur...&v=G4dKUhwTbcs

Codigo:

Código:
#include	<lpc17xx.h>
#include	<stdio.h>
#include	"SetOscto100Mhz.h"
#include	"SysTickTimer.h"
#include	"SetUartX.h"


char str[25];


void SetTimerX(uint8_t timer){

	if(timer==1){

		LPC_SC->PCON |= (1<<1);		//Enable bit 1, Timer0
		LPC_SC->PCLKSEL0 &=~((1<<3)+(1<<2));	//PCLK/4, 100Mhz/4 = 25Mhz
		
		LPC_TIM0->TCR = 0X02;			//Disable Counter
		LPC_TIM0->PR  = 25;				//25*(1/25Mhz) = 1e-6s
		LPC_TIM0->TCR = 0X01;			//Enable Counter
	}

}

void SetDigitalIO(void){

	LPC_GPIO2->FIODIR1 |=(1<<4);	//Port 2.12 OUTPUT
	LPC_GPIO2->FIODIR1 &=~(1<<3); //Port 2.11 INPUT
	LPC_PINCON->PINMODE4 |= (1<<23)+(1<<22); //Pull-down Port 2.11
}


void delay(uint32_t t){

	while(t--){
		delay_ms(1);
	}

}

void clear_buffer(void){
	uint8_t c;
	
	for(c=0;c<sizeof(str);c++){

		str[c]=0x00;

	}
}


float Get_Distance_HC_SRC4(){

		uint32_t time=0;
		float cm=0.0;
		
		LPC_TIM0->TCR = 0X02;					//Disable Counter
		

		LPC_GPIO2->FIOSET1 |= (1<<4);	//High output pin2.12
		delay_us(10);
		LPC_GPIO2->FIOCLR1 |= (1<<4);	//Low output pin2.12
		
		while(!(LPC_GPIO2->FIOPIN1 & (1<<3))); //While the Pin2.11 is low
		LPC_TIM0->TCR = 0X01;									 //Enable Counter
		while((LPC_GPIO2->FIOPIN1 & (1<<3)));  //While the Pin2.11 is high
		time=LPC_TIM0->TC;
		LPC_TIM0->TCR = 0X02;									 //Disable Counter

		cm=((time*1e-6)*343)+(((time*1e-6)*343)*.24);
		return cm;
	
}

int main(void){
	
	SetClockto100Mhz();
	SetUartX(2,115200);
	SetTimerX(1);

	SetDigitalIO();
	
	while(1){
		
		sprintf(str,"Distance = %0.3fm\r",Get_Distance_HC_SRC4());
		UART1_send_string_ram(str);
		clear_buffer();
		delay(1000);
		
	}
}
Saludos!
Archivos Adjuntos
Tipo de Archivo: pdf UCURSOS 2.1.pdf (256,4 KB (Kilobytes), 21 visitas)
09/06/2014 #28

Avatar de george.manson.69

ARM Cortex M3: GPS Ublox
Hola a Todos,

En este post vamos a conocer como usar el modulo GPS de la marca Ublox LEA 6.



¿Qué es un GPS?

El Sistema de Posicionamiento Global permite determinar en todo el mundo posición de un objeto, una persona o un vehículo con una precisión hasta de centímetros, aunque lo habitual son unos pocos metros de precisión.
El sistema fue desarrollado, instalado y empleado por el
Departamento de Defensa de los Estados Unidos.

El sistema GPS está constituido por 24 satélites y utiliza la triangulación para determinar en todo el globo la posición con una precisión de más o menos metros.



Modulo Ublox LEA-6S-0-001
El modulo LEA-6 es un receptor de GPS independiente con un alto
Núcleo de Rendimiento de posición, es compacto, fácil de integrar a otros módulos, alta flexibilidad de energía, diseño y opciones de conectividad.



Tipos de Protocolo
El modulo Ublox LEA-6 se puede usar dos tipos de protocolo:
NMEA: Los mensajes de este tipo son enviados por el GPS que están basados en NMEA 0183 Versión 2.3.
Las Características de mensaje es la siguiente:



UBX: Es un protocolo para transmitir datos del GPS al host de la computadora, utilizando el protocolo UART.



http://www.mediafire.com/view/69gjib...CURSOS_2.2.pdf

Código:
///////////////////////////////////////////////////////////
/*
*//**
*@file	Main.c
*@brief Utilizando una interrupcion por recepecion de datos via Uart
*				se adquiere los datos NMEA del modulo GPS de ublox.
*				Despues pasa por una etapa de decodficiacion
*				para obtener la longitud y latitud.
*@Version	1.0
*@date	05/28/2014
*@author ucursos
*/
///////////////////////////////////////////////////////////

/*
Librerias incluidas
*/

#include  <lpc17xx.h>
#include  <math.h>
#include	<string.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	"SetOscto100Mhz.h"
#include	"SetUartX.h"
#include	"SysTickTimer.h"

/*---------------------------------*/

/*
Definicion de variables
*/

char data[100];
uint8_t intrda=0;

const char CommandsUblox[6][11]={{0xB5,0x62,0x06,0x01,0x03,0x00,0xF0,0x05,0x00,0xFF,0x19}, //CFG-MSG VTG OFF
																 {0xB5,0x62,0x06,0x01,0x03,0x00,0xF0,0x03,0x00,0xFD,0x15}, //CFG-MSG GSV OFF
																 {0xB5,0x62,0x06,0x01,0x03,0x00,0xF0,0x04,0x00,0xFE,0x17}, //CFG-MSG RMC OFF
																 {0xB5,0x62,0x06,0x01,0x03,0x00,0xF0,0x00,0x0F,0x09,0x1E}, //CFG-MSG GGA 15seg
																 {0xB5,0x62,0x06,0x01,0x03,0x00,0xF0,0x02,0x00,0xFC,0x13}, //CFG-MSG GSA OFF
																 {0xB5,0x62,0x06,0x01,0x03,0x00,0xF0,0x01,0x00,0xFB,0x11}};//CFG-MSG GLL OFF
																 
const char NMEAdata[1][7]={"$GPGGA,"};
uint8_t v_;

enum{NMEATYPE=0,UTCTIME,LAT,DIRLAT,LONG,DIRLONG,PFIX,SAT,HDOP,ALT,UA,GID,UG};

struct{

	char NMEAMessage[7];
	char UTCTime[10];
	float Latitude;
	char DirLat;
	float Longitude;
	char DirLong;
	uint8_t PFix;
	uint8_t Satellites;
	float HDOP;
	float Altitude;
	char uA;
	float GeoId;
	char uGeo;
	
}UbloxPacket;
																
/*---------------------------------*/


/*********************************************************************//**
 * @brief		Interrupcion por recepcion de datos en UART0
 * @param[in]	None
 * @return 		None
 **********************************************************************/

void UART0_IRQHandler(void){

	if((LPC_UART0->IIR&0x04)==0x04){
		
		UARTX_get_string_ram(1,data);
		intrda=1;
		
	}
}


/*********************************************************************//**
 * @brief		Funcion de Retardo
 * @param[in]	t: Variable de tiempo
 * @return 		None
 **********************************************************************/

void clear_buffer(char *bf){
	uint8_t c;
	for(c=0;c<sizeof(NMEAdata);c++){

		(*bf++)=0x00;

	}
	
}

/*********************************************************************//**
 * @brief		Funcion de Retardo
 * @param[in]	t: Variable de tiempo
 * @return 		None
 **********************************************************************/

void delay(int t){

	while(--t){
		delay_ms(1);
	}
}

/*********************************************************************//**
 * @brief		Funcion que envia datos al GPS Ublox 
 * @param[in]	*data: Puntero donde localiza el arreglo de datos del NMEA de Ublox
 * @return 		None
 **********************************************************************/

void UbloxSendData(char *data){

	uint8_t c=0;
	
	for(c=0;c<11;c++){
		UART0_putc((char)data[c]);
	}
	
	for(c=0;c<11;c++){
		
		UART1_putc((char)data[c]);
	}
	UART1_putc('\r');
}

/*********************************************************************//**
 * @brief		Funcion que envia datos al GPS Ublox 
 * @param[in]	*data: Puntero donde localiza el arreglo de datos del NMEA de Ublox
 * @return 		None
 **********************************************************************/

void UbloxInit(void){

	uint8_t c=0;
	
	delay(500);
	
	for(c=0;c<6;c++){

		UbloxSendData((char*)CommandsUblox[c]);
		delay(500);

	}

}

/*********************************************************************//**
 * @brief		Funcion para Eliminar un rango de una cadena de caracteres
 * @param[in]	*str: Puntero donde localiza el arreglo de datos del NMEA de Ublox
 * @param[in]	*p1: Punto hasta donde se quiere eliminar la cadena de caracteres
 * @return 		None
 **********************************************************************/

char* GetString(char *ptr2,char *str,uint8_t p1){

	v_=0;
	do{

		(*ptr2++)=(*str);
		v_++;
	}while((*str++)!=',');
	
	return str;
}

/*********************************************************************//**
 * @brief		Funcion para decodificar los datos de NMEA
 * @param[in]	*data: Puntero donde localiza el arreglo de datos del NMEA de Ublox
 * @return 		None
 **********************************************************************/

void 	UbloxDecodeNMEA(char *decoNMEA){
	
	uint8_t x;
	char buffer_aux[12]={0,0,0,0,0,0,0,0,0,0,0,0};
	
	//GGA Message
	if(!strncmp(decoNMEA,NMEAdata[0],sizeof(NMEAdata[0]))){
		
		for(x=0;x<13;x++){
			
			decoNMEA=GetString(buffer_aux,decoNMEA,sizeof(buffer_aux));
			buffer_aux[v_]='\n';
			switch(x){

				case NMEATYPE:
					strncpy(UbloxPacket.NMEAMessage,buffer_aux,sizeof(UbloxPacket.NMEAMessage));
					break;
				
				case UTCTIME:
					strncpy(UbloxPacket.UTCTime,buffer_aux,sizeof(UbloxPacket.UTCTime));
					break;
				
				case LAT:
					if(buffer_aux[0]!=','){
						UbloxPacket.Latitude=atof(buffer_aux);
						UbloxPacket.Latitude= (uint16_t)(UbloxPacket.Latitude/100)+((((((UbloxPacket.Latitude/100))-((uint16_t)(UbloxPacket.Latitude/100))))*100)/60);
					}else{
						UbloxPacket.Latitude=0;
					}
					break;
				
				case LONG:
					if(buffer_aux[0]!=','){
						UbloxPacket.Longitude=atof(buffer_aux);
						UbloxPacket.Longitude= (uint16_t)(UbloxPacket.Longitude/100)+((((((UbloxPacket.Longitude/100))-((uint16_t)(UbloxPacket.Longitude/100))))*100)/60);					
					}else{
						UbloxPacket.Longitude=0;
					}
					break;
				
				case SAT:
					if(buffer_aux[0]!=',')
						UbloxPacket.Satellites=atoi(buffer_aux);
					else
						UbloxPacket.Satellites=0;
					break;
				
				default:
					break;

			}

		}
	}

	
	clear_buffer(data);
	
}

/*********************************************************************//**
 * @brief		Funcion principal
 * @param[in]	None
 * @return 		None
 **********************************************************************/

int main(void){
	
	char buffer[50];

	SetClockto100Mhz();
	SetUartX(1,9600);
	SetUartX(2,9600);
	
	UbloxInit();
	
	NVIC_EnableIRQ(UART0_IRQn);

	while(1){
		
		if(intrda){
			intrda=0;
			UbloxDecodeNMEA(data);
			
			sprintf(buffer,"Message = %s \n",UbloxPacket.NMEAMessage);
			UARTX_send_string_ram(2,buffer);
			
			sprintf(buffer,"UTCTime = %s \n",UbloxPacket.UTCTime);
			UARTX_send_string_ram(2,buffer);
			
			sprintf(buffer,"Position = %0.5f,-%0.5f \n",UbloxPacket.Latitude,UbloxPacket.Longitude);
			UARTX_send_string_ram(2,buffer);

			sprintf(buffer,"Satellites = %u \n",UbloxPacket.Satellites);
			UARTX_send_string_ram(2,buffer);
			
		}
		delay_ms(250);
	}
	
}
Saludos!
Archivos Adjuntos
Tipo de Archivo: pdf UCURSOS 2.2.pdf (411,6 KB (Kilobytes), 14 visitas)
29/06/2014 #29

Avatar de george.manson.69

ARM Cortex M3: Telit GL865 Modo SMS
Hola a Todos,

Les comparto un codigo para usar el modulo Telit GL865 modo SMS.



¿Qué es un Modulo GSM?

•El sistema global para las comunicaciones móviles.

•Un cliente GSM puede conectarse a través de su teléfono con su computador y enviar y recibir mensajes por correo electrónico, faxes, navegar por Internet, acceder con seguridad a la red informática de una compañía (red local/Intranet), así como utilizar otras funciones digitales de transmisión de datos, incluyendo el servicio de mensajes cortos(SMS) o mensajes de texto.

MODULO TELIT G865
Este Modulo nos permitira enviar y recibir mensajes de texto, y realizar conexiones
Tanto como UDP, TCP, HTTP.



Modo SMS
•En este post solo veremos el algoritmo necesario para enviar mensajes muy fácilmente.



COMANDOS SMS

•Como cualquier modulo GSM es necesario enviar ciertos comandos para poder enviar un mensaje, los comandos son los siguientes:

•AT : Checa comunicación entre el microcontrolador y el modulo telit.
•AT+CREG? : Checa si hay conexión a la red.
•AT#SMSMODE=1 : Establece modo SMS
•AT+CMGF=1: Establece modo Texto
•AT+CMGS=“phone” : Establece el teléfono a enviar mensaje, después de la respuesta, se enviara el mensaje y al final el mensaje la la terminasion debe ser 0x1A.
•Se ha creado una función que automatiza el envío de mensajes SMS.

Código:
/*********************************************************************//**
 * @brief		Funcion que envia mensajes SMS al telefono asignado
 * @param[in]	*phone: Puntero que guarda el telefono
 * @param[in]	*msg: Puntero donde guarda el mensaje a enviar
 * @return 		1 si se envio el Mensaje, 0 si hay un error
 **********************************************************************/

uint8_t Send_SMS_GL865(char* phone,char* msg);
El codigo Final es:

Código:
///////////////////////////////////////////////////////////
/*
*//**
*@file	Main.c
*@brief Algoritmo para enviar SMS utilizando el modem de Telit
*				G865.
*@Version	1.0
*@date	06/12/2014
*@author ucursos
*/
///////////////////////////////////////////////////////////

/*
Librerias incluidas
*/
#include  <lpc17xx.h>
#include  <math.h>
#include	<string.h>
#include	<stdio.h>
#include	<stdlib.h>
#include	"SetOscto100Mhz.h"
#include	"SetUartX.h"
#include	"SysTickTimer.h"

/*--------------DEFINICIONES-------------------*/
//#define DEBUG_LEVEL_2
#define DEBUG_LEVEL_1
#define SET	4
#define	QUERY	8
/*---------------------------------*/


/*---------------------------------*/
char data[100];
char debug[100];
uint8_t v_;
struct{
	unsigned IntRda:1;
	unsigned confirm:1;
	unsigned dummy:6;
}Flags={0};


/*
Definicion de variables
*/

const char cmd[7][15]={"AT\r",
											"AT#SMSMODE=1\r",
											"AT+CREG?\r",
											"AT+CMGF=1\r",
											"AT+CMGR=1\r",
											"AT+CMGD=1,4\r",
											"AT+CMGS="};

const char resp[2][15]={"OK",
												"+CREG: 0,1"};
/*---------------------------------*/

/*********************************************************************//**
 * @brief		Funcion de limpiar buffer
 * @param[in]	None
 * @return 		None
 **********************************************************************/

void ClearBuffer(void){

	uint8_t c;
	for(c=0;c<sizeof(data);c++){

		data[c]=0;
	}
	
}
/*********************************************************************//**
 * @brief		Funcion de Retardo
 * @param[in]	t: Variable de tiempo
 * @return 		None
 **********************************************************************/

void delay(int t){

	while(--t>0){
		delay_ms(1);
	}
}

/*********************************************************************//**
 * @brief		Funcion de Envio de Comandos
 * @param[in]	*cmdptr: Puntero para que almacena el comando a enviar
 * @param[in]	*respptr: Puntero para almacenar la repuesta del modem
 * @param[in]	typecmd: Variable que indica que tipo de comando es SET,QUERY
 * @return 		Estado del Comando 1=OK,0=FAIL
 **********************************************************************/

uint8_t	Send_Command_GL865(char *cmdptr,char *respptr,uint8_t typecmd){
	
		uint8_t cn=0;
		Flags.confirm=1;

		#ifdef	DEBUG_LEVEL_2
			UARTX_send_string_ram(2,cmdptr);
		#endif
		UARTX_send_string_ram(1,cmdptr);
		UARTX_get_nstring_ram(1,respptr,typecmd);
		
		///////////////////
		///CHECA ESPEJO DEL COMANDO
		///////////////////
		do{
			#ifdef	DEBUG_LEVEL_2
				sprintf(debug,"[DEBUG]: cmdptr[%c] != respptr[%c] || cn[%u]\r",*cmdptr,*respptr,cn);
				UARTX_send_string_ram(2,debug);
			#endif
			if((*cmdptr!=*respptr) || cn>30){

				Flags.confirm=0;
				#ifdef	DEBUG_LEVEL_2
					sprintf(debug,"[DEBUG]: ERROR\r");
					UARTX_send_string_ram(2,debug);
				#endif
				break;
			}else if(*respptr=='\r'){
				#ifdef	DEBUG_LEVEL_2
					sprintf(debug,"[DEBUG]: OK\r");
					UARTX_send_string_ram(2,debug);
				#endif
				break;

			}
			
			cmdptr++;
			respptr++;
			cn++;
		}while(1);
		/////////////////////
		
		////////////////////////////////
		//Chequeo de comando de establecer
		if(typecmd==SET){
			#ifdef	DEBUG_LEVEL_2
				UARTX_send_string_rom(2,"[DEBUG]: cmd SET\r");
			#endif
			if(Flags.confirm==1){
				
				respptr++;
				respptr++;
				respptr++;
				#ifdef	DEBUG_LEVEL_2
					sprintf(debug,"[DEBUG]: respptr[%c]\r",*respptr);
					UARTX_send_string_ram(2,debug);
				#endif
				if(!strncmp(respptr,resp[0],2))
					Flags.confirm=1;
				else if(!strncmp(respptr,"> ",2))
					Flags.confirm=1;
				else
					Flags.confirm=0;
				#ifdef	DEBUG_LEVEL_2
					sprintf(debug,"[DEBUG]: Flags.confirm[%u]\r",Flags.confirm);
					UARTX_send_string_ram(2,debug);				
				#endif
			}

		}
		//////////////////
		///Chequo de comando de preguntar
		else if(typecmd==QUERY){
			#ifdef	DEBUG_LEVEL_2
				UARTX_send_string_rom(2,"[DEBUG]: cmd QUERY\r");
			#endif
			respptr++;
			respptr++;
			respptr++;
			#ifdef	DEBUG_LEVEL_2
				sprintf(debug,"[DEBUG]: respptr[%c]\r",*respptr);
				UARTX_send_string_ram(2,debug);
			#endif
			if(!strncmp(respptr,resp[1],10))
				Flags.confirm=1;
			else
				Flags.confirm=0;
			#ifdef	DEBUG_LEVEL_2
				sprintf(debug,"[DEBUG]: Flags.confirm[%u]\r",Flags.confirm);
				UARTX_send_string_ram(2,debug);				
			#endif			
			
			if(Flags.confirm==1){
				cn=0;
				do{
					respptr++;
					cn++;
				}while((*respptr)!='\n' && cn<20);
				respptr++;
				respptr++;
				respptr++;
				#ifdef	DEBUG_LEVEL_2
					sprintf(debug,"[DEBUG]: respptr[%c]\r",*respptr);
					UARTX_send_string_ram(2,debug);
				#endif
				if(!strncmp(respptr,resp[0],2))
					Flags.confirm=1;
				else
					Flags.confirm=0;
				#ifdef	DEBUG_LEVEL_2
					sprintf(debug,"[DEBUG]: Flags.confirm[%u]\r",Flags.confirm);
					UARTX_send_string_ram(2,debug);				
				#endif
				

			}
			
		}
		ClearBuffer();
		return Flags.confirm;

}

/*********************************************************************//**
 * @brief		Funcion que envia mensajes SMS al telefono asignado
 * @param[in]	*phone: Puntero que guarda el telefono
 * @param[in]	*msg: Puntero donde guarda el mensaje a enviar
 * @return 		1 si se envio el Mensaje, 0 si hay un error
 **********************************************************************/

uint8_t Send_SMS_GL865(char* phone,char* msg){

	uint8_t valid=1;
	char ph[21];
	//char msgtxt[160];
	char cn=0;

	#ifdef DEBUG_LEVEL_1
		sprintf(debug,"Command SMS: Send\r");
		UARTX_send_string_ram(2,debug);
	#endif
	//Checa Comunicacion AT
	if(Send_Command_GL865((char*)cmd[0],data,SET)){
		delay_ms(100);
		//Establece Conexion a la red
		if(Send_Command_GL865((char*)cmd[2],data,QUERY)){
			delay_ms(100);
			//Establece MODO SMS
			if(Send_Command_GL865((char*)cmd[1],data,SET)){
				delay_ms(100);
				//Establece Mensaje de Texto
				if(Send_Command_GL865((char*)cmd[3],data,SET)){
					delay_ms(100);

					for(cn=0;cn<sizeof(ph)-1;cn++){
						if(cn<=7){
							ph[cn]=cmd[6][cn];
						}else if(cn==8){
							ph[cn]='"';
						}else if(cn>8 && cn<=18){
							ph[cn]=*phone++;
						}else if(cn==19){
							ph[cn]='"';
						}
					}
					ph[20]='\r';
					
					#ifdef DEBUG_LEVEL_1
						sprintf(debug,"Command SMS: Phone %s",ph);
						UARTX_send_string_ram(2,debug);
					#endif
					
					//Comando para establecer Telefono
					if(Send_Command_GL865(ph,data,2)){
						
						#ifdef DEBUG_LEVEL_1
							sprintf(debug,"Command SMS: MSG %s\r",msg);
							UARTX_send_string_ram(2,debug);
						#endif
						///Envia Mensaje
						do{
							
							UART0_putc(*msg);
							
						}while((*msg++)!=0);
						
						UART0_putc(0x1A);						

					}else{
						valid=0;
					}
				}else{
					valid=0;
				}
			}else{
				valid=0;
			}
		}else{
			valid=0;
		}
	}else{
		valid=0;
	}
	ClearBuffer();
	return valid;

}

/*********************************************************************//**
 * @brief		Funcion principal
 * @param[in]	None
 * @return 		None
 **********************************************************************/

int main(void){

	SetClockto100Mhz();
	SetUartX(1,9600);
	SetUartX(2,9600);

	LPC_GPIO2->FIODIR1 &=~(1<<3);
	LPC_GPIO0->FIODIR0 |= (1<<1);

	UARTX_send_string_rom(2,"Waiting....\r");
	delay(2000);
	while(1){

		//Wait to KEY 1 is pressed
		if(!(LPC_GPIO2->FIOPIN1&(1<<3))){

			LPC_GPIO0->FIOCLR0 |= (1<<1);
			if(!Send_SMS_GL865("0123456789","LPC1768 + TELIT G865 GSM/GPRS!!!"))
				UARTX_send_string_rom(2,"Command SMS: ERROR\r");
			
		}else{
			
			LPC_GPIO0->FIOSET0 |= (1<<1);
			
		}
		
		delay(100);
		ClearBuffer();

	}
	
	
}
Waiting....
Command SMS: Send
Command SMS: Phone AT+CMGS="0123456789"
Command SMS: MSG LPC1768 + TELIT G865 GSM/GPRS!!!
Command SMS: Send
Command SMS: ERROR

29/07/2014 #30

Avatar de george.manson.69

FRDM-KL25Z Inicializacion
Hola,

Les comparto el uso del Kit de desarrollo de Freescale el FRDM-KL25Z.



Saludos!
03/08/2014 #31

Avatar de george.manson.69

FRDM-KL25Z + Bluetooth
Hola,

Les comparto una practica del uso del modulo HC-06 + el kit de desarrollo de Freescale el FRDM-KL25Z.


El codigo es el siguiente:

Código:
#include "mbed.h"
 
DigitalOut myled1(PTC9);
DigitalOut myled2(PTC8);
DigitalOut myled3(PTA13);
DigitalOut myled4(PTD3);
DigitalOut myled5(PTD2);
DigitalOut myled6(PTD0);
DigitalOut myled7(PTD5);
 
DigitalOut  LedError(LED_BLUE);
 
Serial Controller(PTE0,PTE1);
 
 
 
int main()
{
    char data=0;
    while (true){
        
        if(Controller.readable()){
        
            data=Controller.getc();
        
            switch(data){
                case '1':
                    myled1=!myled1;
                    LedError=1;
                    break;
                case '2':
                    myled2=!myled2;
                    LedError=1;
                    break;
                case '3':
                    myled3=!myled3;
                    break;
                case '4':
                    myled4=!myled4;
                    LedError=1;
                    break;
                case '5':
                    myled5=!myled5;
                    LedError=1;
                    break;
                case '6':
                    myled6=!myled6;
                    LedError=1;
                    break;
                case '7':
                    myled7=!myled7;
                    LedError=1;
                    break;
                default:
                    LedError=0;
                    break;
            }
            
        }
        wait(0.1);
    }
}

Saludos!
26/08/2014 #32

Avatar de george.manson.69

Raspberry Pi: Inicializacion
Hola,

Les comparto un vídeo sobre la introducción a la programación en python usando el raspberry Pi.


Codigo:

Código:
#////////////////////////////////////////////////7
#
#Python 3
#Autor: Jorge
#Pagina: http://ucursos.blogspot.com
#Descripcion: Control de Relevador
#			  Utilizando el modulo de 8 Relevadores
#////////////////////////////////////////////////7
 
 
#Importamos librerias
 
import RPi.GPIO as GPIO
import time
 
#Variables
 
Relay1=18
 
 
#Funcion Principal
 
def main():
 
	#Funciones de inicializacion
	print("Salidas modo BCM")
	print("Salida 18 como salida")
	GPIO.setmode(GPIO.BCM)
	GPIO.setup(Relay1,GPIO.OUT)
 
 
	for i in range(10):
		GPIO.output(Relay1,0)
		time.sleep(1)
		GPIO.output(Relay1,1)
		time.sleep(1)
 
 
#Definicion Global de Inicializacion de nuestro programa
 
if __name__ == '__main__':
	main()
 
 
GPIO.cleanup()
 
exit()
16/02/2015 #33

Avatar de george.manson.69

DiscoveryF0: SMT32F051R8
Hola a todos,

Les comparto un mini manual para programar los microcontroladores STM32F051R8.


¡Saludos!
19/02/2015 #34

Avatar de george.manson.69

DiscoveryF0: Timer1
Hola,

Continuando con la programacion de microcontroladores de la familia STM32 utilizando el discoveryF0. Vamos a programar un periferico que es el Timer1 segun la tabla de contenido en el microcontrolador STM32F051R8,



El timer1 tiene una resolucion de 16-bit es decir 65535, otra caracteristica es que puede contar ascendentemente, descendente o ambos a la vez, contiene un prescalar de 1 hasta 2^16, etc.

Para programar este modulo hay que entender como funciona la formula para calcular el tiempo de temporizacion,



Time = (Prescaler/SysFreq)*Period

Por ejemplo, si deseamos que nos de una temporizacion de 1 milisegundo de una frecuencia total de 48 Mhz, entonces necesitamos establecer los siguientes datos:



Time = (48/48Mhz)*1000
Time = 0.001 s

En nuestro codigo de ejemplo es el siguiente:

Código:
///////////////////////////////////////////////////////////
/*
*//**
*@file	Main.c
*@Company	ucursos.blogspot.com
*@brief Uso del Modulo Timer de Discovery
*@Version	1.0
*@date	18/02/2015
*@author George
*/
///////////////////////////////////////////////////////////
#include "stm32f0xx.h"

/*Estructuras de Inicializacion*/
TIM_TimeBaseInitTypeDef MyTimer1Init;
GPIO_InitTypeDef GpioInit;


/*********************************************************************//**
 * @brief		Funcion de tiempo
 * @param[in]	TimeOut: Variable donde almacena la cantidad de veces que debe
 *		de repetir el ciclo
 * @return 		None
 **********************************************************************/


void delay_ms(uint32_t TimeOut){

	while(TimeOut--){

		TIM_SetCounter(TIM1,0);
		while(TIM_GetITStatus(TIM1,TIM_IT_Update)==RESET);
		TIM_ClearITPendingBit(TIM1,TIM_IT_Update);


	}

}

/*********************************************************************//**
 * @brief		Funcion Principal
 * @param[in]	None
 * @return 		None
 **********************************************************************/


int main(void){
	
	/*Activar Reloj en Perifericos*/

	RCC_APB2PeriphClockCmd(RCC_APB2Periph_TIM1,ENABLE);
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC,ENABLE);
	
	/*Inicilizacion de Puertos*/
	
	GpioInit.GPIO_Mode  = GPIO_Mode_OUT;
	GpioInit.GPIO_OType = GPIO_OType_PP;
	GpioInit.GPIO_Pin   = GPIO_Pin_9 | GPIO_Pin_8;
	GpioInit.GPIO_Speed = GPIO_Speed_Level_3;
	GpioInit.GPIO_PuPd  = GPIO_PuPd_NOPULL;
	
	GPIO_Init(GPIOC,&GpioInit);
	
	/*Inicilizacion de los Timers*/
	/*
	*Frecuencia_del_Systema = 48Mhz
	*Prescalar = 48
	*Periodo = 1000
	*Tiempo = (Prescalar/Frecuencia_del_Systema)*Periodo
	*Tiempo = (48/48Mhz)*1000
	*Tiempo = 0.001 s
	*/
	
	MyTimer1Init.TIM_Prescaler	= 48;
	MyTimer1Init.TIM_CounterMode	= TIM_CounterMode_Up;
	MyTimer1Init.TIM_Period 	= 1000;
	MyTimer1Init.TIM_ClockDivision 	= TIM_CKD_DIV1;
	MyTimer1Init.TIM_RepetitionCounter = 0x00;
	
	TIM_TimeBaseInit(TIM1,&MyTimer1Init);
	TIM_ITConfig(TIM1, TIM_IT_Update, ENABLE);
	TIM_Cmd(TIM1,ENABLE);
	
	/*Super Loop*/
	
	while(1){

		GPIO_SetBits(GPIOC,GPIO_Pin_8|GPIO_Pin_9);
		delay_ms(50); 
		GPIO_ResetBits(GPIOC,GPIO_Pin_8|GPIO_Pin_9);
		delay_ms(50);

	}

}

http://www.mediafire.com/download/ff...ink_wTimer.zip

¡Saludos!
10/03/2015 #35

Avatar de george.manson.69

LPC4357 Arm CortexM4/M0
Hola Amigos,

Les comparto un video de introduccion a los microcontroladores LPC4357 de la compañia de NXP.


¡Saludos!
14/03/2015 #36

Avatar de george.manson.69

Stm32f103
Hola Amigos,

Les comparto un tutorial para programar los microcontroladores STM32F103.


Codigo:

Código:
#include "stm32f10x.h"

uint32_t TimeOut;
uint8_t t;

int main(void){
	
	GPIO_InitTypeDef MyGpio;
	
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC,ENABLE);
	
	MyGpio.GPIO_Mode = GPIO_Mode_Out_PP;
	MyGpio.GPIO_Pin = GPIO_Pin_13;
	MyGpio.GPIO_Speed = GPIO_Speed_50MHz;
	
	GPIO_Init(GPIOC,&MyGpio);
	
	
	while(1){

		for(t=5;t>0;t--){
			GPIO_SetBits(GPIOC,GPIO_Pin_13);
			for(TimeOut=100000;TimeOut>0;TimeOut--);
			GPIO_ResetBits(GPIOC,GPIO_Pin_13);
			for(TimeOut=100000;TimeOut>0;TimeOut--);
		}
		
		for(t=5;t>0;t--){
			GPIO_SetBits(GPIOC,GPIO_Pin_13);
			for(TimeOut=1000000;TimeOut>0;TimeOut--);
			GPIO_ResetBits(GPIOC,GPIO_Pin_13);
			for(TimeOut=1000000;TimeOut>0;TimeOut--);
		}

		for(t=5;t>0;t--){
			GPIO_SetBits(GPIOC,GPIO_Pin_13);
			for(TimeOut=10000000;TimeOut>0;TimeOut--);
			GPIO_ResetBits(GPIOC,GPIO_Pin_13);
			for(TimeOut=10000000;TimeOut>0;TimeOut--);
		}

	}


}
Proyecto para bajar

Saludos!
20/05/2015 #37

Avatar de Hellmut1956

Hola. muy pronto empezaré a experimentar finalmente con mi placa LPCXpresso1769 de NXP y la IDE de NXP. También me compré los 2 libros de FreeRTOS, el manual de referencia y el manual sobre experimentos con FreeRTOS en la placa LPCXpresso17xx. Informaciones sobre FreeRTOS y los libros se consiguen aquí!
20/05/2015 #38

Avatar de Nuyel

Yo estaba experimentando con la LaunchPad ARM (la Stellaris y la Tiva C con chip TM4C1294), pero no se si agregar aquí todo eso también. Por ahora solo he visto configurar reloj, GPIO, y PWM para controlar un servo (basado en el hardware PWM en lugar del Timer), espero entender el ADC pronto, lanzar la captura con el comparador análogo y muestrear una señal en modo diferencial.
Veré si lo acomodo y grabo unos videos.
06/07/2016 #39


Revivo este post, haber si algún compañero del foro me echa una mano, estoy controlando un linear array TCD1304AP de Toshiba con el STM32F103, ya pude controlar al CCD, mis intentos de usar Arduino fueron nulos pues no hay suficiente RAM (solo 2K) con el STM32 dispongo de 20K de RAM y es más rápido, para programar utilizo el IDE de Arduino 1.6 con el truco para el STM32, lo cierto es que cuando envío el buffer con 3648 valores hacia la PC a 115200 bauds, me toma 3 o 4 segundos, muy lento!, busco un ejemplo de código para transferencia masiva USB con el STM32F103, alguien tiene algo que me ayude?. Aquí el código de envio hacia la PC
Código:
 /*-----------------------------------------------------------
 Enviar datos del buffer hacia PC, por serial port, ¡es lento!
 ------------------------------------------------------------*/
void Enviar_buffer()
{
  digitalWrite(Led_testigo, HIGH); // Led testigo On
   // Ahora imprimimos al puerto serial
   for (int i=0;i<Num_Pixels;i++)
   {
    Serial.print(i);
    Serial.print(",");
    Serial.println(Pixel_array[i]);
   } 
  digitalWrite(Led_testigo, LOW); // Led testigo Off
}
Gracias
Americo
06/07/2016 #40

Avatar de Hellmut1956

la endemoniada salud me retraza en todas mis actividades. Mi fascinación y mi interés en mis actividades combate la letargia que surge a razón de los muchos medicamentos que tomo.

Viendo cuanto conocimiento es mostrado aquí, quisiera preguntar su fuera posible tratar el tema de seguridad en la comunicación de placas. Yo, cuando hace algunos meses, ojalá no ha pasado ya un ano, establecí la comunicación entre mi PC con Windows 7 y la placa Raspi B+. Un ataque por esa puerta de la comunicación con la placa Rasp me rindió mi PC inutilisable, ya que algún "virus" me creaba tantos procesos que el PC se domoraba una eternidad para cualquier labor. Instalando el upgrade a Windows 10 me solucioná el problema inminente, pero me dejo muy claro el mensaje que la próxima vez, y eso está por empezar ahora. Me estudie la materia de seguridad y las configuraciones. Así solo permitire la comunicación entre mi PC y las placas Raspi usando entre otras muchas la función de local host. Aprovecho esto para aprender a fondo todos los mecanismos disponibles en el entorno Linux para lograr un máximo de seguridad.

Por eso creo que si algún forista planea usar la funcionalidad del acceso al y del Internet de alguna de las placas aquí tan maestrosamente presentadas, aprender como establecer al menos un mínimo de seguridad. Ojalá esta pregunta, solicitación quepa en este hilo, ya que veo la cuestión en relación a experimentos con las diversas placas e IDes.
¿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.