Portar proyecto de Arduino a Eclipse.

[planeta9999]

.

¿ 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.

[tsk]

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.

[planeta9999]

.

Gracias tsk, voy a echarle un ojo.

[Picuino]

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.

[Picuino]

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.

[Picuino]

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.

[planeta9999]

.

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.

[Picuino]

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.

[planeta9999]

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.

[Picuino]

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.

[Picuino]

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.

[Picuino]

Eclipse:



Arduino:



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.

[planeta9999]

.

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.

Código: [Seleccionar]

# 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


[Picuino]

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.

[planeta9999]

.

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.