Conexion del microcontrolador

You are more likely to get replies if you post in English

Well, the problem is this: I want to connect the microcontroller  without the programming base.

you want to connect micro-controller to what ?

do you want to connect your micro-controller to PC ?

Sorry but I translated your post in google translate and  i just  recognized you recently joined to forum.

can you give further information about your problem ؟

Mmmmm, I'm so sorry, I'm from Mexico and my english isn't good. but well. answered to you questions.

1.- you want to connect micro-controller to what ? what i want is connect the micro-controller (Only just the micro-controller, not the tablet) on 1 board, but i don't know how to connect each pin of the micro-controller. the pin 20 as ground, the pin 19 as vcc, i don't know, but i want to know.

If I could help, I would greatly appreciate.

Still not clear, but it sounds like you want to design your own board - yes?

This will be an excersice in electronic circuit design - so you will need to be experienced in that.

If (which sounds to be the case) you don't have any experience with electronic circuit design, then you will clearly have to spend some time first to learn those skills - which is beyond the scope of this forum.

I would suggest that you enrol on a basic electronics course, join an electronics club, or similar...

Manuel Javier Franco Franco said:

the pin 20 as ground, the pin 19 as vcc, i don't know, but i want to know.

VCC and GND are obvious. For the other pins, the Terminal function table in the datasheet tells you what the shortcuts n the pinout diagram mean.

E.g.
Pinout pin 11 - P2.3/TA1.0
-> General-purpose digital I/O pin / TA1.0 Timer1_A, capture: CCI0B input, compare: Out0 output

An explanation of the various internal hardware modules (in this case Digital I/O, Timer1) is found in the family users guide. It is also downloadable from the product page.

Hola Manuel,

quizá yo te pueda ayudar con tu problema, hace bastante tiempo que utilizo esta familia de Microcontroladores, si bien soy algo nuevo en el foro.

Lo principal es que no queda clara tu pregunta en términos técnicos. ¿Que quieres hacer? ¿Una placa electrónica diseñada desde la base, utilizando este microcontrolador? En ese caso, deberás contar con un mínimo de conocimientos acerca de hardware y diseño electrónico.

Esta familia de microcontroladores es muy versátil y de bajo costo, lo que implica cierta "universalidad" en las aplicaciones, pero hay cuestiones básicas de hardware que deben ser bien conocidas para aquella persona que pretenda utilizar este micro.

Si puedes especificar un poco mejor de que se trata tu proyecto y que parte le corresponde al microcontrolador, quizá te pueda ayudar o dar una guía para encaminar los primeros pasos del diseño e implementación.

Espero que sea de utilidad mi propuesta. Saludos.

Hola Leonardo.

Mi problema:

1.- (Aclarando) No quiero hacer una tablilla de programación, ya la tengo para que hago una. Quiero, en pocas palabras, conectar mi microcontrolador ya programado (MSP430G2553) a una tablilla, pero el problema es, que aparte de los pines 1 y 20 que son los de Vcc y GND, no se como se conectan los demas pines. Como los conecto para tener un buen funcionamiento del mismo.

Gracias....

Manuel,

creo que voy entendiendo. Utilizaste una placa de desarrollo (la "tablilla de programación") para hacer y grabar el software de tu aplicación. Lo que quieres es, montar el microcontrolador ya grabado en el hardware correspondiente a tu proyecto... ¿Esto es asi? Corrígeme por favor si me equivoco.

Creo que hay un pequeño mal entendido respecto de la forma de trabajo con un microcontrolador de la familia MSP. Normalmente, cuando se comienza un proyecto, el mismo incluye el diseño del hardware (en el 99% de los casos, esta es la primera etapa del proyecto); este hardware debe contemplar la interfaz necesaria para la grabación del microcontrolador (JTAG, BSL, etc.), dependiendo de las prestaciones del mismo en este aspecto, por ejemplo, hay micros de esta familia que tienen un conjunto de 5 pines dedicados a la grabación, mientras que otros micros comparten estos pines con otros de uso general. Esta información se encuentra en la hoja de datos del microcontrolador.

¿A donde quiero llegar con esto? pretendo dejar en claro la forma de trabajo requerida. No se espera que el microcontrolador sea grabado y luego montado en el hardware de destino, si no, que el hardware de destino contenga al microcontrolador y la interfaz necesaria para descargar el software. Por esto, en primer lugar, especificas cuales son tus necesidades de hardware, por ejemplo:

• ¿Utilizaré sensores analógicos?
• ¿Utilizaré señales PWM?
• ¿Utilizaré comunicación serial (I2C, SPI, etc.)?
• ¿Cuántas señales discretas necesito?

No hay problema, entiendo el como funciona.

Tengo otro problemas, y mas que para un proyecto es para cultura general, como se programan las interrupciones en el micro. EJEMPLO:

En un microcontrolador tengo una secuencia x, y al precionar un boton genero una interrupcion que hace que se pare la secuencia, como hago eso...?

Manuel,

tu pregunta es demasiado amplia como para ser contestada en un foro. Para tener mejor resultado con tus consultas, te recomiendo que las realices de manera mas específica.

En cuanto al manejo de interrupciones, de manera general, cada uno de los periféricos asignados al micro (A/D, DMA, Puertos, UART, etc) genera diversos tipos de interrupciones, las cuales se especifican en la hoja de datos del microcontrolador. Cuando ocurre el evento que dispara una interrupción, el flujo de control del programa en ejecución, cambia a una posición de memoria determinada, propia de cada periférico; es en esta posición de memoria donde debes ubicar el codigo de atención para dicha interrupcion (ISR, Iterrupt Service Routine).
Por otra parte, para que el microcontrolador cambie de esta manera el flujo de control del programa, la atención a las  interrupciones debe estar habilitada. Normalmente existen dos puntos de habilitación: una habilitación general por un lado, y la habilitación particular de cada periférico por el otro.

En el caso que expones, quizá lo mas lógico sea utilizar una interrupción por cambio de nivel en algun puerto de entrada/salida que tenga la capacidad de generar dicha interrupción. En tu código, tendrías dos bloques: el de ejecución principal y la rutina de servicio de interrupción.
En todo momento, se ejecuta el código principal, mientras que, cuando se presente la interrupción, tu ISR ejecuta el código que corresponde al evento, y cuando finaliza, el flujo de control vuelve al código principal, en el mismo lugar donde se estaba ejecutando.

Quizá esto parezca muy simple, pero el manejo de interrupciones es toda una materia aparte en el mundo de la programación embebida...

Espero que estos comentarios hayan servido como aporte.

Saludos. 

Hola quizas tu problema es que no te funciona por aparte el micro tienes que asegurar los pines de Vcc y Vdd adicionalmente conectar el PIN 16 RST a una resistencia de 47K a Vcc sino el WDT te resetea el micro 

Si quieres aprender sobre este micro entra al siguiente link http://processors.wiki.ti.com/index.php/MSP430_LaunchPad_%28MSP-EXP430G2%29

y buscas Code examples/Snippets  y descargas

• MSP430G2xx1
• MSP430G2xx2
• MSP430G2xx3

Aqui estan muchos ejemplos para iniciarse el texas y no se te olvide la resistencia de 47K al pin de RST sino no te va a funcionar.

Hola a todos,

Tengo el siguiente problema: soy nuevo programando con los micro de texas y estoy tratando de realizar un programa de comunicacion con el kit eZ430-RF2500 el cual utiliza el microcontrolador MSP430F2274, sin embargo al momento de compilar me arroja una serie de errores y no entiendo muy bien por qué. A continuación, les presento el código el cual tiene como base el código ejemplo que viene con el mismo kit, a quien me pueda ayudar le estare muy agradecido.

Gracias!

//************************ Librerias *******************************************
#include "bsp.h"
#include "mrfi.h"
#include "nwk_types.h"
#include "nwk_api.h"
#include "bsp_leds.h"
#include "bsp_buttons.h"
#include "vlo_rand.h"
#include "msp430x22x4.h"

//******************* Definiciones *********************************************
#define MISSES_IN_A_ROW 5 //define los intentos maximos a establecer conexion
#define Almacenamiento 9 //indica que el bufer utilizado llega al máximo

//************************Funciones de la Red*********************************
void MCU_init(void); // Inicialización del Microcontrolador
void linkTo(void); // Creación del Enlace
void createRandomAddress (); // Creación de las direcciones
void TXString(char* string, int length); // Transmisión del mensaje (mensaje + longitud)

//***************************Uso de la memoria flash****************************
__no_init volatile char Flash_Addr[4] @ 0x10F0; //Espacio de memoria Flash para almacenar 4 direcciones
addr_t Direcciones; //variable para almacenar direcciones

//**Variables relacionadas con el buffer de UART y los datos recibidos del RS232**
volatile static uint8_t Dato_Recibido_SizeUART=0,Dato_Recibido_SizeUART2=0; //vectores que recibiran los datos de la tarjeta
static uint8_t Dato_Recibido_UART[Almacenamiento], Dato_Recibido_UART2[Almacenamiento]; //dos arreglos de 8 posiciones
volatile int buffer_utilizado=1,buffer_que_envia=0; //indentificador del buffer que se esta usando y del que envia

//******************************************************************************
// PROGRAMA PRINCIPAL //
//******************************************************************************

void main(void)
{
WDTCTL = WDTPW + WDTHOLD; //Detiene en WDT

//*****************Ciclo que asegura un inicio correcto***********************
volatile int j;
for(j=0; j<0xFFFF; j++)
{}

//*****************Calibración de los Dispositivos****************************
if(CALBC1_8MHZ==0xFF)
{
volatile int i;
P1DIR|=0x03; //en el puerto 1, los terminales 1 y 2 son salidas y el resto como entradas
BSP_TURN_ON_LED1(); // Prende en LED Rojo
BSP_TURN_OFF_LED2(); // Apaga el LED Verde
while(1)
{
for(i=0; i<0x5FFF; i++)
{}
BSP_TOGGLE_LED2();
BSP_TOGGLE_LED1();
}
}
//*******SimpliciTI cambiará la configuración de los puertos como sigue*******
P1DIR=0xFF; // Dirección del puerto 1
P1OUT=0x00; // Dirección de la salida del puerto 1
P2DIR=0x27;
P2OUT=0x00;
P3DIR=0xC0;
P3OUT=0x00;
P4DIR=0xFF;
P4OUT=0x00;

//**************** Inicialización del Hardware *******************************
BSP_init();

if(Flash_Addr[0]==0xFF && Flash_Addr[1]==0xFF && Flash_Addr[2]==0xFF && Flash_Addr[3]==0xFF)
{
createRandomAddress(); // Se llama la función para obtener las direcciones
}

//********************* Se almacenan las Direcciones**************************
Direcciones.addr[0]=Flash_Addr[0];
Direcciones.addr[1]=Flash_Addr[1];
Direcciones.addr[2]=Flash_Addr[2];
Direcciones.addr[3]=Flash_Addr[3];
SMPL_Ioctl(IOCTL_OBJ_ADDR, IOCTL_ACT_SET, &Direcciones); //Configuración del tiempo de ejecución

//*************************Inicializamos El Micro*****************************
BCSCTL1=CALBC1_8MHZ; // configura el parametro DCO
DCOCTL=CALDCO_8MHZ;
BCSCTL3|=LFXT1S_2; //LFXT1=VLO
TACCTL0=CCIE; //interrupcion por TACCR0 habilitada
TACCR0=12000; //~1 segundo
TACTL=TASSEL_1+MC_1; //ACLK, upmode
P3SEL|=0x30; //P3.4,5 = USCI_A0 TXD/RXD
UCA0CTL1=UCSSEL_2; // SMCLK
UCA0BR0=0x41; // 9600 de 8MHz
UCA0BR1=0x3;
UCA0MCTL=UCBRS_2;
UCA0CTL1&=~UCSWRST; // Incializa el estado de la máquina USCI
IE2|=UCA0RXIE; //habilita la interrupción por USCI_A0 RX


//***************Ciclo de espera de conexión del ED con el AP*****************
while(SMPL_NO_JOIN==SMPL_Init((uint8_t (*)(linkID_t))0))
{
BSP_TOGGLE_LED1();
BSP_TOGGLE_LED2();
__bis_SR_register(LPM3_bits+GIE);
}

//Llamamos a la funcion linkTo al realizar una conexion con el AP exitosamente
linkTo();
}
//******************************************************************************
// FIN DEL PROGRAMA PRINCIPAL //
//******************************************************************************

//**********************Creación de las Direcciones*****************************
void createRandomAddress()
{
unsigned int rand, rand2;
do
{
rand = TI_getRandomIntegerFromVLO(); //el primer byte no puede ser 0x00 ni 0xFF
}
while((rand & 0xFF00)==0xFF00||(rand & 0xFF00)==0x0000);
rand2 = TI_getRandomIntegerFromVLO();

BCSCTL1 = CALBC1_1MHZ; // Set DCO to 1MHz
DCOCTL = CALDCO_1MHZ;
FCTL2 = FWKEY + FSSEL0 + FN1; // MCLK/3 for Flash Timing Generator
FCTL3 = FWKEY + LOCKA; // Clear LOCK & LOCKA bits
FCTL1 = FWKEY + WRT; // Set WRT bit for write operation

Flash_Addr[0]=(rand>>8) & 0xFF;
Flash_Addr[1]=rand & 0xFF;
Flash_Addr[2]=(rand2>>8) & 0xFF;
Flash_Addr[3]=rand2 & 0xFF;

FCTL1 = FWKEY; // Clear WRT bit
FCTL3 = FWKEY + LOCKA + LOCK; // Set LOCK & LOCKA bit
}

//*************************Creación del Enlace**********************************
void linkTo()
{
linkID_t linkID1;

// Inicializa los LEDs
BSP_TURN_OFF_LED1();
BSP_TURN_OFF_LED2();

// Intenta establecer el enlace...
while (SMPL_SUCCESS != SMPL_Link(&linkID1))
{
__bis_SR_register(LPM3_bits + GIE); // LPM3 with interrupts enabled
BSP_TOGGLE_LED1();
BSP_TOGGLE_LED2();
}

for(int i=0; i<5; i++)
{
Dato_Recibido_UART2[i]=(uint8_t)(65+i);
Dato_Recibido_SizeUART2=5;
}

while(1)
{
if(buffer_que_envia==1)
{
if (SMPL_SUCCESS==SMPL_Send(linkID1, Dato_Recibido_UART, Dato_Recibido_SizeUART)) //se envian los datos vía Zigbee al buffer Dato_Recibido_UART
{
Dato_Recibido_SizeUART=0; //
buffer_que_envia = 0;
BSP_TOGGLE_LED2(); // Durante la transmisión de datos el LED verde papardea
BSP_TURN_OFF_LED1(); // Durante la transmisión de datos el LED rojo está apagado
}
}
if(buffer_que_envia==2) // if(Dato_Recibido_SizeUART2==Almacenamiento)
{
if (SMPL_SUCCESS == SMPL_Send(linkID1, Dato_Recibido_UART2, Dato_Recibido_SizeUART2))
{
Dato_Recibido_SizeUART2 = 0; // Si los datos han sido enviados con éxito inicializamos el buffer RX a 0
buffer_que_envia = 0;
BSP_TURN_OFF_LED1(); // Durante la transmisión de datos el LED rojo está apagado
BSP_TOGGLE_LED2(); // Durante la transmisión de datos el LED verde parpadea
}
}
}
}

//***************Transmitimos en Mensaje = Mensaje + longitud*******************
void TXString( char* string, int length )
{
int pointer;
for( pointer = 0; pointer < length; pointer++)
{
volatile int i;
UCA0TXBUF = string[pointer];
while (!(IFG2&UCA0TXIFG)); // Mientras el buffer esté listo (ocupado)
}
}
//******************************************************************************
// Timer A0 interrupt service routine
//******************************************************************************
#pragma vector = TIMERA0_VECTOR
__interrupt void Timer_A (void)
{
__bic_SR_register_on_exit(LPM3_bits); // Clear LPM3 bit from 0(SR)
}

//****************Preparamos la trama que queremos enviar***********************
#pragma vector = USCIAB0RX_VECTOR
__interrupt void USCI0RX_ISR(void)
{
uint8_t rx = UCA0RXBUF;
if (buffer_utilizado==1)
{
if (Dato_Recibido_SizeUART < Almacenamiento)
{
BSP_TOGGLE_LED1(); // Mientras se reciben los datos parpadea el led rojo
Dato_Recibido_UART[Dato_Recibido_SizeUART++] = rx ; //
}
else
{
buffer_que_envia=1;
buffer_utilizado=2;
Dato_Recibido_SizeUART2=0;
}
if (buffer_utilizado==2)
{
if (Dato_Recibido_SizeUART2 < Almacenamiento)
{
BSP_TOGGLE_LED1(); // Mientras se reciben los datos parpadea el led rojo
Dato_Recibido_UART2[Dato_Recibido_SizeUART2++] = rx;
}
else
{
buffer_que_envia=2;
buffer_utilizado=1;
Dato_Recibido_SizeUART=0;
Dato_Recibido_UART[Dato_Recibido_SizeUART++] = rx;
}
}
}
}

Estos son los errores que me arroja:

Error[e46]: Undefined external "BSP_init" referred in main ( C:\Users\Luis\Desktop\Tesis\pruebas\Debug\Obj\main.r43 )

Error[e46]: Undefined external "SMPL_Ioctl" referred in main ( C:\Users\Luis\Desktop\Tesis\pruebas\Debug\Obj\main.r43 )

Error[e46]: Undefined external "SMPL_Init" referred in main ( C:\Users\Luis\Desktop\Tesis\pruebas\Debug\Obj\main.r43 )

Error[e46]: Undefined external "TI_getRandomIntegerFromVLO" referred in main ( C:\Users\Luis\Desktop\Tesis\pruebas\Debug\Obj\main.r43 )

Error[e46]: Undefined external "SMPL_Link" referred in main ( C:\Users\Luis\Desktop\Tesis\pruebas\Debug\Obj\main.r43 )

Error[e46]: Undefined external "SMPL_Send" referred in main ( C:\Users\Luis\Desktop\Tesis\pruebas\Debug\Obj\main.r43 )

Error while running Linker