martes, 16 de diciembre de 2014
domingo, 23 de junio de 2013
Analizador Lógico
Hola hace tiempo que no escribía por aquí; pues como les comenté, compré unos analizadores lógicos y está bastante bien la relación precio-funcionalidad, para lo que nos sirve, funcionan con el software de http://www.saleae.com/ , pues en realidad es un clon; como lo dije, el original y desde mi punto de vista está a buen precio en Estados Unidos ($150USD) para ser un producto de calidad de 8 canales, tristemente no estamos en Estados Unidos, estamos en México y aquí es mucho más caro ya que nos viene saliendo en $250 USD sin la importación lo cual ya vendrían siendo unos $ 3,000 pesos más lo de paquetería y la verdad así ya no vale la pena creo yo.
Pues les explico qué es una analizador lógico. La definición de wikipedia nos dice que: “es un instrumento de medida que captura los datos de un circuito digital y los muestra para su posterior análisis, de modo similar a como lo hace un osciloscopio, pero a diferencia de este, es capaz de visualizar las señales de múltiples canales. Además de permitir visualizar los datos para así verificar el correcto funcionamiento del sistema digital, puede medir tiempos entre cambios de nivel, número de estados lógicos, etc. La forma de capturar datos desde un analizador lógico es conectando una punta lógica apropiada en el bus de datos a medir”
Pues como lo dice, es un instrumento que mide señales digitales, este no lo hace en tiempo real sino que tú le indicas si correr o que espere un disparo en una X señal y empieza a leer datos, pero este tiene la ventaja de que si estás usando un protocolo serial como CAN, DMX-512, I2C, I2S/PCM, Manchester, 1-wire, Async Serial (UART), Paralelo, SPI o UNI/O (protocolo serial de Microchip para sistemas embebidos) tú le dices en el canal 1 tengo SDA y en el canal 2 tengo SCL del I2C, canal 3 tengo MOSI y canal 4 MISO del SPI y los demás son señales simples o algún otro protocolo y te da el dato que se está enviando.
Como ven en la imagen a la derecha más o menos al centro se ven todos los protocolos que tiene el software del analizador lógico.
Pues para probar lo que puede hacer el analizador lógico hice una aplicación muy simple.
El material que utilicé fue una tarjeta XPLAIN XMEGA-A3BU o el micro controlador que está dentro de ella que es un XMEGA256A3BU, un sensor ultrasónico HC-SR04, un módulo bluetooth y el analizador lógico.
La aplicación consiste en hacer una lectura del módulo ultrasónico, procesar el dato (convertirlo a centímetros) y enviarlo vía bluetooth a una terminal, ya sea en la PC o en un teléfono, en este caso estoy usando la del teléfono, desde aquí pueden bajar la aplicación. Actualmente estoy usando el AVR software framework debido a que AVR GCC es del 2010 y ya no le dan soporte y el Atmel software framework (ASF) está bastante bien (es muy parecido al AVR GCC). Una de las cosas que me gustó mucho del ASF es que todo está en estructuras (al menos para los XMEGA que son los que he usado), por ejemplo para los puertos de entrada o salida pones PORTA.DIR, PORTA.OUT , USARTE0.DATA, USARTE0.CTRLA, USARTE0.CTRLB, TCC0.CTRLA, TCC0.CTRLB, TCC0.TCNT, etc …. La verdad no sé si esté así para los ATtiny o ATmega con el ASF pero para los XMEGA sí y los he estado usando bastante y he comparado precios con los ATmega. A mi punto de vista vale mucho más la pena comprar un XMEGA, que son más baratos y hacen muchas más cosas, la curva de aprendizaje no es nada extravagante para los que ya saben usar los ATmega o ATtiny ya que sólo basta aprender los demás dispositivos que tienes disponibles como DMA y Event system, tienen muchos más dispositivos a la mano en muchos puertos, hay 2 USART´s, también 2 timer´s, el ADC es más preciso(12-bit´s), SPI´s, I2C´s, encriptación AES y DES en hardware, cálculo del CRC en hardware, salidas analógicas, etc…… en fin. Son mucho más baratos y tienen muchas más cosas creo que vale la pena aprender a usarlos, si andas tratando de aprender algún micro controlador te recomiendo que aprendas los XMEGA, puedes comprar algún XPLAIN con un XMEGA y pues te vas a gastar no más de 400 pesos, aparte el IDE de C es gratuito (Atmel Studio 6) y esta mucho mejor que otros IDE´s que he visto como de fujistu (softune), TI (Code composer) o Freescale (Codewarrior). Todos esto tiene sus desventajas claro pero pues la verdad no son tan desventajas, si lo son si eres principiante, no encuentras los chips en empaquetado DIP solo en montaje superficial como QFP, QFN, etc … y la segunda trabajan a máximo 3.6 Volts lo que quiere decir que si son interfaces de 5 Volts habrá que poner convertidores de nivel, no lo he probado pero he leído que las entradas no son tolerantes a 5v y se queman si les pones 5 volts.
Ahí está el código pero no lo explicaré muy bien porque el punto es que conozcan más un analizador lógico.
1: #define F_CPU 32000000UL //32 MHZ clock
2: #define triger (1<<0)|(1<<1) //Pin used as triger one for the triger and the other for the logic analyzer
3: #include <avr/io.h>
4: #include <util/delay.h>
5: #include <stdlib.h>
6:
7: typedef union{ //union definition of 16 bits
8: uint16_t palabra; //accessing as a word
9: uint8_t bytes[2]; //accessing as to bytes
10: }w_16bits;
11:
12: char BCD_dis[6]; //pointer to array of the value to send
13:
14: volatile uint32_t distancia; //read value
15: volatile uint8_t i;
16:
17: void clk_config(void); //clock configuration for 32 MHZ
18:
19: int main(void)
20: {
21: clk_config(); //configuration of the clock
22: PORTA.DIR|=triger; //port to trigger the ultrasonic sensor
23: EVSYS.CH6MUX=0b01100000; //event system channel 6 configured to PORTC PIN 0
24: PORTC.PIN0CTRL=0x00; //PORTC PIN 0 set as input sensing both edges
25: TCC0.CTRLA|=TC0_CLKSEL2_bm; //division factor by 8 so the clock is 32000000/8=4000000
26: TCC0.CTRLB|=TC0_CCAEN_bm; //activate output compare A
27: TCC0.CTRLD|=TC0_EVACT2_bm|TC0_EVACT1_bm|TC0_EVSEL3_bm|TC0_EVSEL2_bm|TC0_EVSEL1_bm; //pulse width capture and event channel 6
28: USARTE0.CTRLB=(1<<4)|(1<<3); //UART configuration
29: USARTE0.CTRLC=0b00000011; //UART configuration
30: USARTE0.BAUDCTRLA = 12; //UART configuration
31: USARTE0.BAUDCTRLB = (1<<6); //UART configuration
32: PORTE.DIR|=(1<<3); //set UART port as output
33: BCD_dis[4]=0x0A; //fill the array to send with a LF
34: BCD_dis[5]=0x0D; //fill the array to send with a CR
35: while(1) //main program while cycle
36: {
37: PORTA.OUT|=triger; //triger action
38: _delay_us(11); //minimum time for triger
39: PORTA.OUT&=~(1<<0); //turning of trigger
40: PORTA.OUT&=~(1<<1); //turning of trigger
41: _delay_ms(60); //wait you can only do one read every ~ 60 ms
42: distancia=(TCC0.CCA/232); //convert the read value to centimeters avoiding floating point math
43: itoa(distancia,BCD_dis,10); //Change the 16bit value to a readable number un a console
44: for(i=0;i<=5;i++) //cycle for sending characters
45: {
46: USARTE0.DATA=BCD_dis[i]; //character send
47: while((USARTE0.STATUS&(USART_TXCIF_bm))==0);//check for the send flag
48: USARTE0.STATUS|=USART_TXCIF_bm; //clear the send flag
49: }
50: }
51: }
52:
53: void clk_config(void)
54: {
55: OSC.PLLCTRL=0x80; //Oscillator configuration
56: OSC.CTRL |= (1<<OSC_RC32MEN_bp); //Oscillator configuration
57: while((OSC.STATUS & (OSC_RC32MRDY_bm)) == 0);//Oscillator configuration
58: CCP = CCP_IOREG_gc; //Oscillator configuration
59: CLK.CTRL |= CLK_SCLKSEL_RC32M_gc; //Oscillator configuration
60: OSC.CTRL &= ~OSC_RC2MEN_bm; //Oscillator configuration
61: }
Como les comenté hay que dar un pulso al sensor ultrasónico para que comience la secuencia, se manda el pulso de aproximadamente 10ms.
Seguido del pulso, el sensor ultrasónico nos regresa un pulso, dependiendo de la anchura de este pulso es la distancia medida con un límite de 300 centímetros que yo vi que son como 250 centímetros.
Como se ve en el canal 3 dice Serial TX, estos datos son seriales y es el protocolo que usé, el primero es un 1 seguido de 9 después un 4 y un 0 los \n y \r son retorno de carro y salto de línea, aquí lo interesante es que si se fijan tengo un 0, ese 0 es un cero hexadecimal que envió el hardware debido al programa y los demás no son ceros sino que son los números 31, 39 y 34 que corresponden al 1, 9 y 4, esto se puede ver que el 0 tiene todos los bits en bajo y los demás no debido a que la configuración se conforma por el bit de inicio seguido por el menos significativo y así sucesivamente hasta el séptimo bit que es de paro y sin paridad.
Por ahí se ve el 194 que vimos, me costó trabajo agarrarlo (como lo hace 15 veces por segundo es complicado). Guardé los datos para que los bajen y los puedan abrir en el software de http://www.saleae.com/downloads y aquí esta el link de la sesión.
Aquí una foto de lo que hice físicamente la verdad está hecho un desastre.
Como se ve en el lado izquierdo está el depurador para el micro, en el centro la Xmega-A3BU Xplained después en la orilla derecha el analizador lógico, en la parte de abajo al centro está el sensor ultrasónico y a su lado derecho un poco más arriba el módulo bluetooth.
Pues ya vieron más o menos lo que hace. Es bastante útil para los que diseñamos sistemas digitales y que manejamos protocolos seriales, un osciloscopio nos sirve pero pues este para protocolos seriales es muy muy bueno. Compré varios de estos y por si les interesa los estaré vendiendo en mercadolibre (link) y si les interesa alguna otra cosa tmb la puedo conseguir sólo contáctenme ya saben por correo, un comentario o mi twitter @lams_007
martes, 5 de marzo de 2013
ST discovery, Analizador lógico y nuevo empleo
Hola hace tiempo que no escribía pero había estado algo ocupado ahorita tendré una semana tranquilo creo.
Pues les comente me iba a estar metiendo con los microcontroladores ARM, la serie Cortex MX, y pues creo les mostré varios de diferentes marca hace tiempo, recientemente compre uno del fabricante ST, es un STM32L-Discovery.
ST32ML-Discovery
Lo siento por el anuncio de newark/element14 así llego y si se lo quito se ve mas feo, el costo de este mismo fue muy bajo de 12.31 USD mas iva.
Una de sus características que me llamo la atención fue que como el kit de NXP este trae su depurador y promete poder depurar o programar mas µCde esta misma marca seria de 32 bits
Características principales
- STLINK/V2 depurador
- LCD DIP28 de 24 segmentos y 4 comunes
- 2 Leds para el usuario
- 1 Push button para el usuario
- 4 botones táctiles
- Pin header para fácil prototipaje en una protoboard
Algo que no me gusto de ST en µC de 32 bits seria ARM es que no tienes un IDE propio, comp or ejemplo NXP tiene el LPCxpresso, Atmel el Atmel Studio 6, TI tiene su code composer, etc… muchos de estos estan basados en eclipse que es muy bueno y otros no, ST prefiere no tener uno entonces debes de usar uno externo como IAR, Kiel o Atolic true stduio. Como les comento en lo personal eso a mi no me gusta para nada pero bueno como todo tienes sus ventajas y desventaja
Por el momento es todo lo que les puedo comentas no lo e usada mas que para conectarlo no vi ni el demo que traía.
Otra de las cosas que compre de ST fue un STM8S-Discovery, este es de los µC de 8 bits de ST, haber que tal están en realidad no he visto ni sus características lo compre por que estaba barato como 10 USD ya con IVA. La ventaja es que ST si tiene su IDE para estos chips por que para los de 32 no lo tiene.
STM8S-Discovery
Pues hace tiempo quiero comprarme un osciloscopio y un analizador lógico o los dos en uno, del analizador lógico quiero uno que es del fabricante de www.salaea.com, este es muy básico es por USB pero tiene la opción para decodificar varios protocolos tiene en 8 y 16 bits con un costo de 150 USD y 300 USD respectivamente y del osciloscopio pues estaba pensando en un RIGOL de 100 Mhz y 2 canales, pero como no e podido tener ni uno ni otro un día vagando por internet encontré un analizador lógico al parecer es un clon de una marca www.usbee.com pero pues esta marca y la anteriormente menciona tiene casi el mismo hardware cambiando el VID/PID que viene en una memoria E2PROM podemos hacerlo funcionar como el de la otra marca y pues todo esto por como 20 USD decidí probarlo y ya me llego pro lo pronto pues lo conecte y baje el software de www.usbeee.com y lo reconoce y según hace capturas pero no entiendo ese software, programare esa memoria y veré que tal funciona después les enseño haber si valen la pena y les digo donde o pueden comprar.
Del lado derecho el analizador lógico y del lado izquierdo una fuente conmutada
Les comento hace tiempo quería hacer kits de fuentes conmutadas y el CI LM2576, LM2596, etc… ya que pues son simples de usar y desde mi punto de vista mucho mejores que un CI de la serie 78XX y la vi esta tiene un LM2596S-ADJ, la estaré probando haber si compro mas, debe de funcionar es solo el diagrama que viene en la hija de datos pero recuerden son chinos y pues el CI puede ser diferente al que esta marcado.
Y por ultimo y no menos importante pues cambie de trabajo me ofrecieron un trabajo en Continental Automotive Group en GDL y pues ya ando par acá se supone hoy era mi primer día de trabajo pero por políticas de le empresa solo puedo empezar a trabajar los lunes, y firme contrato hoy entonces hasta el lunes 11 de marzo empezare mientras tengo una semana sin mucho que hacer. les estaré comentando que hare pero pues no puedo decir mucho el contrato de confidencialidad es mucho mucho mas extenso solo puedo decir que estaré usando CAN y micros ARM Cortex M aun no se bien pero pues se ve interesante lo que voy a estar haciendo.
Por cierto ando buscando un programador de java o algún otro lenguaje, este debe de poder saber leer y escribir el puerto serial y entregarme el código fuente y quizás USB a futuro, no tiene que ser java solo quiero que sea un programa que sea portable para Windows, linux y Mac, pagaría por proyecto en realidad es algo muy simple anímense.
Y como siempre ya saben no duden en contactarse conmigo a mi correo mecatronicamexicana@gmail.com y síganme en mi twitter @lams_007
Saludos
martes, 11 de diciembre de 2012
Español : Aprendiendo a usar el entorno de desarollo NXP LPCXpresso LPC812 Ingles: Learning how to use NXP LPXXpresso LPC812 development board
Español
Antes que nada los artículos que pondré de ahora en adelante serán tanto en inglés como en español, espero y funcione por lo pronto no estoy seguro si poner las dos versiones en el mismo post o hacerlo de manera individual; hoy serán ambos idiomas en el mismo post.
Pues como les dije hace unos días me aventuraré en el uso de los µC ARM-CORTEX-MX para eso cuento con varias tarjetas de diferentes fabricantes (más información la pueden encontrar en el post anterior). Empezaré con el de NXP.
Antes que nada comienzo con esta placa y esta serie ya que NXP lo que trata de hacer de µC LPC8XX es desplazar los µC de 8-bits ya que los de esta seria tienen µC de 8 pines en empaquetado DIP y hasta 20 pines en empaquetado TSSOP, con 4 hasta 16 KB de memoria flash y 1 hasta 4KB de memoria RAM, el único lado “MALO” para los hobistas, es que sólo trabajan con voltajes de 1.8V a 3.6V.
Imagen 1- diagrama a bloques del LPC8XX
Otras de las cosas interesantes que tiene este microcontrolador es algo que NXP llama “SWITCH MATRIX”(matríz de switches), esto te da la opción de configurar casi todos los pines del µC (voltaje y tierra no se pueden configurar) con cualquier función que incluya el µC ya sea de las UART´s, GPIO´s, I2C, SPI, etc… en cualquier pin que quieras lo único que debes de hacer es usar la herramienta que llaman SWITCH MATRIX TOOL y ésta nos genera un código que se debe de incluir al principio del µC (o al menos es lo que creo hasta el momento).
Imagen 2 – Switch Matrix Tool
Y por último y no menos importante es que NXP decidió poner drivers de bajo nivel para el I2C y el UART en una memoria ROM entonces sólo requieren llamadas a API´s que vienen dentro de una memoria ROM del µC.
Por el momento los chips como tales no los venden todavía (solo las tarjetas de demostración).
Les comento un poco sobre esta placa, aunque pueden encontrar más información aquí.
En primera: el empaque en lo personal no me gustó pero bueno por los 24 USD que costó pues está bien. Viene en una bolsa de cartón con el plástico este de bolitas que se truenan y cuyo nombre no recuerdo (venia abierta por que la aduana la abrió).
Imagen 3 Bolsa donde viene la LPC812
Dentro de ésta viene la placa dentro de una bolsa antiestática y un plástico con agujeros para los componentes que están más altos como son el potenciómetro el conector USB los dos cristales, el del debug y el del µC y el JTAG. Incluido viene una tarjeta pequeña con un código de cupones que funciona en embedded artists que les da un descuento, aunque no creo que sea muy útil en México (salvo que vayas a comprar un software que sea descargable) pero pedir algo desde allá sale caro.
Imagen 4 lo que viene dentro del paquete.
Imagen 5 - PCB
Espero y se alcance a ver (la única cámara que tengo es la de mi celular), pero en el centro de la PCB se ven unas hileras de pines machos con espaciamiento de 100 mil. Entre estas dos hay soldadura, que hay que remover y poner pines normales para así poder usar el JTAG que tiene en otro dispositivo y para usar el JTAG en el µC interno debes de puentear esto con jumpers.
Imagen 7 - Conector JTAG para dispositivos externos
Ahora sí, antes de comenzar debes de descargar el IDE LPCXpresso basado en eclipse desde aquí . Este IDE es gratuito y es de Code Red, aun así hay que registrarse y después activar el IDE aquí (les menciono para que no les pase como a mí) bajen la versión LPCXpresso v5.0.12 o más nueva por que las versiones anteriores aún no soportan los LPX8XX y de esta manera no tendrán que bajarlo dos veces
Imagen 8 LPCXpresso IDE
Como lo ven pues el IDE está basado en eclipse entonces es bastante familiar para los que ya han usado eclipse como su IDE. En lo personal yo no lo conozco entonces me iré familiarizando con él poco a poco.
Antes de comenzar no está de más bajar la hoja de datos del LPC812 y de la serie LPC8XX, también el diagrama esquemático de la tarjeta y los Sample codes
Después de esto lo que tenemos que hacer es importar los sample codes al LCPXpresso, para esto hay que abrir el IDE, después seleccionar file y después import.
Imagen 9 Ventana de Import
Después de esto en la sección de General seleccionamos existing projects into workspace y damos en Next como se muestra en la imagen.
Cuando hacemos esto nos cambia de ventana y sale una ventana como esta.
Imagen 10 Selección de archivo
Aquí marcamos la opción que dice Select root directory y le damos en browse, que está a la izquierda. Auí nos aparece una ventana y tenemos que seleccionar la carpeta del archivo que se descomprimió y descargamos con los códigos muestra.
Para finalizar le damos click en Finish, después deben de ver el IDE de esta manera. Aquí yo ya lo activé, deben de hacerlo ustedes también solo sigan los paso que les pide para activarlo.
Imagen 11 – LPCXpresso IDE
Después de esto tenemos ya todos los proyectos de muestra importados y listos para ser compilados. Por el momento sólo usaremos el que se llama Blinky.
Antes de eso debemos de tener conectada la tarjeta de desarrollo con sus controladores a la PC y en windows nos debe de aparecer de la siguiente manera.
Imagen 12 – Drivers correctamente instalados
Si esto aparece así quiere decir que ya están instalados los controladores para la tarjeta de desarrollo y que podemos proceder.
El IDE (Integrated Developmente Enviorment) como antes lo mencioné está basado en ECLIPSE y cuenta con 4 zonas que describiré a continuación.
Imagen 13 – Descripción del LPCXpresso IDE
- Explorador de Proyectos: aquí tienes todos los códigos fuente que están en tu lugar de trabajo actual.
- Inicio Rápido: Links usados como: nuevo proyecto, importar de proyectos, etc …
- Editor: Te permite modificar y guardar tu código fuente actual.
- Consola: despliega información de: compilación, depuración, errores, etc …
Sabiendo esto le damos click al explorador de proyectos y abrimos la carpeta que dice blinky. Dentro de eso nos aparecen varias carpetas entre esas una que dice src la abrimos y salen 3 archivos:
- cr_starup_lpc8xx.c
- crp.c
- main.c
Le damos dos click a la que dice main.c
Imagen 14 – click en main.c
Aquí les dejo el código fuente
1: /****************************************************************************
2: * $Id:: blinky.c 3634 2012-10-31 00:09:55Z usb00423 $
3: * Project: NXP LPC8xx Blinky example
4: *
5: * Description:
6: * This file contains LED blink code example which include timer,
7: * GPIO initialization, and clock monitoring.
8: *
9: ****************************************************************************
10: * Software that is described herein is for illustrative purposes only
11: * which provides customers with programming information regarding the
12: * products. This software is supplied "AS IS" without any warranties.
13: * NXP Semiconductors assumes no responsibility or liability for the
14: * use of the software, conveys no license or title under any patent,
15: * copyright, or mask work right to the product. NXP Semiconductors
16: * reserves the right to make changes in the software without
17: * notification. NXP Semiconductors also make no representation or
18: * warranty that such application will be suitable for the specified
19: * use without further testing or modification.
20: 21: * Permission to use, copy, modify, and distribute this software and its
22: * documentation is hereby granted, under NXP Semiconductors'
23: * relevant copyright in the software, without fee, provided that it
24: * is used in conjunction with NXP Semiconductors microcontrollers. This
25: * copyright, permission, and disclaimer notice must appear in all copies of
26: * this code.
27: 28: ****************************************************************************/
29: #ifdef __USE_CMSIS
30: #include "LPC8xx.h"
31: #endif
32: #include "lpc8xx_clkconfig.h"
33: #include "lpc8xx_gpio.h"
34: #include "lpc8xx_mrt.h"
35: extern uint32_t mrt_counter;
36: /* Main Program */
37: int main (void) {
38: uint32_t regVal; 39: SystemCoreClockUpdate();40: /* Config CLKOUT, mostly used for debugging. */
41: regVal = LPC_SWM->PINASSIGN8 & ~( 0xFF << 16 );42: LPC_SWM->PINASSIGN8 = regVal | ( 12 << 16 ); /* P0.12 is CLKOUT, ASSIGN(23:16). */
43: CLKOUT_Setup( CLKOUTCLK_SRC_MAIN_CLK );44: #if 0
45: regVal = LPC_SWM->PINASSIGN0 & ~( (0xFF << 0) | (0xFF << 8) );46: LPC_SWM->PINASSIGN0 = regVal | ( (2 << 0) | (3 << 8) ); /* P0.2 is UART0 TX, ASSIGN(7:0); P0.3 is UART0 RX. ASSIGN(15:8). */
47: #endif
48: /* Enable AHB clock to the GPIO domain. */
49: LPC_SYSCON->SYSAHBCLKCTRL |= (1<<6);50: /* Set port p0.7 to output */
51: GPIOSetDir( 0, 7, 1 );52: /* Set port p0.16 to output */
53: GPIOSetDir( 0, 16, 1 );54: /* Set port p0.17 to output */
55: GPIOSetDir( 0, 17, 1 ); 56: init_mrt(0x8000);57: while (1) /* Loop forever */
58: {59: /* I/O configuration and LED setting pending. */
60: if ( (mrt_counter > 0) && (mrt_counter <= 200) )
61: { 62: GPIOSetBitValue( 0, 7, 0 ); 63: }64: if ( (mrt_counter > 200) && (mrt_counter <= 400) )
65: { 66: GPIOSetBitValue( 0, 7, 1 ); 67: }68: if ( (mrt_counter > 400) && (mrt_counter <= 600) )
69: { 70: GPIOSetBitValue( 0, 16, 0 ); 71: }72: if ( (mrt_counter > 600) && (mrt_counter <= 800) )
73: { 74: GPIOSetBitValue( 0, 16, 1 ); 75: }76: if ( (mrt_counter > 800) && (mrt_counter <= 1000) )
77: { 78: GPIOSetBitValue( 0, 17, 0 ); 79: }80: if ( (mrt_counter > 1000) && (mrt_counter <= 1200) )
81: { 82: GPIOSetBitValue( 0, 17, 1 ); 83: }84: else if ( mrt_counter > 1200 )
85: { 86: mrt_counter = 0; 87: } 88: } 89: }Ahorita no me concentraré mucho en esto debido a que me interesa más que aprendamos a cómo depurar el microcontrolador pero aquí está el código .
Teniendo esto hay que compilar el proyecto. Para esto hay que darle en la barra de herramientas donde dice Project y después le damos en Build Project. Para saber que esta operación fue exitosa, en la consola debe de decir BUILD Finished (took Xs.xxxms)
Ya habiendo compilado esto en el explorador de proyectos queremos recalcar el que dice Blinky y luego en la barra de inicio rápido le damos click en Debugg blinky y si no encontramos problemas ahora estamos depurando el programa (y así comenzamos la depuración).
En mi siguiente post les explicaré en qué nos beneficia depurar el programa y cómo se hace.
Espero y les haya gustado.
Cualquier comentario, pregunta o sugerencia no duden en enviarme un correo a mecatronicamexicana@gmail.com o deja un comentario aquí.
English
Before anything I always be putting thee blog post in 2 different languages, English and Spanish, I hope this works by this time I am not really sure I´ll put the Spanish and English version in the same post or in different post, this time both are going to be in the same.
As I comment you some days before I´ll will star using µC ARM-CORTEX-MX, as you know I have been purchasing several development boards of different manufacturers for more information you can find it in the last post but just to be aware this post it´s only in Spanish as this last post says I will start with the NXP board
I start with this development board because NXP seems to try to replace 8-bit µC with this µC series LPC8XX because this series has µC starting from 8 pin in a DIP package to 20 pin in a TSSOP package and has up to 16 KB of flash memory and up to 4 KB of RAM memory, the only down side is for the hobbyists because this µC only work with voltage from 1.8V to 3.6V.
Image 1 – LPC8XX Block diagram
One of the interesting things this µC has is something NXP calls “SWITCH MATRIX”, this gives you the choice of configure almost every pin of the µC (just VCC and VDD can´t be configured) with any function that the µC has this can be the UART, GPIO, I2C, SPI, etc….. in any pin you want the only thing you have to use is this tool that they call SWITCH MATRIX TOOL, this generates a code that need to be included in the start of the µC or at least this is what I think.
Image 2 – Switch Matrix Tool
At last but not less important is that NXP decided to put low level drivers for I2C and UART in a ROM memory so you only need to make some API call´s for the functions that are in the ROM
For the moment the chip isn´t in sale just the development boards
I will tell you some of the characteristics of this development board but you can find more information here.
At first the package in my personal opinion I didn´t like it but It´s ok for the 24 USD that it cost this comes in a bag made of carton with the plastic that has little bubbles.
Image 3 – Bag where the LPC812 board comes.
Inside this bag it comes the development board inside and antistatic bag with a plastic that has holes for the taller component like the potentiometer, the USB connector and both of the crystals one for JTAG and the other for the µC. Included in the package comes a little card with a coupon code for discount in embedded artists
Image 4 – What´s inside the package
Image 5 – development board
I hope this seems fine because the only camera I have is the camera off my cellphone, but in the center of the development board you can see some holes for pins with a 100 mil spacement, here you can find some points with weld we have to remove this weld and put a male pin header if we need to use the JTAG to program the development board target we need to put some jumpers in this if not we only need to remove them to program an external target.
Image 6 –Jtag connector for external devices
Now before we star we need to download the IDE that´s based in eclipse form here this IDE it´s free of charge it´s from Code Red, but we need to register and after that activate it. I comment you need to download LPCXpresso v5.0.12 or a newer one the old ones don’t have support for this µC series
Image 8 – LPCXpresso IDE
As you can see the IDE is based in Eclipse so it´s very familiar for the persons that use Eclipse as there IDE, I don´t know it I will get used to it little by little
Before we begin we need to have dome information of the LPC812 development board and the LPC8XX µC series, also the schematic diagram of the board and the sample codes.
After all of this we need to import the simple codes to the LPCXpresso IDE to do this we need to open the IDE after this select File and then import
Image 9 – Import window
After this in the General section we select existing projects into workspace and click in next this is as shown in the image
When we do this our Windows changes and put us one of this
Image 10 – Selecting the file
Here we mark the option that says select root directory and we click in browse that´s on the left, it pop up a windows and we need to select the folder that we download and unzipped the sample codes.
To finish this we need to click in Finish after all of this you can see the IDE like this way. I have activated my IDE you must also do it you just only need to follow the steps to activate it it´s completely free.
Image 11 – LPCxpresso IDE
After all of this we have all the projects imported and ready to be compiled by the moment we will only use the one that´s named Blinky
Before this we need to have connected the development board and the drivers to the PC in windows they need to be something like this.
Image 12 – LPC812 Drivers
If this appears like this it mean that the drivers of the development board are installed correctly and we can proceed
The IDE as before is based in Eclipse and I has 4 different areas I´ll describe this different areas.
Image 13 – LPCXpresso IDE
- Project explorer: here we have all the project you have in your work space.
- Quick Start: useful links like new project, import projects, etc…..
- Editor: lets us edit or change the code.
- Console: Give´s you information of compilation time and debugging time
Knowing all this we click in the Project explorer and open the folder that says blinky inside this there are several folders one of those is srs we open it and they are 3 files inside it that are
- cr_starup_lpc8xx.c
- crp.c
- main.c
We click on main.c
Image 14 – Main.c
Here is the source code
1: /****************************************************************************
2: * $Id:: blinky.c 3634 2012-10-31 00:09:55Z usb00423 $
3: * Project: NXP LPC8xx Blinky example
4: *
5: * Description:
6: * This file contains LED blink code example which include timer,
7: * GPIO initialization, and clock monitoring.
8: *
9: ****************************************************************************
10: * Software that is described herein is for illustrative purposes only
11: * which provides customers with programming information regarding the
12: * products. This software is supplied "AS IS" without any warranties.
13: * NXP Semiconductors assumes no responsibility or liability for the
14: * use of the software, conveys no license or title under any patent,
15: * copyright, or mask work right to the product. NXP Semiconductors
16: * reserves the right to make changes in the software without
17: * notification. NXP Semiconductors also make no representation or
18: * warranty that such application will be suitable for the specified
19: * use without further testing or modification.
20: 21: * Permission to use, copy, modify, and distribute this software and its
22: * documentation is hereby granted, under NXP Semiconductors'
23: * relevant copyright in the software, without fee, provided that it
24: * is used in conjunction with NXP Semiconductors microcontrollers. This
25: * copyright, permission, and disclaimer notice must appear in all copies of
26: * this code.
27: 28: ****************************************************************************/
29: #ifdef __USE_CMSIS
30: #include "LPC8xx.h"
31: #endif
32: #include "lpc8xx_clkconfig.h"
33: #include "lpc8xx_gpio.h"
34: #include "lpc8xx_mrt.h"
35: extern uint32_t mrt_counter;
36: /* Main Program */
37: int main (void) {
38: uint32_t regVal; 39: SystemCoreClockUpdate();40: /* Config CLKOUT, mostly used for debugging. */
41: regVal = LPC_SWM->PINASSIGN8 & ~( 0xFF << 16 );42: LPC_SWM->PINASSIGN8 = regVal | ( 12 << 16 ); /* P0.12 is CLKOUT, ASSIGN(23:16). */
43: CLKOUT_Setup( CLKOUTCLK_SRC_MAIN_CLK );44: #if 0
45: regVal = LPC_SWM->PINASSIGN0 & ~( (0xFF << 0) | (0xFF << 8) );46: LPC_SWM->PINASSIGN0 = regVal | ( (2 << 0) | (3 << 8) ); /* P0.2 is UART0 TX, ASSIGN(7:0); P0.3 is UART0 RX. ASSIGN(15:8). */
47: #endif
48: /* Enable AHB clock to the GPIO domain. */
49: LPC_SYSCON->SYSAHBCLKCTRL |= (1<<6);50: /* Set port p0.7 to output */
51: GPIOSetDir( 0, 7, 1 );52: /* Set port p0.16 to output */
53: GPIOSetDir( 0, 16, 1 );54: /* Set port p0.17 to output */
55: GPIOSetDir( 0, 17, 1 ); 56: init_mrt(0x8000);57: while (1) /* Loop forever */
58: {59: /* I/O configuration and LED setting pending. */
60: if ( (mrt_counter > 0) && (mrt_counter <= 200) )
61: { 62: GPIOSetBitValue( 0, 7, 0 ); 63: }64: if ( (mrt_counter > 200) && (mrt_counter <= 400) )
65: { 66: GPIOSetBitValue( 0, 7, 1 ); 67: }68: if ( (mrt_counter > 400) && (mrt_counter <= 600) )
69: { 70: GPIOSetBitValue( 0, 16, 0 ); 71: }72: if ( (mrt_counter > 600) && (mrt_counter <= 800) )
73: { 74: GPIOSetBitValue( 0, 16, 1 ); 75: }76: if ( (mrt_counter > 800) && (mrt_counter <= 1000) )
77: { 78: GPIOSetBitValue( 0, 17, 0 ); 79: }80: if ( (mrt_counter > 1000) && (mrt_counter <= 1200) )
81: { 82: GPIOSetBitValue( 0, 17, 1 ); 83: }84: else if ( mrt_counter > 1200 )
85: { 86: mrt_counter = 0; 87: } 88: } 89: }Here is the source code I won´t put a lot of focus on the source code since I am more interested in learning how to debug the µC
Having this we need to compile the project to do this we need to click in project this is in the toolbar after that we click in build project. To now that this operation was succesfull the console must show BUILD finished (took Xs.xxms)
Having this in the project explorer we highlight the project we want to debug in this case Blinky and then in the quick start we click where it says Debugg blinky if we didn’t have problems we are known debugging the program but that would be all for this post. Debugging the program would be in the next post .
Hope you like it and if you know any comment question suggestion you can email me to mecatronicamexicana@gmail.com or leave a comment here.