Programando la Placa de Desarrollo Mini-STM32 (Valoración de 5.00 sobre 5, resultante de 1 votos)

Componentes y tecnología electrónica, regulación, automatización, domótica, inmótica y edificio inteligente. Protocolo KNX, X10, EIB, LON, DALI, DMX, Zigbee, Powerline…
Avatar de Usuario
por
#287315
Programando la Placa de Desarrollo Mini-STM32 - I -
Presentación de la Mini-STM32 y borrado del programa Demo

Realizar proyectos con placas de desarrollo siempre ha sido mi asignatura pendiente, y hace poco me decidí a comenzar con este tema. Para ello busqué información en la red y al final me decanté por una Mini-STM32, equipada con un microcontrolador STM32. Según un compañero italiano de un foro de física era potente y fácil de programar, con un muchas ayudas disponibles y completas herramientas de software a su disposición ...O al menos ésta era la teoría, porque después de recibir la la placa, y a pesar de haber estudiado y trabajado en temas informáticos durante muchos años, no supe ni por donde empezar.

Esto fue ni más ni menos lo que me ocurrió hace una semana, cuando recibí la flamante Mini-STM32, que pese a ser un modelo de gran venta, la realidad es que apenas hay información de nivel básico disponible en Internet, y menos aún si nos remitimos al mundo hispanohablante. Por suerte, en los primeros intentos de programación recibí la ayuda de Francisco Javier y de Melchor, dos compañeros expertos en el tema que conocí a través de la red y cuyos consejos me permitieron superar el bloqueo en que me encontraba. Y tal vez para devolver una parte de este gesto he decidido comenzar una relación de mis experiencias con la Mini-STM32, en la esperanza que puedan servir a otros para andar más rápidos por el mismo camino.

El realizar esta especie de tutorial básico también constituye para mí un proceso de aprendizaje. Por tanto iré paso a paso y sólo hablaré de aquellas cosas que o bien conozca de otros dispositivos parecidos o haya podido probar en éste, y como aún así corro el riesgo de interpretar algo de forma equivocada, agradeceré cualquier comentario al respecto.


La placa de desarrollo Mini-STM32

Realizadas estas aclaraciones, diré que la placa o módulo de desarrollo Mini-STM32 es una placa de bajo precio y buenas prestaciones construida alrededor de un microcontrolador STM32F103VC Cortex M3, de 32 bits, fabricado por ST Electronics. Dichos microcontroladores pertenecen a la popular familia de los ARM, con los cuales son compatibles, y son utilizados habitualmente en multitud de sistemas industriales, domésticos y de automoción.

Vista de la Mini-STM32 reproduciendo el programa de demostración

Imagen


Diferencias entre un microcontrolador y un microprocesador

¿Y cual es la diferencia entre un microcontrolador y un microprocesador, como por ejemplo el Pentium que equipa nuestros ordenadores? Pues la diferencia es básicamente el grado de integración de elementos dentro del mismo chip. Un microprocesador puede procesar datos digitales de acuerdo a un programa, pero necesita de una memoria externa RAM, de una ROM y de otra memoria para programas en flash o en disco duro. El microprocesador precisa además de otros chips de entradas y salidas (denominados normalmente PIO - Port Input / Output) que le permitan comunicarse con otros módulos, tanto de la misma placa como exteriores al ordenador, como una tarjeta grafica para la pantalla, un chip especial para las comunicaciones serie, otro chip de sonido, etc. En el microprocesador las funciones de cada uno de sus pines suele estar muy definido, agrupándose en forma de buses de datos, de direcciones y de control.

Un microcontrolador en cambio es casi como un pequeño ordenador y lo integra todo en el mismo chip, además de la unidad de proceso, contiene su propia memoria RAM, su ROM con un sistema de carga de datos y la memoria de almacenamiento de programas, normalmente de tipo Flash. En cuanto a sus pines, un alto porcentaje de ellos pueden ser configurados de forma indistinta como entradas o salida de tipos muy diferentes, ya que pueden por ejemplo controlar directamente un servo tipo radiocontrol, o el circuito driver de una sirena de alarma, o un display de LEDS, o leer el estado de un contacto o medir la tensión analógica de un sensor de temperatura.


El microcontrolador STM32F103VC

En nuestro caso concreto, el STM32F103VC es un pequeño chip de forma cuadrada tipo SMD alimentado a 3,3 volts. Dispone de 100 pines e integra en su interior 48 Kbytes de memoria RAM, 256 KBytes de memoria flash y funciona a una frecuencia de reloj de hasta 72 Mhz.

Como es habitual en los microcontroladores actuales, la mayoría de los pines pueden ser programados para que realicen distintas funciones, especialmente los que están agrupados en los cinco puertos (PA, PB, PC, PD y PE), de 16 líneas cada uno. Aparte de los pines utilizados por la propia placa que no están disponibles para el usuario, hay 2 de ellos que activan sendos LEDS de uso general y 2 a pulsadores también utilizables para cualquier función. Hay 30 pines no conectados y por tanto disponibles y configurables como entradas o salidas de distintos tipos, 16 de ellos pueden además actuar como entradas analógicas con conversor ADC de 12 bits, 2 como salidas analógicas tipo DAC, y también hay un cierto número de salidas de impulsos PWM modulados en duración, temporizadores y muchas otras funciones especiales que ya iremos descubriendo.
Por otra parte, los pines del microcontrolador, con o sin uso, están todos disponibles entre los conectores E/S superior e inferior.

De todas formas, si a alguien le empuja la impaciencia puede hallar una descripción más detallada de este micro en el manual de referencia del STM32, disponible en la web de ST Microelectronics, pero advierto que tiene alrededor de 1.000 páginas y su contenido es mucho más técnico que el nivel que de momento pretendemos asumir. También podríamos obtener información adicional de la placa en su conjunto acudiendo a la web del fabricante, en las direcciones: http://www.poweravr.com y http://www.powermcu.com , pero para ello necesitaríamos entender los caracteres chinos o confiar tal vez demasiado en la traducción automática de Google entre idiomas tan diferentes.

Por todo lo anteriormente expuesto ya intuimos que el controlador STM32 tiene una potencia y una versatilidad realmente notable para su tamaño, pero sobre todo esta placa se distingue de otras parecidas en que dispone de origen de un display LCD sensible al tacto de 320 x 240 pixels, capaz de representar 262.000 colores (64 niveles para cada color básico RGB).


Comprando la Mini-STM32

Y si buenas parecen las características de la placa en su conjunto, igual de bueno es su precio, ya que puede encontrarse en Internet por unos 30 €, como por ejemplo en la tienda on-line Micro4you (http://www.micro4you.com/store/mini-stm ... board.html), radicada en Tailandia, a lo que deberemos añadir unos 5 € por el envío aéreo hasta España.

El pago puede efectuarse por tarjeta de crédito o bien por Paypal, siendo ésta la opción que considero más segura porque te permite un lapso de 45 días para efectuar reclamaciones ante problemas imprevistos. Por el bajo importe del envío no hay retención por parte de aduanas, y sin ser rápido raramente tarda más de 15 días, lo cual entra dentro de lo razonable.

Y hechas las presentaciones de rigor, pasemos a ver nuestra pequeña maravilla:


Mostrando las partes de la Mini-STM32

En la imagen que viene a continuación, en que la placa a aparece con un tamaño un 20% inferior al real, podemos ver los bordes de la placa base y la pantalla LCD en primer término. En la parte alta hay dos bases mini-USB, pero sólo el de la izquierda es un USB 2.0 real, ya que el de la derecha es en realidad una entrada serie RS-232 que usa la tecnología USB para pasar las señales entre la placa y el ordenador.

Las versiones anteriores de esta placa venían equipadas con el típico conector serie DE9, de 9 pines, montado en un lateral, pero resulta que aparte de la deficiente estética funcional por su tamaño, hoy en día ya no se venden ordenadores con salida RS-232 y también son cada vez menos los que quedan funcionando en nuestras casas. Por este motivo, en la parte del ordenador se utiliza una solución de compromiso que consiste en convertir uno de sus USB en un puerto COM virtual, y por tanto generador de señales RS-232, siendo la recepción en la placa Mini-STM32 un conector también USB pero que conduce la señal a un chip convertidor PL2303HX, cuya misión es traducir de nuevo las señales de falso USB en las normales RS-232, las cuales ya son aprovechables directamente por el microcontrolador.

Descripción de los elementos de la placa

Imagen


Esta conexión RS232-USB entre el ordenador y la placa la utilizaremos para borrar los programas contenidos en la memoria flash y sustituirlos por otros que deseemos.

Aparte de este detalle, distinguimos 4 LEDS situados en las cuatro esquinas, y serigrafiados de LD1 a LD4, cuya función es la siguiente:

LD1 Pertenece al USB, puede utilizarse para pruebas, aunque su labor normal es indicar la transferencia de datos a por el USB
LD2 LED de Power. Se enciende siempre que la placa tenga tensión de 5 volts, presente en uno de los pines del conector USB
LD3 LED de uso general, conectado a una salida del chip como indicador de lo que deseemos
LD4 Igual que el anterior, LED de uso general

En la franja inferior podemos ver cuatro pequeños botones. Comenzando por la derecha son:

Reset Efectúa un reset al microcontrolador. Si estaba en modo de carga de programa, pasa a modo de ejecución
Boot Abreviatura de "Boot Loader". Apretado junto con el al botón anterior, coloca la placa en modo de "carga de programa"
KeyB Pulsador de uso general, perteneciente al puerto B, para introducir órdenes en el programa
KeyA Pulsador de uso general, perteneciente al puerto A, para introducir órdenes en el programa

Parte trasera de la Mini-STM32

Imagen


En la parte trasera de la placa principal sólo es distinguible el conector para una tarjeta de memoria MiniSD, del mismo tipo que utilizamos en las tablets y en las cámaras de fotos digitales, capaz de almacenar una gran cantidad de datos.

A parte de los elementos que hemos descrito en la primera imagen, aquí también son visibles tanto arriba como abajo de la placa las líneas E/S (entradas salidas) del microcontrolador, donde de acuerdo al programa que corra en su interior, deberemos conectar el resto del hardware que la placa pretenda controlar en nuestros proyectos, como sensores, motores, etc.

Si ahora quitamos los cuatro tornillos que sujetan la placa del LCD y la extraemos con cuidado de no doblarla ni forzar los contactos (ya que su único conector de 34 pines está situado en su parte izquierda), podemos ver la totalidad de la placa principal, donde descartando los elementos periféricos que ya hemos descrito, distinguimos el microcontrolador central y otros componentes SMD. A la izquierda vemos el alojamiento para una pila de litio tipo DL1220, de 3 volts, destinada a mantener el funcionamiento del reloj interno en tiempo real, y en la derecha el chip PL2303HX que "traduce" los datos USB en RS232, y un conector denominado JTAG, acrónimo de Joint Test Action Group, y que puede servir desde la comprobación en fábrica de la integridad de la propia placa hasta como sistema de depuración de código, aunque en estos momentos no sabría dar más información al respecto.

La tensión de alimentación del microcontrolador, así como de la mayoría de elementos del circuito es de 3,3 Volts, pero en las pruebas normales la obtendremos a partir de los 5 Volts del USB del ordenador. La reducción la efectúa un integrado estabilizador, que tiene la forma de un pequeño transistor, situado al lado del conector JTAG.

El microcontrolador y algunos elementos de la placa base

Imagen


La placa del LCD no tiene muchos secretos, a parte del propio display de cristal líquido, distinguimos un diminuto integrado asociado al mismo y una serie de contactos sin soldar denominados CNB que son una continuación de los contactos, pin a pin del conector de entrada CNA que une esta placa a la principal.

Parte trasera de la placa del LCD

Imagen



Borrando el programa Demo

Bien, ya hemos visto un poco por encima la placa Mini-STM32 que acabamos de recibir, y como estamos impacientes por ver que hace. Tomamos el corto cable USB que la acompaña como único accesorio y lo enchufamos al conector CN3 (el tipo min-USB situado en la esquina superior derecha). Después, tomamos el otro extremo del cable y lo insertamos en una base USB de nuestro ordenador.

Al instante veremos como la pantalla se ilumina en rojo y nos pide que pulsemos en una serie de puntos para efectuar una calibración. Para pulsar usaremos algo tipo lápiz de material plástico duro, semejante al que utilizan las tablets o los ordenadores de mano tipo PAD. Nunca se deben utilizar herramientas metálicas o que puedan rayar la pantalla.

La calibración debe efectuarse porque el sistema de reconocimiento táctil es de tipo resistivo, cuya precisión no es tan buena como el capacitivo, y necesita encontrar los puntos de referencia correctos antes de comenzar a trabajar.

Después se iniciará un programa de demostración que nos muestra las posibilidades gráficas de la placa, con texto, barras de colores colores, cuadrados, círculos, ventanas tipo Windows y demás. Todo muy bonito para mostrar lo que hemos comprado, pero como nuestro interés es comenzar a programar la placa y entender sus entresijos, lo que de verdad debemos hacer es quitar dicho programa y entrar los nuestros, aunque de momento está claro que no tendrán comparación posible en cuento a vistosidad.


El software para comenzar a trabajar

Antes de comenzar con la primera prueba consistente el borrar el programa de demostración contenido en la placa, necesitamos una serie de programas que vamos a bajar:

1) Vamos a la web del vendedor de la placa, y en concreto a la pantalla de nuestro producto, Micro4you ( http://www.micro4you.com/store/mini-stm ... board.html ) y en el apartado "Software" pulsamos sobre "PL2303 USB to Serial Driver", lo cual nos lleva a la web de Prolific y de allí nos descargamos dos pequeños programas que guardaremos en una carpeta:

PL2303_Prolific_DriverInstaller_v1417.zip
PL2303DRemover_v1001.zip

El primero de ellos es un driver que una vez instalado en el ordenador reconocerá la placa cuando la conectemos a un USB y nos creará un puerto COM virtual, que puede ser cualquier número disponible (en uno de mis ordenadores ha sido el COM 7 y el otro el COM 4). El segundo programa, como su propio nombre indica, solo sirve como desinstalador del primero.

Hagamos entonces la prueba, instalamos el programita, conectamos la placa al ordenador y si abrimos el Mi PC > Propiedades > Hardware > Administrador de Dispositivos, deberemos ver como el el apartado "Puertos (COM y LPT)" ha aparecido el COM adicional.

Conectando el mini USB-RS232 de la placa con el USB normal del ordenador
Imagen


2) Ahora debemos bajar e instalar otro programa llamado "Flash Loader Demo", de ST Microelectronics, que puede conseguirse sin problemas en la propia web de la marca y en otros muchos sitios de Internet con sólo introducir el nombre en el Google. En caso de que si por alguna otra causa resulta difícil hallar dichos programas, pueden bajarse los dos de una vez, empaquetados en un archivo .rar, desde la siguiente dirección:

STM32setup.rar ( http://dl.dropbox.com/u/5592203/Progs/STM32setup.rar )

3) Ahora colocaremos la placa Mini-STM32 en modo Boot-Loader, o de carga exterior. Para ello apretamos simultaneamente los pulsadores "Boot" y "RST", y manteniendo el primero pulsado, soltamos el segundo. Observaremos como en el display desaparece el programa demo que estaba corriendo y la pantalla se queda en un blanco de baja luminosidad.

4) Como ya tenemos instalado el Flash Loader Demo, lo arrancamos y ha de aparecernos la siguiente imagen:

Imagen

En "Port name" seleccionaremos el port virtual que nos haya creado el programa anterior, dejando sin cambiar el resto de cuadros. Apretamos "Next" y saltamos a la siguiente pantalla:

Imagen


Si el pequeño semáforo aparece en verde es que todo ha ido bien y se ha establecido la comunicación entre la placa y el ordenador. Pulsamos de nuevo "Next"

Imagen


Aquí nos aparece una pantalla de selección e información sobre la memoria flash de la placa, datos que por ahora no vamos a usar. Apretamos "Next"

Imagen


En esta página están las acciones a realizar. La que está resaltada por defecto es la de "Erase", o borrado de la memoria, que puede ser total o de una parte que hayamos seleccionado. Bien, como de momento no tenemos necesidades demasiado específicas, procederemos a borrarla en su totalidad, dejando el botón "All" seleccionado. Pulsamos de nuevo "Next"

Imagen


Esta última página nos informa si el proceso se ha realizado con éxito, con la frase "Erase operation finished succesfully" o ha habido algún problema.


Problemas de reconocimiento de la placa con Windows 2000

En mi caso, este procedimiento ha funcionado bien y al primer intento en mi ordenador normal equipado con Windows XP y en otro con Windows 7, pero en cambio no he conseguido que andara más que una o dos veces de las veinte que lo he probado en otros dos ordenadores con Windows 2000. Aún no he podido determinar si el problema está en el sistema operativo con los COM virtuales o en alguna pijadita de configuración del hardware. Con los W-2000 he bajado la velocidad de los COMs para aumentar la seguridad de la transmisión y he probado las demás opciones de paridad, eco, etc, y sigue sin funcionar, y ya en la segunda página me aparece el semáforo en rojo y la indicación "Unrecognaized device...".

Pero bueno, en casa y con mi ordenador principal andando con XP me funciona, y como supongo que la mayoría ya dejasteis aparcado el W-2000 hace años, también debería funcionar en la vuestra. Si habéis llegado a la última pantalla del Flash Loader con la indicación de que el borrado se ha efectuado de forma satisfactoria, en la placa podéis pulsar el botón RST de la esquina inferior derecha, y con ello saldrá del modo "Boot Loader" y se colocará en ejecución, aunque en este caso, al haber borrado el programa, no va ha hacer absolutamente nada.


Descargando más software e información de utilidad


En la próxima entrega intentaremos realizar nuestro primer programa, cargarlo y ejecutarlo, pero de momento no estaría de más repasar todo lo anterior mientras regresamos a la web del vendedor Micro4you (http://www.micro4you.com/store/mini-stm ... board.html) y descargamos el software y la información que tan amablemente nos regala y que nos será útil en el futuro:

Del software descargaremos:

- Keil RealView MDK (Potente entorno IDE de programación en C, aunque es una versión de evaluación limitada a programas de 34 Kbytes)
- PL2303 USB to Serial Driver (que ya tenemos por haberlo descargado antes)
- Sample Code (ejemplos de código para las distintas opciones del microcontrolador)
- Update Sample Code 2011 (V1.5) (actualización de los ejemplos)
- Update Sample Code 2011 (1.18) (actualización de los ejemplos)

En la documentación en PDF:

- Mini STM32 STM32F103 TFT LCD Board Schematic (esquema completo de la placa)
- 3.2 TFT LCD Schematic (esquema del módulo LCD)
- TSC2046 Datasheet
- SSD1289 Datasheet
- All Chip Datasheet


Continuará...
Última edición por Anilandro el 01 Dic 2011, 12:47, editado 1 vez en total
Avatar de Usuario
por
#287339
Contenido
¡Jodó! Esto sí que es un aporte y lo demás es tontería. :yep :plas
por
#287340
Contenido
yo en previsión de previsible borrado ya me lo he copiadopegado a un word. Que me quiten lo bailao. Ahora, veo que el tft es de 3,2 inches, no? no las hay mas grandes? con un 7 inches sería la poia....
Avatar de Usuario
por
#287342
Hola a todos

Este texto es sólo la primera "entrega" del tutorial que estoy desarrollando sobre esta placa, en los días siguientes iré añadiendo otros. Lo que sí he visto es que me equivoqué en el precio de la placa, no son 30€, son 36€.

Por cierto LuisM, dices "en previsión de previsible borrado"... ¿Es que la aportación no es correcta? ¿En mi primera entrada he infringido alguna norma del foro? Porque después de haber encontrado un sitio en que los temas se tratan seriamente, lo cual es muy infrecuente en Internet, me sabría mal que así fuera.

Por cierto, no he visto placas con este microcontrolador y LCD de mayor tamaño, lo cual implicaría más tamaño total y más memoria de vídeo, pero seguro que buscando en la red puede encontrarse algo.

Un saludo
Última edición por Anilandro el 29 Nov 2011, 14:41, editado 1 vez en total
por
#287343
Anilandro escribió:Hola a todos

Este texto es sólo la primera "entrega" del tutorial que estoy desarrollando sobre esta placa, en los días siguientes iré añadiendo otros. Lo que sí he visto es que me equivoqué en el precio de la placa, no son 30€, son 36€.

Por cierto LuisM, dices "en previsión de previsible borrado"... ¿Es que la aportación no es correcta? ¿En mi primera aportación he infringido alguna norma del foro? Porque después de haber encontrado un sitio en que los temas se tratan seriamente, lo cual es muy infrecuente en Internet, me sabría mal que así fuera.

Por cierto, no las he visto con LCD de mayor tamaño, lo cual implicaría más tamaño total y más memoria de vídeo, pero seguro que buscando en la red puede encontrarse algo.

Un saludo


No... por mi está mas que perfecto.. pero últimamente andan los cuchillos algo largos por los pasillos... y alguien podría estar pensando que esto es publicidad... pero insisto, por mi está mejor que bien. Te has metido en un buen berenjenal para ser el primer contacto con este mundo. Yo tiré de cabeza hacia los arduinos, porque la cantidad de recursos y de información es infinita. Pero no obstante, me ha encantado la placa esta, no la conocía.
Avatar de Usuario
por
#287348
Contenido
No Anilardo, no. Creo que no incumples ninguna norma del foro, más bien quizá todo lo contrario. :wink Lo que pasa es que últimamente ha habido alguna "movida" y estamos todos un tanto..., cómo diría yo,... susceptibles, digamos.

En fin, que gracias por la aportación y esperamos que sigas así en el futuro. Gente como tú es la que enriquece en este foro (y no "trolls" como LuísM y yo mismo :burla ... :partiendo2 )

Saluti :cheers
Avatar de Usuario
por
#287357
Pues no me imagino que alguien pueda pensar que este trabajo es propaganda de ningún tipo. Pero aún sin conocer este foro entiendo lo de las susceptibilidades. De hecho, durante un año he sido moderador de un foro de ciencia y si algo he aprendido, es que si frente a los problemas se va cediendo una y otra vez para evitar las críticas o que te tachen de autoritario, las cosas acaban por desbordarse y luego siempre es peor, se te llena el sitio de verdaderos trolls, de fantasmas que pretenden hacer ver lo que no son ni saben, de oferentes compulsivos de consejos que te dicen como ellos lo habrían hecho mejor (naturalmente, si alguna vez se dignaran a hacer algo), de adeptos a las energías gratis, de autogeneradores de hidrógeno y "milagrosos" motores a imanes que dan presuntamente más de lo que gastan, de adoradores del lado oscuro de Tesla y de conspiranóicos de todo tipo. Es lo que tiene Internet y sus puertas abiertas.

Por este motivo este foro me ha causado buena impresión, porque siendo evidente que no todos sus participantes son ingenieros (yo por ejemplo sólo me quedé en "proyecto" de teleco en la Bonanova de principios de los setenta) creo ver profesionalismo y ganas de hacer las cosas bien.

Mañana colgaré la segunda parte del tutorial de la Mini-STM32.

Un saludo
Avatar de Usuario
por
#287359
Contenido
Anilandro escribió: de adeptos a las energías gratis, de autogeneradores de hidrógeno y "milagrosos" motores a imanes que dan presuntamente más de lo que gastan, de adoradores del lado oscuro de Tesla y de conspiranóicos de todo tipo.
Uffff.. pos aqui también tenemos de esos... no veas.. desde borricos a modo de noria, a electrolisis en fosas oceánicas...


Por cierto.. excepcional aporte, muchas gracias.. :plas y bien venido al foro..
Avatar de Usuario
por
#287392
Programando la placa de desarrollo Mini-STM32 - II
Los entornos IDE y haciendo parpadear los LED


Conseguir el parpadeo de uno o varios LED suele ser de las primeras pruebas que se llevan a cabo cuando se aprende a programar una placa microcontrolada, y en eso vamos a meternos en esta página, pero antes es necesario hablar un poco sobre programación, recordar cuatro generalidades y también presentar el programa que utilizaremos para llevarla a cabo.

Otra cosa que debemos tener en cuenta es que una placa de desarrollo no se parece demasiado a un ordenador corriente, del cual los usuarios podemos desconocer por completo su estructura interna y en cambio manejar a la perfección los programas a través del teclado y la pantalla. Un módulo de este tipo es totalmente dependiente de la circuitería asociada, de tal forma que para realizar el simple ejercicio de encender un LED será imprescindible saber donde y cómo está conectado, y tanto en las pruebas como en el desarrollo de proyectos más de una vez será necesario diseñar y construir pequeños circuitos auxiliares para adaptar los sensores o los actuadores a las características y limitaciones del microcontrolador.

Por todos estos motivos, es necesario que quien quiera meterse en el tema conozca los rudimentos de la programación en C, pero también deberá tener algunos conocimientos de electrónica y de manejo de las herramientas e instrumentos asociados a esta disciplina.

======================================================

Consideremos por un momento que hemos resuelto el problema de la conexión del LED y sabemos perfectamente a que pin de salida del microcontrolador está conectado, y pensemos ahora como podía ser un programa capaz de hacerlo parpadear. Sin duda deberemos escribir una orden para dar tensión a dicho pin, mantenerla durante un cierto tiempo, tras este lapso quitarle la tensión, esperar el mismo tiempo y volver a repetir el ciclo desde el principio.

Secuencia de un programa para hacer parpadear un LED

Orden --- Acción --- Resultado
1 --- Suministrar tensión al LED (El LED se enciende)
2 --- Esperar un poco (El LED permanece encendido)
3 --- Cortar tensión al LED (El LED se apaga)
4 --- Esperar un poco (El LED permanece apagado)
5 --- Regresar al punto 1 (Se repite todo el ciclo anterior)

Estas órdenes son lógicas y fáciles de entender para nosotros... pero por desgracia no hay manera de cargarlas en la placa para que el microcontrolador las ejecute, ya que estos chips poseen un juego de órdenes muy determinado y mucho más preciso que nuestras formas corrientes de expresión. Las órdenes o instrucciones que puede ejecutar un dispositivo semejante se agrupan en lo que llamamos un "lenguaje de programación".

¿Y cómo sería programar con un lenguaje semejante...? Pues en la práctica como entrar en la Torre de Babel, ya que cada modelo de microcontrolador tiene el suyo propio, que a lo sumo será similar entre chips evolucionados de modelos anteriores, pero puede ser muy diferente al cambiar de tipo, de marca o de tecnología de fabricación.

Esto podría ser algo preocupante, y es el problema con que se encontraban los programadores de los primeros ordenadores. Por este motivo se trabajó para encontrar una solución hasta desarrollar los denominados "compiladores". Expliquemos cuatro cosas al respecto.

======================================================

Lenguajes de bajo y alto nivel

Hay muchos lenguajes de programación. Seguro que todos habréis oído hablar en alguna ocasión del Código Máquina, del Asembler, del Fortran, del Basic, del Visual Basic, del Pascal, del Java o del C, pero hay un factor determinante que diferencia los dos primeros de todos los demás.

El Código Máquina y el Asembler son calificados como lenguajes de bajo nivel, y están formados por órdenes muy escuetas, operaciones de deplazamiento en números binarios, conteos ascendentes o descendentes, escritura o lectura de bits en memorias-registro, comparaciones booleanas tipo OR, AND o NOT, etc. De hecho el Código Máquina y el Asembler son lo mismo, simplemente que el primero adopta la forma de listas interminables de números binarios y el segundo los sustituye por una representación algo más amable mediante iniciales, palabras abreviadas y números hexadecimales, que conocemos como lenguaje Asembler o Ensamblador.

Ejemplo de un corto fragmento de lenguaje ensamblador correspondiente a un microcontrolador PIC

org 0x00 ; aquí comienza el micro.-
goto Inicio ; salto a inicio del programa.-
org 0x05 ; origen del código del programa.-
bsf STATUS,RPO ; pasamos de Banco 0 a Banco 1
movlw b' 11111' ; Muevo 11111 a W.-
movwf TRISA ; cargo en TRISA
movlw b' 11111'
movlw TRISB
bcf STATUS,RPO ; Paso del Banco 1 al Banco 0
bcf PORTB,Led ; Comienza el apagado

Estos lenguajes no entienden de frases escritas ni procesadores de texto, ni de operaciones con números decimales o de mover una imagen en una pantalla o conectarse a Internet, sólo tratan con bits de información, con señales en un punto que representan un 1 si hay tensión eléctrica y un 0 si no la hay.

El Código Máquina y su alter ego el Asembler son los lenguajes primarios de los microprocesadores y microcontroladores, y la dificultad que implica su uso no sólo deriva de la complejidad o la extensión de sus programas cuando necesita efectuar funciones gráficas o matemáticas, sino también porque son exclusivos para cada modelo de chip. En contrapartida, su ventaja es la gran velocidad y el ahorro de memoria que permiten. Si necesitamos que un microcontrolador procese muy rápido la información que le entra, como por ejemplo la procedente de señales de audio o de vídeo, es necesario que no pierda tiempo en operaciones o comprobaciones inútiles, y eso se consigue con un código máquina eficiente y lo más reducido posible.

El resto de los lenguajes citados, desde el Fortran al C, son llamados "lenguajes de alto nivel", y poseen instrucciones capaces de realizar funciones muy complejas, como cargar un fichero desde un disco a una memoria, mostrar una imagen a color en una pantalla, o permitir que el usuario le entre un número, multiplicarlo por pi, efectuar su raíz cuadrada y escribir el resultado final en la ventana de un programa. Y aunque estos lenguajes también tienen sus dificultades, muchas de sus órdenes adoptan la forma de palabras que describen la acción, aunque por supuesto en inglés:

======================================================

Ejemplos de instrucciones de lenguajes de alto nivel

Instrucciones y acción que realizan

Load (Carga un archivo completo)
Save (Guarda un archivo completo)
Let A = 3 (Deja que la variable A tenga el valor 3)
IF X<6 Then Print "Hola" (Si X es menor que 6, entonces imprime "Hola")

La consecuencia es que mientras los lenguajes de bajo nivel están casi exclusivamente reservados a expertos, ya que su programación llega a ser compleja, tediosa y muy proclive a contener errores, los lenguajes de alto nivel pueden ser utilizados por la mayoría de las personas con una mínima formación.

Sin embargo, ya hemos dicho que sólo el lenguaje máquina es entendido por el microcontrolador, y por tanto, cualquier programa de alto nivel, que también llamaremos "código fuente", deberá ser "traducido" a bajo nivel antes de ser cargado. Esta función la efectúa el "compilador", con la ventaja adicional que no deberemos preocuparnos por los diferentes códigos máquina, porque el propio compilador ya dispone en su interior de los "diccionarios" adecuados para traducir el código fuente de entrada al código máquina de cada tipo de microcontrolador.

En la programación de alto nivel destinada a microprocesadores se utilizan todos los lenguajes antes citados y una veintena más para usos más específicos, pero en el caso de los microcontroladores el lenguaje utilizado es casi en exclusiva el C.

¿Y porqué en C y no en Visual Basic o en Pascal? Pues porque el C es un lenguaje algo especial, mediante el cual, con órdenes sencillas podemos cargar no sólo una imagen en pantalla o crear matrices de datos, sino que también efectuar funciones típicas del Código Máquina, como trabajar con bits individuales, con operaciones booleanas y acceder directamente a elementos del hardware o a posiciones de memoria. El C es potente y rápido a la vez, tal es así que muchos otros lenguajes están escritos interiormente en C, así como la mayor parte de los sistemas operativos como el Windows, el Linux o el Unix.

======================================================

Los IDE o Entornos Integrados de Desarrollo

Para programar en C utilizaremos programas llamados IDE (Entorno Integrados de Desarrollo), que consisten en una serie de herramientas unidas en un mismo paquete, que nos permiten escribir el código en C, corregir la sintaxis, añadir la librerías necesarias, compilar y depurar el código asembler resultante, e incluso cargarlo en el microcontrolador.

Hay bastantes programas IDE, la mayoría de pago, como el Keil uVision, el Atollic TrueStudio o el CrossWorks, aunque también pueden encontrarse soluciones de código libre como el Coocox o el Yagarto.

Para esta práctica del tutorial utilizaré el Keil microVisión en su versión gratuita de evaluación, que pese a estar reducida a compilaciones de 34 KBytes, nos basta perfectamente para nuestros propósitos, y el motivo es que todos los ejemplos de software que suministra el vendedor de la placa están en este formato de proyectos. Otro IDE que también veremos en futuras páginas será el Coocox, más sencillo de utilizar y que además suministra mucha información útil sobre órdenes y librerías.

======================================================

Instalación del Keil uVisión V4.22

El Keil uVision es otro de los archivos que habremos bajado de la web de Micro4you en el "Ejercicio 1", en concreto el archivo "mdk422.exe", de 414 Mbytes. Este considerable tamaño, teniendo incluso en cuenta que es un fichero comprimido autoextraible, es debido a que contiene muchas herramientas, información y librerías para los distintos microcontroladore ARM.

Sin perder más tiempo clicamos sobre el fichero mdk422.exe y procedemos a instalarlo en nuestro ordenador.

Anagrama de arranque del IDE Keil uVision 4.22
Imagen

Una vez instalado, vemos que la interface es clásica y discreta, pero eso es tan engañoso como puede serlo en el Photoshop, ya que el uVision V4 es un programa complejo y de grandes posibilidades, la mayoría de las cuales no utilizaremos pero otras las iremos descubriendo a lo largo de las próximas páginas. Así que ahora no vamos a meternos en grandes explicaciones, porque lo siguiente será cargar el primer ejemplo y comenzar a trabajar.

======================================================

Cargando el primer ejemplo

Los ejemplos están contenidos en los archivos...

- Mini STM32 V4 Code.rar
- Mini STM32 V4 2011.1.5.rar
- Mini STM32 V4 2011.1.18.rar

...Que también habíamos bajado en la página anterior de este tutorial. De ellos elegiremos el Mini STM32 V4 2011.1.5.rar que parece el más actualizado, lo descomprimimos y abrimos la carpeta resultante HY-MiniSTM32V 2011.1.5, cuyo contenido son las 19 subcarpetas siguientes:

- WWDG, USB-Mass_Storage-SD Card, USART, uCOSII2.91+UCGUI3.90A(FSMC), uCOSII2.91, TouchPanel, TIM, Temp, SysTick, RTC+USART, PWR, IWDG, ID, GPIO, FreeRTOSV6.1.0, Flash, FATFS V0.08A-SD Card, EXTI+USART

Elegiremos la GPIO, la abrimos, seleccionamos MDK-ARM y el archivo Project.uvproj. Al instante se nos abrirá el Keil uVision mostrándonos una estructura de carpetas a la izquierda y otra mucho más ancha a la derecha con un fichero de texto ilegible. Esto no nos ha de preocupar, porque posiblemente dicho archivo está escrito originalmente en ideogramas chinos y nuestro sistema no lo sabe interpretar, así que lo cerramos apretando sobre la pestaña superior "readme.txt", con botón derecho del ratón y Close. Después, en la columna de la izquierda abrimos la carpeta USER y el archivo main.c , el cual nos aparecerá con su propia pestaña en la ventana derecha.

Interface del Keil uVisión 4.22, con el primer programa de ejemplo que hará parpadear un LED
Imagen

La palabra "main", en inglés, significa "principal" y de hecho el listado así denominado representa el "programa principal" que va a ejecutarse, aunque este "main.c" también depende de otros archivos que contienen las definiciones de las órdenes que va a usar. Estos archivos se denomina "librerías" y tienen la forma de un nombre seguido de la extensión .h

A causa de esta dependencia, cuando se escribe un "main" en necesario incluir las librerías de que depende. Por ejemplo, en el "main" que estamos viendo, la instrucción #include "stm32f10x.h" indica en esta librería están las órdenes que después van a usarse, de manera que cuando arranquemos la compilación, no sólo va a procesarse el "main", sino también el "stm32f10x.h" , y ambos serán después "linkados" o unidos para formar el archivo ejecutable final.

Sigamos. El texto completo de "main.c",después de limpiarlo un poco de comentarios (escritos en verde entre los indicadores /* y */) para que no nos ocupe tanto espacio, tiene el siguiente aspecto.

======================================

#include "stm32f10x.h"
/*--------------Private functions ---------------*/
void GPIO_Configuration(void);
void Delay (uint32_t nCount)
{
for(; nCount != 0; nCount--);
}
/*----------------------- main -------------------------*/
int main(void)
{
GPIO_Configuration();
/* Infinite loop */
while (1)
{
/* LED1-ON LED2-OFF */
GPIO_SetBits(GPIOB , GPIO_Pin_0);
GPIO_ResetBits(GPIOB , GPIO_Pin_1);
Delay(0xfffff);
Delay(0xfffff);
Delay(0x5ffff);
/* LED1-OFF LED2-ON */
GPIO_ResetBits(GPIOB , GPIO_Pin_0);
GPIO_SetBits(GPIOB , GPIO_Pin_1);
Delay(0xfffff);
Delay(0xfffff);
Delay(0x5ffff);
}
}
void GPIO_Configuration(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB , ENABLE);
/* LED1 -> PB0 LED2 -> PB1 */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
#ifdef USE_FULL_ASSERT

======================================

Sin meternos ahora en explicaciones del cómo y el porqué, veo que este programa activará y desactivará de forma alternativa los Pins 0 y 1 del bus B del STM32. Entonces, abrimos el archivo "Mini STM32 STM32F103 TFT LCD Board V4.pdf" que contiene el esquema de la placa Mini-STM32 (archivo que ya habíamos bajado anteriormente de la web del vendedor), y en la parte del diagrama de las páginas 2 y 3 que reproducimos debajo, observamos que estos pins están conectados respectivamente a las etiquetas LED1 y LED2, que a su vez, a través de sendas resistencias alimentan los leds serigrafiados en la placa como LD3 y LD4, los cuales, evidentemente, también centellearán.

Parte del esquema de la placa Mini-STM32, que muestra las conexiones desde los Pines 0 y 1 del bus B, hasta los leds LD3 y LD4
Imagen

Imagen

Ahora que ya sabemos que hace, vamos a compilar el programa y después lo cargaremos en la placa siguiendo esta secuencia:

1) De la etiqueta Projet apretamos Build Target (o F7). Vemos que se abre una ventana en la parte inferior y comienza a compilar una serie de ficheros.

2) La primera vez tarda bastante, ya que no solo ha de hacerlo con el main.c sino con todas las librerías que éste utiliza. Después, cuando acaba, la penúltima fila nos indica "FromELF: creating hex file..." y la última si ha habido errores o avisos, en este caso "0" en ambas cosas.
El compilador nos ha creado un archivo ejecutable para el microcontrolador y lo ha guardado en la carpeta Obj del proyecto que hemos abierto. Antes de compilar por primera vez, esta carpeta estaba vacía, pero ahora hay muchos archivos, y entre ellos uno denominado Project.hex, que es ni más ni menos el ejecutable que hemos de cargar en nuestra placa.

3) Ahora conectamos nuestra MiniSTM32 al ordenador, la colocamos en modo de carga de programas (ver la página anterior para hacerlo) y abrimos el Flash Loader Demostrator.

4) Las dos primeras pantallas de la ventana del programa serán iguales que cuando borramos el programa Demo de la Mini-STM32, pero al llegar a la tercera hemos de marcar "Download to device" y después seleccionar ficheros tipo ".hex" y en concreto " el fichero Project.hex que hemos creado antes.

Imagen

Imagen

5) Le damos al "Next". La siguiente pantalla nos indicará el origen y tamaño del archivo cargado (1,2 KB) y la indicación en verde "Download operation successfuly" que la carga ha sido correcta.

Imagen

6) Ahora apretaremos el botón Reset de la placa y... Oh maravilla... ya tenemos a los dos LEDS de la parte inferior destelleando de forma alternativa.

======================================================
Mejorando lo presente, vamos a crear nuestro primer programa

Antes he dicho que el programa anterior me parecía enrevesado, y no es que sea incorrecto bajo el punto de vista de un programador, es solamente que como ejemplo parece hecho a propósito para despistar a quienes no tengan un buen nivel de C. Por este motivo, sin que en ningún momento tenga interés en iniciar un curso de programación de este lenguaje, he decidido crear mi propio programa para luego poder explicar más fácilmente algunas órdenes concretas para manejar este microcontrolador.

Borro el contenido de main.c y escribo este nuevo listado:

======================================

/*Mini-STM32 encendido alternativo de dos leds*/
/* by Anilandro, octubre 2011*/

#include "stm32f10x.h" /*incluye la librería "stm32f10x.h"*/
GPIO_InitTypeDef GPIO_InitStructure;

int main(void){ /*inicio del programa principal*/

int cont; /*definimos una variable llamada "cont", de tipo entero*/

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; /*establece velocidad a 50 Mhz*/
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; /*establece modo de salida digital*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1; /*aplicar lo anterior a PIN 0 y 1*/
GPIO_Init(GPIOB, &GPIO_InitStructure); /*cerrar*/

while (1){ /*bucle infinito*/
GPIO_SetBits(GPIOB , GPIO_Pin_0); /*coloca el PIN 0 a valor alto (enciende el LED 1)*/
GPIO_ResetBits(GPIOB , GPIO_Pin_1); /*coloca el PIN 0 a valor bajo (apaga el LED 2)*/
for(cont=0; cont<1000000; cont++); /*bucle de espera que cuenta un millón de pasos*/
GPIO_ResetBits(GPIOB , GPIO_Pin_0); /*coloca el PIN 0 a valor bajo (apaga el LED 1)*/
GPIO_SetBits(GPIOB , GPIO_Pin_1); /*coloca el PIN 0 a valor alto (enciende el LED 2)*/
for(cont=0; cont<1000000; cont++); /*bucle de espera que cuenta un millón de pasos*/
} /*final de bucle "while" que vuelve al principio*/
} /*final del programa principal*/

======================================

Una vez acabado, coloco la placa en modo boot-loader, arranco el Flash Loader Demonstrator y cargo el nuevo programa, que funciona a la primera. Los leds parpadean de forma alternativa, aunque con una cadencia algo más rápida que la anterior debido a los diferentes valores de los bucles de espera.

Para quien desee repetir la prueba, lo cual aconsejo si sigue este tutorial, bastará que seleccione el texto del recuadro y lo copie en su espacio "main.c" una vez borrado el texto anterior. Como estos ficheros son sólo de texto, a partir de este momento es igual que si lo hubiéramos escrito directamente en la ventana del Keil

======================================================

Explicando el funcionamiento del nuevo programa

Con los comentarios contenidos entre /*...*/ del programa anterior creo que ya es posible hacerse una idea de cómo actúa el programa, pero la cosa estará más clara si concretamos un poco más.

El programa está escrito en varios bloques claramente diferenciados:

#include "stm32f10x.h"
GPIO_InitTypeDef GPIO_InitStructure;
int main(void){


La primera línea incluye la librería que contiene las órdenes a usar, la segunda una llamada a una estructura de órdenes y la tercera el comienzo de la rutina principal. La primera instrucción "#include "stm32f10x.h" incluye la librería donde están las órdenes que vamos a utilizar, aunque ello no significa que tales órdenes estén físicamente dentro de esta librería, porque a su vez ésta también puede tener otros "#include". La línea GPIO_"InitTypeDef GPIO_InitStructure;" se refiere a una estructura de variables (no preguntemos ahora que es una estructura), las cuales serán utilizadas a continuación. Y "int main(void){" inicia la parte principal del programa.

int cont;

A continuación viene la declaración de variables. En este caso una sola que llamaremos "cont", y que es de tipo "int" o entera. Lo cual significa que dicha variable podrá contener números enteros entre -2.147.483.648 a 2.147.483.647. Dicha variable la utilizaremos como puntero de los contadores que nos permitirán establecer un tiempo de encendido y otro de apagado de los leds.

Ahora viene la parte que configura los "pins" del microcontrolador:

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;
GPIO_Init(GPIOB, &GPIO_InitStructure);


El STM32 dispone de 3 buses utilizables para periféricos:

- Advanced High-Performance Bus (AHB)
- Advanced Peripheral Bus (APB1) de velocidad hasta 36 MHz
- Advanced Peripheral Bus (APB2) de velocidad hasta 72 MHz

Normalmente estos buses están desconectados para que no consuman corriente. En este caso sólo usaremos pines del APB2, y para ello introduciremos la orden "RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);" que proporciona la adecuada señal de reloj.
Las tres siguientes órdenes establecen la velocidad a 50 Mhz, que el pin actuará como una salida en Push-Pull, y la tercera a que pines afectarán estos parámetros, en concreto vemos que afecta a Pin = GPIO_Pin_0|GPIO_Pin_1; , es decir, al Pin_0 y al Pin_1.

Esta parte se cierra con GPIO_Init(GPIOB, &GPIO_InitStructure); tras la cual ya no podemos seguir asignando pines, excepto que de nuevo cerremos con la misma instrucción, por ejemplo, las órdenes:

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1; /*asigna pin 0 y 1*/
GPIO_Init(GPIOB, &GPIO_InitStructure); /*cierra*/


Son equivalentes a:

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0; /*asigna pin 0*/
GPIO_Init(GPIOB, &GPIO_InitStructure); /*cierra*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1; /*asigna pin 1*/
GPIO_Init(GPIOB, &GPIO_InitStructure); /*cierra*/


Y finalmente encontramos las órdenes que encienden y apagan los LED, encerradas dentro de un bucle while (1){.......} que se repite infinitamente

while (1){
GPIO_SetBits(GPIOB , GPIO_Pin_0);
GPIO_ResetBits(GPIOB , GPIO_Pin_1);
for(cont=0; cont<1000000; cont++);
GPIO_ResetBits(GPIOB , GPIO_Pin_0);
GPIO_SetBits(GPIOB , GPIO_Pin_1);
for(cont=0; cont<1000000; cont++);
}


Aquí vemos las órdenes de encendido tipo GPIO_SetBits .... y las órdenes de apagado tipo GPIO_ResetBits . Formando dos grupos que encienden un LED y apagan el otro, e intercaladas entre los grupos la línea for(cont=0; cont<1000000; cont++); Que es un contador desde 0 a 1.000.000, y el tiempo que tarda en hacerlo es el que permanece encendido un LED y apagado el otro.

La sentencia for(cont=0; cont<1000000; cont++); hace lo siguiente:

1) Toma la variable cont y le asigna el valor 0 (cont=0;)
2) Comprueba si el valor de la variable es menor de 1.000.000 (cont<1000000;), si es menor, pasa al paso 3), si es igual o mayor sale del "for" y salta a la siguiente instrucción
3) Le suma 1 a cont y salta de nuevo al paso 2) (cont++)

Entonces, si nosotros alteramos el valor de la comparación de (cont<1000000;), y ponemos 2.000.000 ó 500.000, el tiempo de conteo, y por tanto de encendido de un LED y de apagado de otro, subirá al doble o bajará a la mitad.

La secuencia total de esta parte es:

1) - Activamos Pin_0 y por tanto encendemos el LED_1
2) - Desactivamos el Pin_1 y por tanto apagamos el LED_2
3) - Esperamos el tiempo de conteo
4) - Desactivamos Pin_0 y por tanto apagamos el LED_1
5) - Activamos el Pin_1 y por tanto encendemos el LED_2
6) - Esperamos el tiempo de conteo
7) - Volvemos al paso 1)

====================================================

Probando algunas variaciones


Las órdenes GPIO_SetBits(GPIOB , GPIO_Pin_x); y GPIO_ResetBits(GPIOB , GPIO_Pin_x); (siendo "x" cualquier número de Pin válido) No son las únicas posibles para poner los pins a 0 y a 1, también podemos utilizar:

GPIO_WriteBit(GPIOB, GPIO_Pin_x,Bit_SET); /*coloca el PIN 0 a valor alto (enciende el LED 1)*/
GPIO_WriteBit(GPIOB, GPIO_Pin_x,Bit_RESET); /*coloca el PIN 0 a valor bajo (apaga el LED 1)*/


A la vez, la librería "stm32f10x.h" es muy general, pero también podemos utilizar las librerías particulares para las órdenes GPIO, y por tanto podemos sustituir la orden #include "stm32f10x.h" por:

#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"


Aplicando estos cambios, nuestro programa "main.c" quedaría como:

======================================
/*Mini-STM32 encendido alternativo de dos leds*/
/* by Anilandro, octubre 2011*/

#include "stm32f10x_gpio.h" /*incluye la librería "stm32f10x_gpio.h"*/
#include "stm32f10x_rcc.h" /*incluye la librería "stm32f10x_rcc.h"*/
GPIO_InitTypeDef GPIO_InitStructure;

int main(void){ /*inicio del programa principal*/

int cont; /*definimos una variable llamada "cont", de tipo entero*/

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; /*establece velocidad a 50 Mhz*/
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; /*establece modo de salida digital*/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1; /*aplicar lo anterior a PIN 0 y 1*/
GPIO_Init(GPIOB, &GPIO_InitStructure); /*cerrar*/

while (1){ /*bucle infinito*/
GPIO_WriteBit(GPIOB, GPIO_Pin_0,Bit_SET); /*coloca el PIN 0 a valor alto (enciende el LED 1)*/
GPIO_WriteBit(GPIOB, GPIO_Pin_1,Bit_RESET); /*coloca el PIN 0 a valor bajo (apaga el LED 2)*/
for(cont=0; cont<1000000; cont++); /*bucle de espera que cuenta un millón de pasos*/
GPIO_WriteBit(GPIOB, GPIO_Pin_0,Bit_RESET); /*coloca el PIN 0 a valor bajo (apaga el LED 1)*/
GPIO_WriteBit(GPIOB, GPIO_Pin_1,Bit_SET);; /*coloca el PIN 0 a valor alto (enciende el LED 2)*/
for(cont=0; cont<1000000; cont++); /*bucle de espera que cuenta un millón de pasos*/
} /*final de bucle "while" que vuelve al principio*/
} /*final del programa principal*/

======================================

En la próxima entrega de este tutorial mostraremos otro entorno de programación IDE, el Coocox, veremos como utilizar botones para entrar órdenes al programa y montaremos alguna experiencia práctica algo más útil que encender y apagar un par de LEDs.

Continuará...
Avatar de Usuario
por
#287412
Contenido
Esto es un master del yunivers...
No sé de qué se trata, lástima no tener tiempo, pero los que lo utilizais parece que os es de valiosa ayuda...

Me alegro de que alguien entre en un foro y comparta tamaño logro....

Gracias Anilandro. Interesante tu sitio web.

:hi2 :comunidad
Avatar de Usuario
por
#287435
Contenido
MAZINGER escribió:No sé de qué se trata, ...


No está mal para un ITI en electrónica. :burla :burla
Avatar de Usuario
por
#287563
Programando la Placa de Desarrollo Mini-STM32 - III
El Coocox y las Entradas Digitales

En la página anterior de este mismo tema habíamos hablado un poco sobre programación, habíamos cargado el compilador KEIL uVIsión e incluso escrito un sencillo programa para hacer parpadear dos LEDs. También habíamos citado otros IDE o Entornos Integrados de Desarrollo interesantes, como el Coocox, un proyecto de software libre y gratuito que integra en un mismo entorno un módulo de programación y otro de depuración.

En esta página mostraré la instalación y uso básico del Coocox, así como un nuevo tipo de órdenes para nuestra Mini-STM32, como son las entradas digitales, mediante las cuales podemos controlar la ejecución de un programa para que realice una u otra función dependiendo del estado de la entrada.

Imagen

El Coocox es un proyecto GNU destinado a la programación de los microcontroladores ARM Cortex M3 y M0, así como de sus equivalentes de marcas como Atmel, Energy Micro, Texas Instruments, NXP, Nuvoton y los populares ST de Microelectronics.

El Coocox integra elementos como el compilador GCC, un entorno de desarrollo Eclipse, un programador autónomo de memoria flash y un asistente para generar código. Permite además el control de diversos adaptadores de depuración basados en hardware y también contiene gran cantidad de información y recursos, tanto internos como de la Red, para facilitar la programación a los principiantes en el tema de los microcontroladores.
Sin duda podríamos estar hablando de aspectos técnicos del Coocox y de cada uno de sus componentes hasta mañana, pero creo que lo más interesante es descargarlo, instalarlo en el ordenador y comenzar a trabajar con él.

Imagen

1) Vamos a la web de Coocox o lo descargamos directamente desde el enlace CoIDE ( http://www.coocox.org/Tools/CoIDE-1.3.0.exe )
2) Lo instalamos en nuestro ordenador ejecutando el CoIDE-1.3.0.exe

El archivo de CoIDE-1.3.0 es de 108 MBytes, que una vez instalados se convierten en 472 MBytes contenidos en la carpeta Coocox, radicada, a menos que le hayamos especificado otra ruta, en C:\.

Al arrancarlo, la primera pantalla que nos muestra es la siguiente:

Imagen

Con diversos espacios destinados a funciones que iremos descubriendo. Lo primero que hemos de hacer es seleccionar la marca concreta del microcontrolador que utilicemos, en esta caso ST.

Imagen

Aquí nos aparecen los tipos de controladores de ST Microelectronics Cortex M3 disponibles. Seleccionamos el nuestro, el STM32F103VC. A la vez, observamos como en la ventana de la derecha nos muestra las características concretas de este microcontrolador:

STM32F103VC Descripción:
- Los ST STM32F103VC operan a una velocidad máxima de 72 MHz y dispone de 48 KBytes de SRAM y 256 KBytes de memoria Flash.
- Parametros:
- Controlador para Flexible Static Memory FLASH de tipos SRAM, PSRAM, NOR y NAND.
- PLL, oscilador interno de 8MHz y 32kHz, reloj en tiempo real.
- 4 Syncronismos. Temporizadores de 16-bit con Captura de Entrada, Comparador de Salida y PWM.
- 2 temporizadores avanzados de 16-bi, 2 temporizadores básicos de 16-bit.
- 2 temporizadores Watchdog de 16-bits, Temporizadores y SysTick Timer.
- 3 SPI/I2S, 2 I2C, 5 USART, USB 2.0 "Full Speed Interface".
- CAN 2.0B Activo, 3 conversores A/D de 12-bit con 16 canales.
- 2 convertidores D/A de 12-bit, SDIO, 80 puertos I/O rápidos.
- Tensión de alimentación de 2V a 3.6 Volts

Para más información sobre este chip, consultar las "Chips pages" o el "Datasheet"
http://www.st.com/internet/mcu/product/221024.jsp
http://www.stmicroelectronics.com.cn/in ... 220364.pdf

Una vez seleccionado el modelo concreto de microcontrolador, en la ventana central nos aparecen las librerías compatibles con el mismo, sin que tengamos que ir a buscarlas en largas listas sin saber muy bien que necesitamos para complementarlas.

Imagen

En este caso concreto, repetiremos el programa que habíamos creado en el Keil uVisión para hacer parpadear dos LEDs. Para ello deberemos seleccionar la librería GPIO, observando como sólo dar un doble click con el puntero sobre la línea correspondiente en la ventana derecha nos mostrará las funciones contenidas en esta librería.
Esta información es de gran ayuda, ya que no sólo muestra un listado y una corta descripción, sino que además, pulsando sobre los enlaces de los nombres, nos aparece la función concreta con su sintaxis y los parámetros que acepta.

Otro detalle interesante de este programa es que al seleccionar una librería seleccionan también de forma automática otras dependencias necesarias. en este caso, al elegir GPIO también se han marcado la RCC, la CMSIS Boot y la CMSIS core.

Imagen

Sigamos con los detalles. Al seleccionar las librerías, si no tenemos ningún proyecto abierto, el programa crea uno de forma automática y nos pedirá el nombre del mismo (en este caso lo llamamos GPIO_01) . Las carpetas que lo componen y que más tarde utilizaremos aparecerán en el recuadro inferior izquierda.

Observemos también el pequeño recuadro superior de la izquierda en donde aparece un árbol con las librerías que hemos seleccionado, y el hecho que en algunas de ellas hay enlaces a ejemplos. Pulsemos para probar el enlace de la "GPIO (with 4 examples)". Como muestra la imagen siguiente se crea otro recuadro en la parte central con una relación que muestra estos 4 ejemplos y también enlaces adicionales de Internet sobre el mismo tema.

Imagen

Para ver los ejemplos seleccionamos con "view" el que más nos guste, como el "GPIOExample", y su listado aparecerá en una nueva pestaña que se creará en la ventana principal. Este listado no podemos editarlo, pero sí copiarlo en un documento de texto para poder utilizarlo después. Pulsando "add" también podremos añadirlo al proyecto que tengamos abierto en este momento.

Imagen

Estamos viendo las grandes facilidades didácticas que ofrece este programa, pero ahora aparquemos un poco esta descripción para crear nuestro primer programa. Cerramos la ventana de ejemplos central-superior y también la pestaña del ejemplo "GPIOExample". Después, en el recuadro inferior-izquierdo vamos hasta el penúltimo archivo visible "main.c" y pulsamos sobre él.

Imagen

Este archivo se abre en la ventana principal y si el proyecto es nuevo observaremos que salvo dos escuetas órdenes el resto está vacío. Pues bien, aquí podemos empezar a crear nuestro programa, o incluso copiar algún otro que tengamos guardado. Hacemos un "copia y pega" a partir del último programa que habíamos utilizado en el Keil uVisión.
Ahora este programa se ha convertido en el "main.c" o principal de el proyecto que tenemos abierto. En caso de haber errores, el propio Coocox nos lo indicará con una interrogante en el margen izquierdo de la línea afectada. Comprobamos que no hay problemas y para iniciar la compilación pulsamos el cuarto icono de la barra superior o el "Built" de la pestaña "Projet".

Imagen

En la parte baja se abre una nueva ventana que nos va informando de las incidencias de la compilación, la cual de realizarse sin incidencias, en el caso del archivo actual acabará con el mensaje:

Program Size:
text data bss dec hex filename
1524 0 1032 2556 9fc GPIO_01.elf

El compilador nos ha creado un archivo ejecutable que ahora cargaremos en la placa con el Flash Loader Demo, en el cual, al llegar a la pantalla de selección de archivo, deberemos buscarlo en:

1)- Entrar en: C:\CooCox\CoIDE\workspace\
2)- Allí veremos los proyectos existentes, seleccionemos el actual, en este caso GPIO_01
3)- Dentro de este proyecto seleccionamos \Debug\bin\
4)- Aquí seleccionaremos de forma indistinta el GPIO_01.hex o el GPIO_01.bin

Una vez cargado sin problemas en la placa Mini-STM32, apretamos el "Reset" y vemos como los dos LEDs comienzan a parpadear.

Si con Mi-PC entramos en la carpeta que contiene los programas .bin y .hex, veremos que también hay un fichero de texto GPIO_01.txt. Al abrirlo observaremos que es un listado del ejecutable anterior en lenguaje Asembler, el nativo del microcontrolador STM32, que ha creado el compilador del Coocox a partir de nuestro "main.c" y de sus librerías asociadas. Y recordemos lo dicho sobre lenguajes de bajo y alto nivel en la página anterior de este tutorial, ya que de programar en Asembler sería lo que nosotros deberíamos haber escrito para hacer lo mismo que hemos conseguido con unas pocas líneas de C.

Aprendiendo a gestionar las Entradas Digitales

La primera prueba de programación que realizamos consistió en crear un archivo "main.c" que hacía destellear dos LEDs. Esta función es una característica "Salida Digital", puesto que controlamos un periférico a todo o nada, o hay corriente y el LED se enciende, o no la hay y se apaga. De igual manera podríamos controlar circuito driver para activar un relé o un triac, y así poder encender luces, activar una sirena de alarma, abrir un portero automático o disparar un mecanismo cualquiera. La prueba siguiente, en cambio, consistirá en crear un programa que controle una "Entrada Digital" que actúe de señal para que el programa efectúe una u otra función. En este caso, esta señal la generaremos a partir de un pulsador de prueba integrado en la propia placa Mini-STM32.

Además, en este caso también añadiremos dos elementos más a la secuencia de destellos, un tercer LED que forma parte del circuito USB de la placa, y la propia pantalla del display, la cual aún no sabemos controlar a nivel gráfico pero que utilizaremos sólo como fuente de luz. Para conseguir todo esto antes debemos reunir la necesaria información.

1)- Abrimos de nuevo el documento PDF (http://dl.dropbox.com/u/5592203/Textos/ ... 0Board.pdf) del esquema de la placa. Recordemos que los LEDs LD3 y LD4 estaban conectados a los pins PB0 y PB1 del microcontrolador.

2)- El nuevo LED1 que haremos parpadear no está conectado directamente a un pin determinado, como los anteriores, sino que pertenece al circuito de monitorización del conector USB Device, el cual podemos ver en la parte superior-media de la página 3 del documento. El LED está asociado al transistor Q1, que al ser de tipo PNP conducirá cuando su base esté puesta a cero. Si miramos la etiqueta [USB_EN] asociada a la base y la seguimos hasta la página 2 del documento, observamos como está conectada al pin PB7 del microcontrolador.

3)- Volvemos a la página 3, en la parte central-izquierda y nos fijamos en el circuito y el conector marcado como LCD, y en concreto en la línea unida a la etiqueta [BL-CNT], que puesta a 1 enciende la pantalla del LCD y a 0 la apaga. Seguimos la etiqueta hasta la página 2, viendo que está conectada al pin PB5 del microcontrolador.

4)- Ahora pasamos de nuevo a la página 3 y en la parte arriba-derecha, en la zona rotulada como BUTTON, vemos dos pulsadores. Observamos como el denominado KEYB cierra sus contactos a positivo, dando un 1 en estado pulsado y 0 en estado normal, pero en cambio el KEYA, al cerrarse sobre masa, actúa en sentido contrario, dando 0 pulsado y 1 en normal. Elegiremos el KEYB, asociado a la etiqueta [USER_KEYB] que suponemos que también pertenece al bus PB, a igual que los dos pines anteriores. Después, mirando la página 2 vemos que, efectivamente, dicha etiqueta está conectada al pin PB2.

Resumiendo las salidas y entradas digitales que utilizaremos en esta prueba:

A)- Pin PB0, Salida Digital al LED3 (lógica directa 1 ON, 0 OFF)
B)- Pin PB1, Salida Digital al LED4 (lógica directa 1 ON, 0 OFF)
C)- Pin PB5, Salida Digital a encendido de fondo de pantalla LCD (lógica directa 1 ON, 0 OFF)
D)- Pin PB7, Salida Digital al LED1 (lógica inversa 1 OFF, 0 ON)
E)- Pin PB2, Entrada Digital del pulsador KEYB (lógica directa 1 ON, 0 OFF)

Tomando como referencia el programa anterior y los datos recientes, damos forma al siguiente archivo:

====================================
#include "stm32f10x_gpio.h"
#include "stm32f10x_rcc.h"

GPIO_InitTypeDef GPIO_InitStructure;

int main(void){
int ncount; /* definimos variable "ncount" para conteo de tiempos de espera */
int boton; /* definimos variable "boton" para almacenar dato de estado del botón KEYB */

RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; /*pins siguientes como Salidas Digitales Push-Pull */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_5|GPIO_Pin_7; /* inicia pins 0,1,5 y 7 como Salidas Digitales */
GPIO_Init(GPIOB, &GPIO_InitStructure);

GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; /*Pin siguiente como Entrada Digital en Flotación */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; /* inicia pin 2 como Entrada Digital */
GPIO_Init(GPIOB, &GPIO_InitStructure);

while(1){ /* bucle de repetición de encendido-apagado */
boton = 0;
boton = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2); /* lee estado del botón KEYB y asigna a la variable "boton" */

if (boton==1){ /* si "boton" es 1, permite repetición de encendido-apagado */
GPIO_WriteBit(GPIOB, GPIO_Pin_0,Bit_SET); /* enciende LED 1 */
for(ncount=0; ncount<1000000; ncount++); /* espera */
GPIO_WriteBit(GPIOB, GPIO_Pin_0,Bit_RESET); /* apaga LED 1 */

GPIO_WriteBit(GPIOB, GPIO_Pin_1,Bit_SET); /* enciende LED 2*/
for(ncount=0; ncount<1000000; ncount++); /* espera */
GPIO_WriteBit(GPIOB, GPIO_Pin_1,Bit_RESET); /* apaga LED 2 */

GPIO_WriteBit(GPIOB, GPIO_Pin_7,Bit_RESET); /* enciende LED de USB */
for(ncount=0; ncount<1000000; ncount++); /* espera */
GPIO_WriteBit(GPIOB, GPIO_Pin_7,Bit_SET); /* apaga LED de USB */

GPIO_WriteBit(GPIOB, GPIO_Pin_5,Bit_SET); /* enciende DISPLAY */
for(ncount=0; ncount<1000000; ncount++); /* espera */
GPIO_WriteBit(GPIOB, GPIO_Pin_5,Bit_RESET); /* apaga DISPLAY */
}
}
}
====================================

¿Qué cosas nuevas hay en este programa con respecto al de la página anterior?

1)- Para empezar la orden GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; que configurará el siguiente Pin que se defina como modo IN_Floating, lo que significa que será una entrada y que estará en flotación, es decir que el Pin no tiene interiormente ninguna resistencia Pull-Up (conectada a positivo) ni Pull-Down (conectada a masa), y el estado del Pin dependerá exclusivamente de la tensión que se le entre desde el circuito exterior.
2)- Para captar el estado del botón KEYB y por tanto del Pin2, utilizaremos la orden: boton = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2); que asignará a la variable "boton" un 1 si está apretado y un 0 si está en su estado normal.
3)- Esta información la utilizaremos para actuar sobre una orden condicional if (boton==1){ ..... } que encierra las instrucciones de destelleo, de manera que éste sólo se producirá si apretamos el KEYB.
4)- A parte de esto, observamos que el tercer LED (el del USB) se enciende con un Bit_Reset y se apaga con un Bit_Set, cuando en el resto es al contrario. Esto es debido a que este LED se enciende con "lógica inversa", y por tanto también han de serlo las órdenes que le demos.

Compilando el programa con el Coocox

El programa lo compilaremos con el Coocox, de la forma que ya hemos visto:

A)- Arrancar el Coocox. Si hay algún proyecto abierto lo cerramos con Project > Close Project.
B)- Seleccionamos el microcontrolador adecuado ST > STM32F103VC
C)- Como esto no será un ejemplo ya hecho sino un proyecto totalmente nuevo, hemos de seleccionar las librerías adecuadas para las órdenes de entrada-salida digital, marcamos la GPIO. Nos pedirá que abramos el nuevo proyecto, que llamaremos "003-Ent-Sal-Digital". A le vez observamos que también se han seleccionado automáticamente la RCC, la CMSIS Boot y la CMSIS Core, de las que depende la inicial.
D)- De la ventana abajo-izquierda, marcamos sobre "main.c". El fichero se abre en la ventana central. Borramos las pocas instrucciones iniciales.
E)- De la página web copiamos el texto del programa que hemos escrito y lo pegamos sobre el recuadro vacío de "main.c"
F)- Repasamos que todo esté bien y seleccionamos Project > Build o pulsamos F7. Vemos como el programa de compila. Comprobamos que el proceso acaba bien, dando los valores:

text data bss dec hex filename
1752 0 1032 2784 ae0 003-Ent-Sal-Digital.elf

G)- Con la placa Mini-STM32 conectada al ordenador en modo Boot-Loader, arrancamos el Flash Loader Demo.
H)- Seleccionamos el fichero 003-Ent-Sal-Digital.hex que está en C:\CooCox\CoIDE\workspace\003-Ent-Sal-Digital\Debug\bin
I)- Una vez cargado el .hex, pulsamos el Reset de la placa, y seguidamente, al apretar el pulsador KEYB, si todo ha ido bien deberemos observar el destello secuencial de los 3 LEDs y del display LCD.

Video de youtube: http://www.youtube.com/watch?v=45GHpNbv ... r_embedded

Compilando el mismo programa con el Keil uVision 4.22

En esta ocasión hemos descrito y utilizado de forma práctica el IDE Coocox, pero tampoco vamos a dejar de lado el Keil uVision que vimos en la página anterior, ya que por su enfoque profesional es mucho más potente y permite tanto la simulación de microcontroladores como dispositivos de depuración de programas. Otro motivo es que lo necesitamos para reproducir los ejemplos de software que hemos bajado de Micro4you, cuyo formato es precisamente para este programa.

Sobre estos ejemplos, mi idea inicial era adaptarlos a otro formato más estándar y menos dependiente de un IDE concreto. El Coocox era tal vez más interesante para comenzar por su filosofía de programa abierto y porque en teoría tiene una opción de importación de formatos de Keil. Pero lamentablemente, esta opción no funciona de manera adecuada y poco más o menos se limita a copiar la estructura original, con la consecuencia que la mayoría de las veces, al compilar, aparecen una infinidad de errores de librerías y de funciones no reconocidas, que después de un fin de semana entero intentándolo, no he encontrado una manera satisfactoria de solucionar. Por otra parte, muchas librerías que comparten nombre en el Keil y en el Coocox, en realidad son algo diferentes, y cualquier intento de integrarlas me ha dado resultados negativos.

A nivel básico, utilizar el Keil uVision no resulta tan fácil, ya que a falta de práctica deberíamos montar a mano la estructura de carpetas del programa, y buscar y cargar cada uno de los casi 200 archivos en su lugar correcto. Por este motivo se me ha ocurrido utilizar la estructura ya existente de un proyecto, limpiándolo de cualquier archivo que lo caracterice como tal, de manera que se ha convertido en un proyecto estandar que podemos utilizar para cargar cualquier "main.c" de los ejemplos de prueba o de los programas similares que nosotros realicemos.

Lo he llamado Proyecto-Base-Keil-uVision-4.22, y está contenido en una carpeta del mismo nombre con tres subcarpetas en su interior: Libreries, MDK-ARM y USER, además de un fichero readme.txt con información básica de su uso.

1)- Libreries , contiene un cierto número de subcarpetas con todas las librerías necesarias, que parece las mismas en todos los ejemplos de Keil
2)- MDK-ARM, contiene el fichero "Project.uvproj", que deberemos seleccionar desde el Keil para abrir el proyecto. De igual modo, un doble click sobre este fichero abrirá automaticamente el Keil y se cargará.
En esta carpeta hay dos subcarpetas más: la List y especialmente la Obj, donde se guardarán todos los archivos una vez compilados y el fichero ejecutable final, que siempre se llamará "Project.hex", y desde donde deberemos seleccionarlo con el Flash Loader Demo.
3)- USER, donde se encuentra el fichero principal "main.c"

El proyecto base puede descargarse desde el enlace: Proyecto-Base-Keil-uVision: http://dl.dropbox.com/u/5592203/Progs/P ... 204.22.rar

Entonces, después de descargarlo y guardar una copia para tenerlo siempre limpio y original, con la otra y el Keil haremos lo mismo que antes hemos hecho con el Coocox:

A)- Abrimos Proyecto-Base...> MDK-ARM y damos doble click sobre "Project.uvproj". Se arranca el Keil uVision y se carga el proyecto
B)- En la ventana izquierda-arriba, abrimos Keil-Project y USER. Damos doble click sobre "main.c" que se abre en la ventana gran de la derecha
C)- Copiamos nuestro programa de la página y lo pegamos en "main.c"
D)- Seleccionamos Project > Build Target o F7, se abre una ventana inferior y se inicia la compilación
E)- Una vez acabada y comprobado que no hay errores, con la tarjeta Mini-STM32 conectada al ordenador y en modo Boot-Loader, arrancamos el Flash Loader Demo, seleccionamos el Project.hex contenido en MDK-ARM \ Obj y lo cargamos en memoria

Tal como ha ocurrido con el Coocox, al pulsar Reset el programa ha de funcionar sin problemas.

... Y por esta página creo que ya he largado suficiente. En la que venga a continuación repasaremos los diversos tipos de órdenes de Entrada y Salida Digital, los explicaremos un poco mejor y también comenzaremos a mirar las rutinas gráficas de la pantalla LCD.

Continuará...
Avatar de Usuario
por
#287578
Hola Anilandro, excelente aporte como entrada al foro. Creo que efectivamente sería más adecuado darle formato de artículo técnico a toda la documentación que estás exponiendo. ¿Cabe esa posibilidad?
Avatar de Usuario
por
#287603
Yo lo he pasado a PDF, para archivo...

Por cierto, gracias de nuevo, Anilandro.. este IDE no lo conocía..
Palabras clave
Temas similares

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 0 invitados

Permisos de mensaje

No puede abrir nuevos temas en este Foro
No puede responder a temas en este Foro
No puede editar sus mensajes en este Foro
No puede borrar sus mensajes en este Foro
No puede enviar adjuntos en este Foro