TODOPIC
Otros Microcontroladores / Dispositivos programables => Microcontroladores ARM => Mensaje iniciado por: planeta9999 en 24 de Abril de 2017, 09:32:25
-
.
¿ Por casualidad alguien ha portado un proyecto de Arduino a Eclipse ?, tengo un aplicativo para Teensy (Kinetis), y a esta gente por desgracia les dió por usar como IDE Arduino, que para mi es una soberana CASTAÑA.
Con Teensy no hay manera de hacer Debug, no se si Arduino lo permite, pero como Teensy tiene por delante otro Kinetis con un bootloader para cargar el ejecutable, no hay manera de entrarle directo, y aunque le conectara SWD soldando hilos, o montando mi placa, no creo que pueda hacerle Debug mezclando fuentes de Arduino con SWD usando el Jlink de Segger. Esta gente de Teensy se montaron un invento para poder enviar desde el programa de usuario lo que quieras a través de un COM virtual para visualizarlo en el hiperterminal o programas similares, osea un Debug de pacotilla.
He encontrado googleando, un plugin para Eclipse o así lo anuncian (Sloeber), pero al bajarlo veo que es una versión completa de Eclipse tocada para en teoría importar proyectos de Arduino, la he estado mirando y me parece una chufa.
De la estructura interna de Arduino no conozco demasiado, solo que hay por ahí un fuente interno que lleva su main() como dios manda, y de ahí se llama a la función setup() del usuario y luego a la loop().
Mi duda es básicamente donde se define el oscilador y el tipo de microcontrolador para el que debe de compilar el compilador. El micro se selecciona en la barra de menús y no aparece por ninguna parte en los fuentes del usuario. Creo que me lo podría llevar todo a MCUXpresso o KDE sin mucha dificultad, para poder trabajar con seriedad, hacer Debug y demás.
Cada vez que toco Arduino, me parece una castaña más gorda, no entiendo como algo así puede haber triunfado.
-
Revisa este proyecto
http://platformio.org/
Tienen soporte para teensy
http://platformio.org/boards?filter%5Bplatform%5D=teensy
Tienen su propio IDE, aunque se puede integrar con cualquier otra plataforma como Eclipse
http://platformio.org/get-started/integration
https://community.platformio.org/t/platformio-debugging/1704
Realmente no lo he probado, pero tal vez te sirva.
-
.
Gracias tsk, voy a echarle un ojo.
-
Cada vez que toco Arduino, me parece una castaña más gorda, no entiendo como algo así puede haber triunfado.
Eso es como quejarte de los micros de 8 bits porque son mucho más simples que los de 32bits. O de las ruedas de bicicleta por soportar mucho menos que una de un 4x4.
No es una castaña, cada producto tiene su objetivo y el de Arduino lo cumple muy bien.
Si te fijas, el objetivo es hacer código C sencillo.
Eso es una antítesis como hacer agua que no moja, fuego frío o tortugas veloces y sin embargo el IDE Arduino lo ha conseguido.
Otro tema es que en realidad te estás quejando solo del IDE Arduino, no de la PLACA Arduino. Son dos cosas distintas aunque tengan la misma marca.
Dicho esto, como en el IDE de Arduino estás en realidad programando en C para el compilador GCC, todo el código es diréctamente portable a Eclipse sin ningún problema.
La primera vez que lo hagas solo tendrás que añadir un include con defines del micro, velocidad de reloj y alguna otra opción, como bien dices.
Eso una vez que lo hagas ya queda hecho para siempre.
Lee esto: Arduino Build Process https://www.arduino.cc/en/Hacking/BuildProcess
Esos defines normalmente los oculta el IDE y los añade automáticamente a partir de las opciones del menú para ocultarle a propósito al usuario la complejidad del microcontrolador. Recuerda que Arduino está hecho para usuarios no expertos.
De un usuario experto se espera que lea el documento anterior y otros similares para poder hackear el producto sin problema. Los mismos creadores de Arduino lo fomentan y esto es otro punto a favor de Arduino.
Un saludo.
-
Si lo comparas con PIC, Arduino te da todo lo bueno del CCS (encapsular el código complejo y darte funciones que te hacen la vida más simple) y todo lo bueno del compilador XC8 (defines infinitos, control absoluto, etc) pero te lo da todo bien documentado, con código abierto, completamente libre y gratuito, con buen soporte, programador incluído, desarrollo continuo de nuevos productos, con una comunidad enorme con distintos niveles de conocimientos, sin necesidad de donaciones ni pagos por ningún tipo de software, con hardware un poco más caro que los chinos pero de precios asequibles.
Y no me lo compares con productos de 32 bits, porque Arduino en principio pertenece al mundo de los 8 bits que es mucho más caro y cerrado.
¿Qué más quieres? Eso es triunfar por todo lo alto.
Un saludo.
-
Aquí explican cómo hacer tu primer proyecto de Arduino en Eclipse. Está adaptado a Arduino, pero imagino que valdrá también con algunas modificaciones para Teensy:
http://playground.arduino.cc/Code/Eclipse#YourFirstArduinoProject
Página completa: http://playground.arduino.cc/Code/Eclipse
Un saludo.
-
.
Ok, gracias por la información Picuino. Creo que ya encontré el fichero que buscaba, es el boards.txt, ahí están todos los parámetros del microcontrolador, frecuencia de reloj y un montón más de parámetros que supongo se pasan al compilador para el micro elegido.
Leeré esos documentos, ya me imaginaba que si compila con GCC no debe de ser difícil de portar, lo que me descoloca es todo lo que Arduino gestiona de manera oculta, como librerías propias que no las ve el usuario en su código fuente, ni tampoco hay includes que desvelen de que librerías se trata.
Lo demás más o menos lo tengo claro, es un ARM NXP Kinetis y debe de poder manejarse todo desde Eclipse si consigo parametrizar lo necesario e incluir todas las librerías.
En cuanto al Editor de Código de Arduino, sigo pensando que es una castaña, paso el ratón por encima de las variables y ni se inmuta, quiero que me apunte automáticamente a la declaración de una función y ni se inmuta, ni colorea ni indexa el código. Más bien parece un vulgar editor de texto plano, sin más, eso es una castaña. Cualquiera que haya trabajado con Eclipse o con Visual Studio se da cuenta de inmediato de las grandes deficiencias del Editor de Arduino. Si creo que hasta la gente opta por otro entorno que alguien ha desarrollado para reemplazar al original, yo lo bajé y no conseguí que me funcionara bien, pero se veía infinitamente mejor, te colorea el código, te lo indexa, y supongo que en Debug te mostrará el contenido de variables tan solo con pasar el ratón por encima.
El conjunto de Arduino, puede que esté bien para estudiantes y gente poco exigente que empieza, pero el Editor que han montado, por dios, sino es más que un editor de texto vulgar y corriente sin ninguna ayuda para el programador. Vengo de estar programando en Eclipse para STM32, y aquello es una gozada.
Si por todo esto, precisamente, me quiero llevar el aplicativo que tengo de Teensy bajo Arduino, a Eclipse, para trabajar como dios manda, y no tener que estar adivinando las cosas.
-
El editor tiene coloreado de sintaxis y como debuger una consola donde envía y recibe por el puerto serial. No tiene nada más.
No es un entorno profesional y no lo es a propósito. Su objetivo inicial era que los artistas pudieran utilizar microcontroladores para sus obras. No es el público más experto en electrónica o informática. Pero al contrario que PICAXE u otros semejantes, el equipo de Arduino ideó un entorno abierto y que permite utilizarlo con toda la potencia si quieres.
Los detalles se ocultan a propósito para no asustar al neófito.
Muchas opciones están en el fichero preferences.txt
https://www.arduino.cc/en/Hacking/BuildProcess
Relevant variables include:
<BOARD>.name: the name to display in the Boards menu
<BOARD>.build.mcu: the microcontroller on the board (normally "atmega8" or "atmega168").
<BOARD>.f_cpu: the clock speed at which the microcontroller operates (normally "16000000L", or, for an ATmega168 running on its internal clock, "8000000L").
<BOARD>.core: which sub-directory of the hardware/cores/ directory to link sketches against (normally "arduino").
Luego las librerías están incluidas en el código principal como #includes
Las transformaciones que hace el IDE son:
https://www.arduino.cc/en/Hacking/BuildProcess
Transformations to the main sketch file
The Arduino environment performs a few transformations to your main sketch file (the concatenation of all the tabs in the sketch without extensions) before passing it to the avr-gcc compiler.
First, #include "Arduino.h" is added to the top of your sketch. This header file (found in <ARDUINO>/hardware/cores/<CORE>/) includes all the defintions needed for the standard Arduino core.
Next, the environment searches for function definitions within your main sketch file and creates declarations (prototypes) for them. These are inserted after any comments or pre-processor statements (#includes or #defines), but before any other statements (including type declarations). This means that if you want to use a custom type as a function argument, you should declare it within a separate header file. Also, this generation isn't perfect: it won't create prototypes for functions that have default argument values, or which are declared within a namespace or class.
Finally, the contents of the current target's main.cxx file are appended to the bottom of your sketch.
Otro detalle del proceso de build:
The include path includes the sketch's directory, the target directory (<ARDUINO>/hardware/core/<CORE>/) and the avr include directory (<ARDUINO>/hardware/tools/avr/avr/include/), as well as any library directories (in <ARDUINO>/hardware/libraries/) which contain a header file which is included by the main sketch file.
En esos directorios está todo.
Un saludo.
PD. Como tu estás utilizando un Teensy, imagino que Teensyduino añade a todos los directorios anteriores el código necesario para que Teensy funcione. Solo necesitas encontrarlo y moverlo a tu proyecto eclipse. Son pocos archivos y una vez hecho un proyecto base, te vale como plantilla para todos los que hagas a partir de ahora.
Ten en cuenta que muchas librerías son dependientes unas de otras. Si has utilizado librerías de Teensyduino, igual tienes que copiar también algunas librerías/código de Arduino del que dependa.
-
PD. Como tu estás utilizando un Teensy, imagino que Teensyduino añade a todos los directorios anteriores el código necesario para que Teensy funcione. Solo necesitas encontrarlo y moverlo a tu proyecto eclipse. Son pocos archivos y una vez hecho un proyecto base, te vale como plantilla para todos los que hagas a partir de ahora.
Ten en cuenta que muchas librerías son dependientes unas de otras. Si has utilizado librerías de Teensyduino, igual tienes que copiar también algunas librerías/código de Arduino del que dependa.
Ese es el tema, averiguar todo lo que Arduino maneja de manera oculta, para poder montar mi proyecto bajo Eclipse. Ya veremos el galimatías de librerias que hay por debajo de la alfombra, y que necesito conocer para que no me casque una y otra vez la compilación.
Por eso no me gustan todos estos entornos prefabricados y propietarios, no son estandard y en cuanto te sales de ellos, lo que has aprendido te sirve para poco. Igual que esos entornos basados en pseudocódigo con organigramas y demás, hay gente que se cree que eso le facilita las cosas, nada más lejos de la realidad, te quedas atrapado en un sistema propietario y en cuanto intentas irte a otra plataforma, todo lo aprendido no te sirve para nada.
El ideal, es siempre trabajar en C o C++ puro y duro, en todo caso con algún asistente para generar código como Cube para STM32 o Processor Expert para Kinetis, pero nunca trabajar con un sistema que mantiene oculta a la vista buena parte del código con un entresijo de librerías y programas internos que te esconden parte de la realidad de un proyecto. Poco o nada se aprende metiéndose en esas plataformas, además de que te dificulta la portabilidad, por eso entre otras cosas, no me gustan en absoluto entornos como Arduino (aparte de que su editor es infumable), son como cajas negras hechas para gente que no quiere conocer realmente como se construye un aplicativo de principio a fin.
-
No te preocupes que no es para tanto.
Yo suelo utilizar con frecuencia Arduino para pruebas porque es muy rápido. Las pruebas luego las he portado en varias ocasiones a otros entornos sin problema.
Lo único que tienes que tener en cuenta es no depender demasiado de las librerías de Arduino porque son muy sencillas de usar, pero lentas y pesadas (ocupan mucha memoria). Para comenzar pruebas no están mal, pero luego es mejor ir sustituyendolas por otras instrucciones.
Por ejemplo digitalWrite() es mucho más pesada y lenta que escribir directamente en el registro de salida, pero más sencilla. Simplemente pones el número de salida y listo. Te olvidas de buscar cuál es el registro en el que escribir, en qué bit y hacer la operación de bit correspondiente (OR para poner a uno y AND con dato invertido para poner a cero la salida)
Puedes utilizar las dos (yo utilizo las dos) dependiendo de lo que te interese.
Al final las librerías no son tantas y están todas en el mismo sitio. Hay dos lugares donde encontrarlas.
Las librerías de usuario (IRremote, LiquidCrystal) están todas en tu directorio de usuario en la carpeta Arduino. Son transparentes puesto que tienes que colocarlas tú mismo ahí.
Las librerías incluidas en el sistema están todas en el directorio de instalación de Arduino/libraries y son unas 18 en total, que ocupan como mucho unos 15Mbytes
También hay librerías dependientes del Hardware en Arduino/Hardware/arduino/avr que en tu caso tendrá una ruta diferente para el Teensy.
Y que yo sepa no hay más.
Arduino no es un entorno propietario, es opensource y una vez que lo conoces, bastante abierto y sencillo.
Yo encuentro muuuucho más complicado configurar Eclipse que el entorno Arduino. En Eclipse hay muchas más configuraciones que se hacen de forma automática y oculta al usuario con varios niveles que no son sencillos.
Es algo común a todos los IDE. En el caso de Arduino no son tantos y están siempre en el mismo sitio para que los modifiques o trastees con ellos si quieres.
Un saludo.
-
Aquí tienes el código completo del IDE de Arduino:
https://github.com/arduino/Arduino
Completamente abierto.
Arduino es un conjunto de herramientas. Puedes utilizar todas juntas o solo las que tu quieras o te interese. Es muy flexible, abierto y adaptable. Por eso estás utilizando una placa no Arduino (Teensy) junto a otras herramientas de Arduino.
Las herramientas son estas:
IDE
Librerias en C y C++
Código de ejemplo y aplicaciones en C y C++
Placas de desarrollo.
Shields de ampliación de las placas de desarrollo.
Puedes usar cualquiera de ellas de forma independiente.
Por ejemplo puedes usar un IDE como Eclipse con las librerías Arduino, con placa Teensy, con un Shield para Arduino (tendrás que cablearlo a mano). Tu decides.
Por ejemplo puedes utilizar el IDE de Arduino para programar en puro C, C++ sin usar ninguna función o definición de Arduino.
Por otro lado puedes usar un IDE distinto (Eclipse u otro) para programar usando las librerías de Arduino y sus ejemplos.
O puedes portar los ejemplos y librerías de Arduino a otro entorno (yo lo hice en su día con la librería de LCD portándola a PIC)
Conclusión: Usa lo que quieras de Arduino y como quieras, es libre, abierto y gratuíto.
Un saludo.
-
Eclipse:
(http://www.a350xwb.com/fileadmin/templates/a350xwb/assets/img/mood-lighting/cockpit-day.jpg)
Arduino:
(https://i.ytimg.com/vi/vftNmk6R0Oo/maxresdefault.jpg)
Son dos productos diferentes. Intenta enseñar a utilizar Eclipse a alguien que no sabe absolutamente nada de microcontroladores y lo entenderás.
Pero en el fondo en los dos casos estás haciendo básicamente lo mismo y el más simple te sirve para llegar a aprender a utilizar el otro.
Un saludo.
-
.
Bueno, por los foros de Teensy, me han dado una solución, que creo me puede resolver el problema. Me dicen que en la instalación de Teensy para Arduino, hay un Makefile con el que se puede compilar el proyecto sin necesidad de tener Arduino.
He buscado información en la web de Teensy, y me encuentro con esto:
"
Step #3: The GCC Compiler and Tools
Update: This page only applies to Teensy 2.0. Teensy 3.0 is supported by Teensyduino. To use Teensy 3.0 without Arduino, first install Teensyduino. A sample makefile is installed in hardware/teensy/cores/teensy3. The makefile comments explain how to detete the unnecessary portions of Arduino, if you wish to use only the makefile.
To compile C and C++ programs, you will need a collection of programs including avr-gcc, the avr-libc C library and avr-binutils. Installing all the required pieces separately can be difficult. Fortunately, there are complete, easy to install packages for all major platforms. "
He buscado en la instalación de Arduino/Teensy, y me he encontrado el Makefile famoso, que tiene este contenido. Mi duda es si puedo meter este archivo a capón en el proyecto de Kinetis en el KDE. Nunca he mirado los Makefile, intuyo para que sirven, pero no se los detalles. Ahí veo parámetros para el enlazador y el compilador, que es una de las cosas que andaba buscando, y los path a ciertas librerías de Arduino, que podrían ser necesarias para portar el proyecto a Eclipse.
# set your MCU type here, or make command line `make MCU=MK20DX256`
MCU=MK20DX256
# make it lower case
LOWER_MCU := $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,$(subst X,x,$(subst Y,y,$(subst Z,z,$(MCU)))))))))))))))))))))))))))
MCU_LD = $(LOWER_MCU).ld
# The name of your project (used to name the compiled .hex file)
TARGET = main
# Those that specify a NO_ARDUINO environment variable will
# be able to use this Makefile with no Arduino dependency.
# Please note that if ARDUINOPATH was set, it will override
# the NO_ARDUINO behaviour.
ifndef NO_ARDUINO
# Path to your arduino installation
ARDUINOPATH ?= ../../../../..
#ARDUINOPATH ?= ../../../..
endif
# configurable options
OPTIONS = -DF_CPU=48000000 -DUSB_SERIAL -DLAYOUT_US_ENGLISH -DUSING_MAKEFILE
# options needed by many Arduino libraries to configure for Teensy 3.0
OPTIONS += -D__$(MCU)__ -DARDUINO=10613 -DTEENSYDUINO=132
# Other Makefiles and project templates for Teensy 3.x:
#
# https://github.com/apmorton/teensy-template
# https://github.com/xxxajk/Arduino_Makefile_master
# https://github.com/JonHylands/uCee
#************************************************************************
# Location of Teensyduino utilities, Toolchain, and Arduino Libraries.
# To use this makefile without Arduino, copy the resources from these
# locations and edit the pathnames. The rest of Arduino is not needed.
#************************************************************************
ifdef ARDUINOPATH
# path location for Teensy Loader, teensy_post_compile and teensy_reboot (on Linux)
TOOLSPATH = $(abspath $(ARDUINOPATH)/hardware/tools)
# path location for Arduino libraries (currently not used)
LIBRARYPATH = $(abspath $(ARDUINOPATH)/libraries)
# path location for the arm-none-eabi compiler
COMPILERPATH = $(abspath $(ARDUINOPATH)/hardware/tools/arm/bin)
else
# Default to the normal GNU/Linux compiler path if NO_ARDUINO
# and ARDUINOPATH was not set.
COMPILERPATH ?= /usr/bin
endif
#************************************************************************
# Settings below this point usually do not need to be edited
#************************************************************************
# CPPFLAGS = compiler options for C and C++
CPPFLAGS = -Wall -g -Os -mcpu=cortex-m4 -mthumb -MMD $(OPTIONS) -I.
# compiler options for C++ only
CXXFLAGS = -std=gnu++0x -felide-constructors -fno-exceptions -fno-rtti
# compiler options for C only
CFLAGS =
# linker options
LDFLAGS = -Os -Wl,--gc-sections,--defsym=__rtc_localtime=0 --specs=nano.specs -mcpu=cortex-m4 -mthumb -T$(MCU_LD)
# additional libraries to link
LIBS = -lm
# names for the compiler programs
CC = $(COMPILERPATH)/arm-none-eabi-gcc
CXX = $(COMPILERPATH)/arm-none-eabi-g++
OBJCOPY = $(COMPILERPATH)/arm-none-eabi-objcopy
SIZE = $(COMPILERPATH)/arm-none-eabi-size
# automatically create lists of the sources and objects
# TODO: this does not handle Arduino libraries yet...
C_FILES := $(wildcard *.c)
CPP_FILES := $(wildcard *.cpp)
OBJS := $(C_FILES:.c=.o) $(CPP_FILES:.cpp=.o)
# the actual makefile rules (all .o files built by GNU make's default implicit rules)
all: $(TARGET).hex
$(TARGET).elf: $(OBJS) $(MCU_LD)
$(CC) $(LDFLAGS) -o $@ $(OBJS) $(LIBS)
%.hex: %.elf
$(SIZE) $<
$(OBJCOPY) -O ihex -R .eeprom $< $@
ifneq (,$(wildcard $(TOOLSPATH)))
$(TOOLSPATH)/teensy_post_compile -file=$(basename $@) -path=$(shell pwd) -tools=$(TOOLSPATH)
-$(TOOLSPATH)/teensy_reboot
endif
# compiler generated dependency info
-include $(OBJS:.o=.d)
clean:
rm -f *.o *.d $(TARGET).elf $(TARGET).hex
-
El makefile es un archivo que define todo el proceso de compilación y enlace.
Se llama con el programa make incluido en GCC.
Lo que no sé es cómo incluírlo en Eclipse para que le haga caso, porque tengo entendido que Eclipse crea sus propios makefiles.
Dentro de unos dias me llega el Teensy 3.6 y lo pruebo.
Un saludo.
-
.
Ok, gracias Picuino.
A mi me suena haber visto en los proyectos de Eclipse para los STM32, algun archivo makefile, pero nunca me he parado a mirar para que servían, ni como se han generado.
Si pudiera editar el makefile que cree Eclipse, para meterle mis apaños a partir del makefile del Teensy, pero me da la sensación de que si toco cosas en la configuración de Eclipse, me creará un nuevo makefile y perderé todo lo que meta a mano. Por ejemplo, solo con que toque la configuración para la optimización, que veo que está en el makefile como un parámetro del compilador, ya supongo que se crearía un nuevo makefile.
Tambien puedo tratar de configurar en Eclipse, las opciones que vea en el makefile del Teensy, hay muchas cosas que me suenan haberlas visto, como el tipo de procesador Cortex-M4, la optimización, y los path de las librerías. Este makefile de Teensy, me serviría más bien para saber que librerías de Arduino me tengo que llevar, donde están, y que parámetros tengo que configurar en Eclipse.
Igual al final no es tan complicado portar el proyecto de Arduino a KDS o MCUXpresso.
Estos días he estado trasteando con MCUXpresso, y vaya tela, está totalmente en bragas, al menos para Kinetis. Creo que partieron de LPCXpresso para los LPC, y están tratando de meter a cabezazos los Kinetis para fusionarlo todo en uno. Pero lo están haciendo fatal, ahora mismo te instalas MCUXpresso, vas a crear un proyecto y no ves por ninguna parte los Kinetis, tienes que irte a la web de NXP y generar el SDK para el micro que quieras. Te lo bajas al PC y lo importas en el MXUXpresso, entonces ya te sale el micro para crear el proyecto, y de todas formas no está el Processor Expert, para mi imprescindible.
Esta gente de NXP debería de fijarse en como han hecho las cosas los de ST, para presentar un producto serio. Y el KDE está dejado a su suerte, se ve que ya no lo actualizan desde hace tiempo porque no soporta los MK66, sin embargo el Processor Expert instalado suelto si que lo tiene, de locos.
-
Igual al final no es tan complicado portar el proyecto de Arduino a KDS o MCUXpresso.
Una vez hecho, seguro que te parece sencillo.
Probablemente tendrás que tocar todas las configuraciones de Eclipse para que este produzca un makefile igual.
Por eso prefiero en muchos casos trabajar diréctamente con un editor de textos, sin IDE. Es lo mejor por ejemplo para pasar a otra persona tu configuración. Simplemente le envías el makefile y listo.
En el libro Mastering STM32 los ejemplos de compilación los escribe directamente en línea de comandos. Por ejemplo en la página 6:
$ arm-none-eabi-gcc -mcpu=cortex-m4 -mthumb -fverbose-asm -save-temps -O0 -g -c file.c
Para hacer eso con Eclipse habría que mostrar en el libro unas cuantas imágenes de pantallas gráficas y configuraciones.
Por eso, trabajar con Eclipse es en muchos sentidos como trabajar con el IDE Arduino. Es más sencillo, pero te oculta muchas tareas que hace en la sombra.
Con la línea de comandos lo tienes todo a la vista. Esa es otra opción para empezar a portar desde Arduino y es la primera que yo voy a hacer.
Un saludo.
-
A propósito ¿Que opción elegir KDS o MCUXpresso?
-
El LPCXpresso en su momento y las LPCOpen (librerías) eran lo máximo. Lamentablemente se quedaron y perdieron muuuucho terreno/tiempo. Yo habia arrancado con NXP y estaba muy contento. Pero no le dieron bola a los foros de consulta, no publicaron muchos aplication notes y ST los pasó por arriba.
Espero que se pongan en tono pronto porque tenía buenos micros, unque al ritmo que va ST no sé cuándo lo van a alcanzar.
Sds
-
A propósito ¿Que opción elegir KDS o MCUXpresso?
Precisamente ahora mismo acabo de conseguir, por fin, que el MK66 se pueda trabajar con Processor Expert en KDS. Menudo galimatías, estos de NXP han montado un pastel de mucho cuidado, yo todavía no entiendo muy bien todo este festival de KDS, SDK, IDE, ahora MCUXpresso, la configuración online en su web para crear los SDK, etc..., es de locos. Para cualquier mente medianamente organizada, todo esto no tiene ni pies ni cabeza, es como si lo hubieran hecho aprisa y corriendo, un sinsentido.
La gente de soporte de NXP me han echado un cable en el foro, y he podido descargar e instalar el KSDK 1.3 para que el KDS soporte los MK66, toda una odisea, pero ya funciona.
A ver, ahora entre MCUXpresso y KDS (Kinetis Design Studio), sin dudarlo KDS porque soporta el Processor Expert, este es el generador de código para poder configurar toda la periferia sin escribir una linea de código. El Processor Expert es en Kinetis lo que el Cube en ST o el Harmony en Microchip, te ahorras un montón de tiempo.
Por ahora, MCUXpresso no soporta todavía el Processor Expert, ya por eso, yo de momento no lo utilizaría. Supongo que lo pondrán, parece que están en ello. Pero lo han hecho muy mal, han liberado un producto que está a medio acabar, por lo menos para los interesados en Kinetis. Supongo que para usarlo con LPC será distinto, porque han partido (creo) de LPCXpresso para crear MCUXpresso y fusionar LPC y Kinetis en un solo entorno de trabajo.
Ahora están metiendo los Kinetis en MCUXpresso a cabezazos, con soluciones cogidas por los pelos, como eso de tener que configurar un SDK para Kinetis desde su web para importarlo luego a MCUXpresso. Eso es una chapuza, que no te permite ligar automáticamente el código que generas con el SDK y tu código fuente, como si te hace el Cube de ST.
A ver si por lo menos se ponen las pilas, y van liberando pronto y rápido versiones decentes de MCUXpresso.
-
Por eso prefiero en muchos casos trabajar diréctamente con un editor de textos, sin IDE. Es lo mejor por ejemplo para pasar a otra persona tu configuración. Simplemente le envías el makefile y listo.
Ya, pero necesita hacer Debug, para eso Eclipse tiene que estar configurado, y eso a su vez supongo que genera su propio makefile que machacaría cualquier cosa que yo meta a mano en el fichero makefile generado por Eclipse.
Miraré de poner todos los parámetros del makefile de Teensy en Eclipse. Hay cosas que si que se por donde andan, como los parámetros de la optimización, indicarle que es un Cortex M4, todo el tema de los path de librerías.
-
Por eso a la gente le gusta tanto Arduino. Es pinchar y listo.
Y para hacer debug, configuraré un DMA para que envíe un buffer de memoria por la UART y listo. Casi no consume pines ni tiempo de procesador. En el lado del PC recojo los valores y los presento en pantalla actualizados.
Si tengo que poner un breakpoint, añado una función que espere a un pin con pullup que se ponga a masa o que espere recepción de un dato por UART.
Un poco rústico, pero funciona.
Si veo que te da resultados los IDEs de NXP, pensaré en pasarme a ellos.
A propósito ¿Qué tipo debug necesitas hacer para que Arduino se quede corto?
Saludos.
-
A propósito ¿Qué tipo debug necesitas hacer para que Arduino se quede corto?
Saludos.
Uso siempre el Debug del entorno, en los ST y los Kinetis el GDB y OpenOCD. No suelo utilizar eso de encender leds y cosas por el estilo.
Lo que si estoy mirando ahora es a enlazar con Processing una placa que tiene un acelerómetro, para poder ver en tiempo real y de manera gráfica si se calculan bien los ángulos con la fórmula de los cuaterniones. Y de paso hacerle una presentación chula al cliente.
Y hace un momento, mirando la nueva versión que acaba de salir del libro Mastering STM32, me he encontrado con STMStudio, esto no lo conocía. Es una utilidad gratuita que permite por SWD ver en gráficos y en tiempo real el estado de cualquier variable. La ventaja es que no hay que habilitar ningún puerto especial para sacar los datos, todo se hace con el STLInk por SWD en tiempo de Debug.
-
Eso gana a cualquier otro debug primitivo.
Lo que no sé es si realmente merece la pena el trabajo de pasarse a Eclipse para tener ese tipo de debug.
Si fuese algo sencillo del tipo pinchar y listo, no habría problema para elegir.
Un saludo.
-
¿Esto sirve para iniciar el debug?modifying-the-teensy-3-5-and-3-6-for-arm-swd-debugging (https://mcuoneclipse.com/2017/04/29/modifying-the-teensy-3-5-and-3-6-for-arm-swd-debugging/), la persona del blog utiliza el KDS (no siempre hay que usar lo más actual o lo último que sacan los fabricantes), tuvo que añadir un header al footprint del header del SWD y remover el micro que graba el micro target de la teensy.
Si tienes el ejecutable puedes usar OpenOCD + arm-none-eabi-gdb + el ejecutable para depurar, eso si, todo desde la consola y no con la UI de Eclipse.
Saludos
-
Estropean la pobre placa y la llenan de parches para poder hacer debug.
Definitivamente ese no es el camino.
-
¿Esto sirve para iniciar el debug?modifying-the-teensy-3-5-and-3-6-for-arm-swd-debugging (https://mcuoneclipse.com/2017/04/29/modifying-the-teensy-3-5-and-3-6-for-arm-swd-debugging/), la persona del blog utiliza el KDS (no siempre hay que usar lo más actual o lo último que sacan los fabricantes), tuvo que añadir un header al footprint del header del SWD y remover el micro que graba el micro target de la teensy.
Si, ha quitado el Kinetis MKL02 que actúa de puente para cargar el ejecutable al MK64/66, y le ataca por SWD. Antes ha intentado anular ese chip, pero no lo ha conseguido porque le interfiere con las señales del SWD, al final a lo bestia, se carga el chip y a correr.
En mi caso no voy a hacer esos cambios, porque ya tengo una placa de diseño propio con un MK66, para el producto que estoy diseñando. En mi placa el bootloader, va por software y solo servirá para cargar actualizaciones de firmware, además va encriptado.
Los Teensy, los guardo tal cual, para pruebas, si alguien quiere poder hacer debug por JTAG o SWD mejor hacerse una plaquita propia y soldarle un micro nuevo. Comprarse un Teensy para reventarlo así, es innecesario.
-
Eso gana a cualquier otro debug primitivo.
Lo que no sé es si realmente merece la pena el trabajo de pasarse a Eclipse para tener ese tipo de debug.
Si fuese algo sencillo del tipo pinchar y listo, no habría problema para elegir.
Un saludo.
Todo eso te lo configura automáticamente Eclipse, no hay que hacer nada. Compilas para Debug, le das al botoncito de la "cucaracha" en la barra de herramientas y entras en Debug de inmediato.
Ahí lo tienes todo, el Debug de toda la vida, puedes añadir puntos de ruptura, avanzar paso a paso, ver el estado de cualquier variable simplemente pasando el puntero del ratón por encima, y unas cuantas cosas más.
Y con el STMStudio ves cualquier variable en tiempo real en modo gráfico, sin necesidad de crear ningún puerto físico para sacar los datos, esto lo tengo que probar, no lo había visto antes.
-
Acabo de encontrarme con esto:
Teensy for Microsoft Visual Studio and Atmel Studio
http://www.visualmicro.com/page/Teensy-for-Microsoft-Visual-Studio.aspx
-
Acabo de encontrarme con esto:
Teensy for Microsoft Visual Studio and Atmel Studio
http://www.visualmicro.com/page/Teensy-for-Microsoft-Visual-Studio.aspx
Interesante, he probado con Visual Studio y funciona perfecto, eso si que es un señor entorno para gestionar un proyecto, si siguiera con Kinetis sería una solución perfecta.
Pero como he decidido portarlo a un Atmel SAM S70, se me complica la cosa, los fuentes del proyecto a portar son para Teensy, osea Kinetis, y el nuevo proyecto es para un ARM de Atmel, directamente no lo puedo pasar a Atmel Studio. Ya veré como me lo llevo, tendrá que ser a mano, pero ya tengo más o menos todo bien ubicado, no creo que me cueste mucho.
Al final todo queda en el mundo ARM, no puede ser tan difícil portar entre fabricantes. El compilador es el mismo, y la configuración de los entornos muy similar, básicamente definir bien los path a las librerías y configurar los parámetros del compilador/enlazador, de Cortex-M4 a Cortex-M7.
Saludos.
-
.
He estado mirando, de manera superficial todavía, como portar un proyecto Teensy/Kinetis/Arduino a SAM S70, usando Atmel Studio. Resulta algo complicado averiguar todo lo que esconde Arduino del proyecto, pero poco a poco me voy haciendo una idea.
Toda la parametrización del microcontrolador para el compilador está en el fichero C:\ARDUINO\hardware\teensy\avr\boards.txt.
La cascada de includes que llevan a la definición y asignación de puertos y demás del MK66 en Arduino, es la siguiente, partiendo de la aplicación a portar: Arduino.h --> Wprogram.h --> wiring.h --> core_pins.h --> kinetis.h
Los archivos que marco en rojo, son la madre del cordero, los que definen el hardware del micro Kinetis MK66 del Teensy 3.6, para integrarlo en Arduino. Esos y otros ficheros están dentro del directorio C:\ARDUINO\hardware\teensy\avr\cores\teensy3\ de Arduino.
Ahora se trata de reemplazar esos archivos, con mi propio core que defina e integre el SAM S70 dentro de Arduino.
El proyecto lo estoy creando en Atmel Studio, que me permite trabajar tanto en modo nativo, como abriendo el proyecto original de Arduino (con un plugin). Si lo sigo trabajando como un proyecto Arduino, aún desde Atmel Studio, puedo introducir toda la parametrización del SAM S70 dentro del archivo boards.txt de Arduino, para que aparezca como una placa más.
Ahora lo complicado es definir los archivos core_pins.h y reemplazar el kinetis.h, por algo como sam.h. El fichero sam.h lo genera Atmel Studio cuando se crea un proyecto nativo para el SAM S70, falta ver si todas las definiciones de ese fichero tiene algo que ver con lo que necesita el core de Arduino.
El problema, para hacer el proyecto como nativo en Atmel Studio, es que el código fuente del que parto hace uso de la librería SmartMatrix, diseñada expresamente para Teensy/Arduino. Lo tengo que estudiar, si no lo veo muy complicado la idea es sacarlo todo del entorno Arduino. Si conociese al detalle las entrañas de Arduino, iría bastante rápido, así lo voy viendo sobre la marcha.
-
Es más sencillo de lo que parece.
Todos los archivos necesarios están en el directorio:
C:\ARDUINO\hardware\teensy\avr\cores\teensy3\
Dentro de ese directorio, el archivo principal es main.cpp
Es el que contiene la función main() y la aplicación de usuario.
Las librerías de Arduino hay que añadirlas como otra librería cualquiera. Simplemente la incluyes en la ruta de compilación (-I) y la enlazas en tu aplicación main.cpp añadiendo los ficheros de cabecera correspondientes. No hay que hacer nada más.
El archivo C:\ARDUINO\hardware\teensy\avr\boards.txt es para que el IDE de Arduino tenga las diferentes opciones de compilación. A tí no te hace falta. Con poner tus opciones de compilación en tu proyecto de Atmel Studio es suficiente.
Modificar kinetis.h y core_pins.h es más complicado. Hay que definir todas las direcciones y números de cada puerto, interrupción, etc.
Puedes partir del Arduino Due que tiene un Atmel Cortex-M3, probablemente más parecido al tuyo que el Teensy.
Las librerías de Teensy serán genéricas, pero tendrán necesariamente alguna configuración dependiente del nucleo. Esa configuración suele venir precedida del nombre del nucleo:
#if defined(__MK64FX512__) || defined(__MK66FX1M0__)
Tienes que añadir ahí tu nuevo núcleo con su código personalizado.
Saludos.
-
Modificar kinetis.h y core_pins.h es más complicado. Hay que definir todas las direcciones y números de cada puerto, interrupción, etc.
Puedes partir del Arduino Due que tiene un Atmel Cortex-M3, probablemente más parecido al tuyo que el Teensy.
Solo ahí está la complicación, core_pins.h tiene 2000 lineas, y kinetis.h nada menos que 5700 lineas.
Ya vi e instale el SAM Due, y la forma de definir el core no se parece en nada. Lo tengo que estudiar con tranquilidad, porque no parece que haya un patrón definido para crear los cores que enganchen el micro a Arduino.
-
Lo que cuenta es que todos los fuentes de la carpeta C:\ARDUINO\hardware\teensy\avr\cores\teensy3\ sean consecuentes entre sí y que respondan a las constantes del sistema (por ejemplo A0 para la primera entrada analógica)
En este caso, si quieres aprovechar librerías Teensy, deberías mantener el mayor parecido posible con el código Teensy.
Si quieres te ayudo a convertir la documentación PDF en código C con una macro Python.
Saludos.
-
.
Eso es lo que trato de hacer, pero no parece que sean iguales en todos los cores, o faltan puertos. Además se definen otras cosas, algunos cores son super extensos, como el de Kinetis y otros todo lo contrario. Lo miraré con tranquilidad.
No entiendo lo de la documentación PDF a código C.
-
http://www.todopic.com.ar/foros/index.php?topic=43374.msg359160#msg359160
Saludos.
-
.
¿ Que hay que hacer con el datasheet del S70 para generar código C que configure los registros ?, no entiendo muy bien la utilidad de tu macro.
Mirando en Arduino algunos cores, entiendo parte, pero no se si los nombres de los puertos son siempre los mismos, también aparecen otras cosas que no son asignar un nombre a una dirección de memoria. Me llama mucho la atención que en Teensy el fichero kinetis.h tenga 5700 lineas.
Está claro que meter cualquier micro en Arduino, pasa por crear el core, pero la falta de un patrón y documentación técnica para poder hacerlo, es lo que lo complica bastante. En mi caso conocer los detalles de un core, me puede permitir sacar el aplicativo de Arduino, que es lo que realmente quiero hacer, para trabajarlo de manera nativa con Atmel Studio.