# Teensy ++ 2.0 (A estrenarlo).



## Meta (Dic 21, 2010)

Hola:

Un amigo se compró el Teensy ++ 2.0. Ahora está ocupado en un empleo nuevo que consiguió y me lo prestó en este mismo momento para hacer pruebas, como Led parpadeante, apagar Led y endenderlo con un pulsador, etc, lo básico. No lo ha probado, sin embargo dice que es C y es fácil. Eso lo voy a comprobar si es tan fácil como dice. Él sabe C, yo no.








Al tenerlo en mis manos, me impresionó lo pequeño que es y su poco peso. Dentro de unas horas pondré capturas desde antes de abrirlo hasta abrirlo por si le pican la curiosidad algunos.


El SoftWare para trabajar con C me sorprendió ya que funciona bajo Windows, Linux e incluso Mac. (Lo mismo para el nuevo MPLAB X).

http://www.arduino.cc/en/Main/Software

Lo bueno de la Web principal, me llamó la atención sus increíbles tutoriales bien hechos, organizados con imágenes incluidas para empezar con este tipo de prototipo.  (Microchip.com debe coger este ejemplo, que espavilen o notarán ventas en AVR de Atmel que PIC de Microchip).






Fue comprado en este enlace:
http://www.pjrc.com/store/teensypp_pins.html

Con este cable:
http://www.pjrc.com/store/cable_usb_mini_b.html

El AVR de Atmel que viene es el:
90USB1286

He visto por Internet muy animagos en hacer libros en español sobre AVR. Los de PIC hay libros de sobra y siguen apareciendo, falta por aparecer los PIC32 en español, en Inglés está desde hace tiempo.

Voy hacer pruebas por primera vez desde cero con este dispositivo explicado en la Web haber si es tan fácil al menos de encender y apagat Led partiendo de sus tutotirales.

*¿Qué opinan del Teensy ++ 2.0?*

Un cordial saludo.

PD: _En unas horas subiré fotos sacadas desde un movil._


----------



## Meta (Dic 21, 2010)

Hola:

Gracias por el apoyo. 
90USB1826
http://www.atmel.com/dyn/resources/prod_documents/7593S.pdf

Las fotos que he sacado por ahora.




















Felices fiestas 2010.


----------



## Moyano Jonathan (Dic 21, 2010)

Esa herramienta es muy poderosa, podés conseguir un libro de C y empezar a hacer pruebas para GCC vas a ver lo poderoso que puede llegar a ser.


----------



## Meta (Dic 21, 2010)

Hola:

Puede ser poderoso. Lo importante que asm me tiene negro y también dice que es más poderoso, más rápido, más eficaz que los lenguajes de alto nivel pero me cuesta mucho tiempo y trabajo en entender algo. jejejeje.

En el papel que me vino del Teensy ++ 2.0, tiene dos caras y no se cual escoger.

http://www.pjrc.com/teensy/card4a.pdf

http://www.pjrc.com/teensy/card4b.pdf

Estoy en blanco. No se cual escoger para empezar y no tengo ni la más  mínima idea de AVR. Probaré en una máquina Virtual Box con _*Ubuntu 10.10 32-bits*_ y _*openSUSE 11.3 64-bits*_ en Windows 7 nativo 64 bits más adelante.

Saludo.

Saludo.


----------



## Dr. Zoidberg (Dic 21, 2010)

Meta dijo:


> Puede ser poderoso. *Lo importante que asm me tiene negro y también dice que es más poderoso, más rápido, más eficaz que los lenguajes de alto nivel pero me cuesta mucho tiempo y trabajo en entender algo*. jejejeje.


       
Bien!!!!! Vamos aprendiendo la lección!!!!!


----------



## Meta (Dic 21, 2010)

Edito:

http://www.subeimagenes.com/img/te-10177.png

Estoy pecando. Según el enlace de abajo hay que hacer algo, ni me sale.
http://www.pjrc.com/teensy/gcc.html


```
# Hey Emacs, this is a -*- makefile -*-
#----------------------------------------------------------------------------
# WinAVR Makefile Template written by Eric B. Weddington, Jörg Wunsch, et al.
#
# Released to the Public Domain
#
# Additional material for this makefile was written by:
# Peter Fleury
# Tim Henigan
# Colin O'Flynn
# Reiner Patommel
# Markus Pfaff
# Sander Pool
# Frederik Rouleau
# Carlos Lamas
#
#----------------------------------------------------------------------------
# On command line:
#
# make all = Make software.
#
# make clean = Clean out built project files.
#
# make coff = Convert ELF to AVR COFF.
#
# make extcoff = Convert ELF to AVR Extended COFF.
#
# make program = Download the hex file to the device, using avrdude.
#                Please customize the avrdude settings below first!
#
# make debug = Start either simulavr or avarice as specified for debugging, 
#              with avr-gdb or avr-insight as the front end for debugging.
#
# make filename.s = Just compile filename.c into the assembler code only.
#
# make filename.i = Create a preprocessed source file for use in submitting
#                   bug reports to the GCC project.
#
# To rebuild project do "make clean" then "make all".
#----------------------------------------------------------------------------


# Target file name (without extension).
TARGET = blinky


# List C source files here. (C dependencies are automatically generated.)
SRC =    $(TARGET).c \
    usb_debug_only.c \
    print.c

# MCU name, you MUST set this to match the board you are using
# type "make clean" after changing this, so all files will be rebuilt
#
#MCU = at90usb162       # Teensy 1.0
#MCU = atmega32u4        # Teensy 2.0
#MCU = at90usb646       # Teensy++ 1.0
MCU = at90usb1286      # Teensy++ 2.0


# Processor frequency.
#   Normally the first thing your program should do is set the clock prescaler,
#   so your program will run at the correct speed.  You should also set this
#   variable to same clock speed.  The _delay_ms() macro uses this, and many
#   examples use this variable to calculate timings.  Do not add a "UL" here.
F_CPU = 16000000


# Output format. (can be srec, ihex, binary)
FORMAT = ihex


# Object files directory
#     To put object files in current directory, use a dot (.), do NOT make
#     this an empty or blank macro!
OBJDIR = .


# List C++ source files here. (C dependencies are automatically generated.)
CPPSRC = 


# List Assembler source files here.
#     Make them always end in a capital .S.  Files ending in a lowercase .s
#     will not be considered source files but generated files (assembler
#     output from the compiler), and will be deleted upon "make clean"!
#     Even though the DOS/Win* filesystem matches both .s and .S the same,
#     it will preserve the spelling of the filenames, and gcc itself does
#     care about how the name is spelled on its command-line.
ASRC =


# Optimization level, can be [0, 1, 2, 3, s]. 
#     0 = turn off optimization. s = optimize for size.
#     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
OPT = s


# Debugging format.
#     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
#     AVR Studio 4.10 requires dwarf-2.
#     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
DEBUG = dwarf-2


# List any extra directories to look for include files here.
#     Each directory must be seperated by a space.
#     Use forward slashes for directory separators.
#     For a directory that has spaces, enclose it in quotes.
EXTRAINCDIRS = 


# Compiler flag to set the C Standard level.
#     c89   = "ANSI" C
#     gnu89 = c89 plus GCC extensions
#     c99   = ISO C99 standard (not yet fully implemented)
#     gnu99 = c99 plus GCC extensions
CSTANDARD = -std=gnu99


# Place -D or -U options here for C sources
CDEFS = -DF_CPU=$(F_CPU)UL


# Place -D or -U options here for ASM sources
ADEFS = -DF_CPU=$(F_CPU)


# Place -D or -U options here for C++ sources
CPPDEFS = -DF_CPU=$(F_CPU)UL
#CPPDEFS += -D__STDC_LIMIT_MACROS
#CPPDEFS += -D__STDC_CONSTANT_MACROS



#---------------- Compiler Options C ----------------
#  -g*:          generate debugging information
#  -O*:          optimization level
#  -f...:        tuning, see GCC manual and avr-libc documentation
#  -Wall...:     warning level
#  -Wa,...:      tell GCC to pass this to the assembler.
#    -adhlns...: create assembler listing
CFLAGS = -g$(DEBUG)
CFLAGS += $(CDEFS)
CFLAGS += -O$(OPT)
CFLAGS += -funsigned-char
CFLAGS += -funsigned-bitfields
CFLAGS += -ffunction-sections
CFLAGS += -fpack-struct
CFLAGS += -fshort-enums
CFLAGS += -Wall
CFLAGS += -Wstrict-prototypes
#CFLAGS += -mshort-calls
#CFLAGS += -fno-unit-at-a-time
#CFLAGS += -Wundef
#CFLAGS += -Wunreachable-code
#CFLAGS += -Wsign-compare
CFLAGS += -Wa,-adhlns=$(<:%.c=$(OBJDIR)/%.lst)
CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
CFLAGS += $(CSTANDARD)


#---------------- Compiler Options C++ ----------------
#  -g*:          generate debugging information
#  -O*:          optimization level
#  -f...:        tuning, see GCC manual and avr-libc documentation
#  -Wall...:     warning level
#  -Wa,...:      tell GCC to pass this to the assembler.
#    -adhlns...: create assembler listing
CPPFLAGS = -g$(DEBUG)
CPPFLAGS += $(CPPDEFS)
CPPFLAGS += -O$(OPT)
CPPFLAGS += -funsigned-char
CPPFLAGS += -funsigned-bitfields
CPPFLAGS += -fpack-struct
CPPFLAGS += -fshort-enums
CPPFLAGS += -fno-exceptions
CPPFLAGS += -Wall
CPPFLAGS += -Wundef
#CPPFLAGS += -mshort-calls
#CPPFLAGS += -fno-unit-at-a-time
#CPPFLAGS += -Wstrict-prototypes
#CPPFLAGS += -Wunreachable-code
#CPPFLAGS += -Wsign-compare
CPPFLAGS += -Wa,-adhlns=$(<:%.cpp=$(OBJDIR)/%.lst)
CPPFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
#CPPFLAGS += $(CSTANDARD)


#---------------- Assembler Options ----------------
#  -Wa,...:   tell GCC to pass this to the assembler.
#  -adhlns:   create listing
#  -gstabs:   have the assembler create line number information; note that
#             for use in COFF files, additional information about filenames
#             and function names needs to be present in the assembler source
#             files -- see avr-libc docs [FIXME: not yet described there]
#  -listing-cont-lines: Sets the maximum number of continuation lines of hex 
#       dump that will be displayed for a given single line of source input.
ASFLAGS = $(ADEFS) -Wa,-adhlns=$(<:%.S=$(OBJDIR)/%.lst),-gstabs,--listing-cont-lines=100


#---------------- Library Options ----------------
# Minimalistic printf version
PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min

# Floating point printf version (requires MATH_LIB = -lm below)
PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt

# If this is left blank, then it will use the Standard printf version.
PRINTF_LIB = 
#PRINTF_LIB = $(PRINTF_LIB_MIN)
#PRINTF_LIB = $(PRINTF_LIB_FLOAT)


# Minimalistic scanf version
SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min

# Floating point + %[ scanf version (requires MATH_LIB = -lm below)
SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt

# If this is left blank, then it will use the Standard scanf version.
SCANF_LIB = 
#SCANF_LIB = $(SCANF_LIB_MIN)
#SCANF_LIB = $(SCANF_LIB_FLOAT)


MATH_LIB = -lm


# List any extra directories to look for libraries here.
#     Each directory must be seperated by a space.
#     Use forward slashes for directory separators.
#     For a directory that has spaces, enclose it in quotes.
EXTRALIBDIRS = 



#---------------- External Memory Options ----------------

# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# used for variables (.data/.bss) and heap (malloc()).
#EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff

# 64 KB of external RAM, starting after internal RAM (ATmega128!),
# only used for heap (malloc()).
#EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff

EXTMEMOPTS =



#---------------- Linker Options ----------------
#  -Wl,...:     tell GCC to pass this to linker.
#    -Map:      create map file
#    --cref:    add cross reference to  map file
LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
LDFLAGS += -Wl,--relax
LDFLAGS += -Wl,--gc-sections
LDFLAGS += $(EXTMEMOPTS)
LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
#LDFLAGS += -T linker_script.x



#---------------- Programming Options (avrdude) ----------------

# Programming hardware
# Type: avrdude -c ?
# to get a full listing.
#
AVRDUDE_PROGRAMMER = stk500v2

# com1 = serial port. Use lpt1 to connect to parallel port.
AVRDUDE_PORT = com1    # programmer connected to serial device

AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
#AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep


# Uncomment the following if you want avrdude's erase cycle counter.
# Note that this counter needs to be initialized first using -Yn,
# see avrdude manual.
#AVRDUDE_ERASE_COUNTER = -y

# Uncomment the following if you do /not/ wish a verification to be
# performed after programming the device.
#AVRDUDE_NO_VERIFY = -V

# Increase verbosity level.  Please use this when submitting bug
# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> 
# to submit bug reports.
#AVRDUDE_VERBOSE = -v -v

AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)



#---------------- Debugging Options ----------------

# For simulavr only - target MCU frequency.
DEBUG_MFREQ = $(F_CPU)

# Set the DEBUG_UI to either gdb or insight.
# DEBUG_UI = gdb
DEBUG_UI = insight

# Set the debugging back-end to either avarice, simulavr.
DEBUG_BACKEND = avarice
#DEBUG_BACKEND = simulavr

# GDB Init Filename.
GDBINIT_FILE = __avr_gdbinit

# When using avarice settings for the JTAG
JTAG_DEV = /dev/com1

# Debugging port used to communicate between GDB / avarice / simulavr.
DEBUG_PORT = 4242

# Debugging host used to communicate between GDB / avarice / simulavr, normally
#     just set to localhost unless doing some sort of crazy debugging when 
#     avarice is running on a different computer.
DEBUG_HOST = localhost



#============================================================================


# Define programs and commands.
SHELL = sh
CC = avr-gcc
OBJCOPY = avr-objcopy
OBJDUMP = avr-objdump
SIZE = avr-size
AR = avr-ar rcs
NM = avr-nm
AVRDUDE = avrdude
REMOVE = rm -f
REMOVEDIR = rm -rf
COPY = cp
WINSHELL = cmd


# Define Messages
# English
MSG_ERRORS_NONE = Errors: none
MSG_BEGIN = -------- begin --------
MSG_END = --------  end  --------
MSG_SIZE_BEFORE = Size before: 
MSG_SIZE_AFTER = Size after:
MSG_COFF = Converting to AVR COFF:
MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
MSG_FLASH = Creating load file for Flash:
MSG_EEPROM = Creating load file for EEPROM:
MSG_EXTENDED_LISTING = Creating Extended Listing:
MSG_SYMBOL_TABLE = Creating Symbol Table:
MSG_LINKING = Linking:
MSG_COMPILING = Compiling C:
MSG_COMPILING_CPP = Compiling C++:
MSG_ASSEMBLING = Assembling:
MSG_CLEANING = Cleaning project:
MSG_CREATING_LIBRARY = Creating library:




# Define all object files.
OBJ = $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o) 

# Define all listing files.
LST = $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst) 


# Compiler flags to generate dependency files.
GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d


# Combine all necessary flags and optional flags.
# Add target processor to flags.
ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)





# Default target.
all: begin gccversion sizebefore build sizeafter end

# Change the build target to build a HEX file or a library.
build: elf hex eep lss sym
#build: lib


elf: $(TARGET).elf
hex: $(TARGET).hex
eep: $(TARGET).eep
lss: $(TARGET).lss
sym: $(TARGET).sym
LIBNAME=lib$(TARGET).a
lib: $(LIBNAME)



# Eye candy.
# AVR Studio 3.x does not check make's exit code but relies on
# the following magic strings to be generated by the compile job.
begin:
    @echo
    @echo $(MSG_BEGIN)

end:
    @echo $(MSG_END)
    @echo


# Display size of file.
HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
#ELFSIZE = $(SIZE) --mcu=$(MCU) --format=avr $(TARGET).elf
ELFSIZE = $(SIZE) $(TARGET).elf

sizebefore:
    @if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \
    2>/dev/null; echo; fi

sizeafter:
    @if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \
    2>/dev/null; echo; fi



# Display compiler version information.
gccversion : 
    @$(CC) --version



# Program the device.  
program: $(TARGET).hex $(TARGET).eep
    $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)


# Generate avr-gdb config/init file which does the following:
#     define the reset signal, load the target file, connect to target, and set 
#     a breakpoint at main().
gdb-config: 
    @$(REMOVE) $(GDBINIT_FILE)
    @echo define reset >> $(GDBINIT_FILE)
    @echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
    @echo end >> $(GDBINIT_FILE)
    @echo file $(TARGET).elf >> $(GDBINIT_FILE)
    @echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)
ifeq ($(DEBUG_BACKEND),simulavr)
    @echo load  >> $(GDBINIT_FILE)
endif
    @echo break main >> $(GDBINIT_FILE)

debug: gdb-config $(TARGET).elf
ifeq ($(DEBUG_BACKEND), avarice)
    @echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
    @$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
    $(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
    @$(WINSHELL) /c pause

else
    @$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
    $(DEBUG_MFREQ) --port $(DEBUG_PORT)
endif
    @$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)




# Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
COFFCONVERT = $(OBJCOPY) --debugging
COFFCONVERT += --change-section-address .data-0x800000
COFFCONVERT += --change-section-address .bss-0x800000
COFFCONVERT += --change-section-address .noinit-0x800000
COFFCONVERT += --change-section-address .eeprom-0x810000



coff: $(TARGET).elf
    @echo
    @echo $(MSG_COFF) $(TARGET).cof
    $(COFFCONVERT) -O coff-avr $< $(TARGET).cof


extcoff: $(TARGET).elf
    @echo
    @echo $(MSG_EXTENDED_COFF) $(TARGET).cof
    $(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof



# Create final output files (.hex, .eep) from ELF output file.
%.hex: %.elf
    @echo
    @echo $(MSG_FLASH) $@
    $(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock -R .signature $< $@

%.eep: %.elf
    @echo
    @echo $(MSG_EEPROM) $@
    -$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
    --change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT) $< $@ || exit 0

# Create extended listing file from ELF output file.
%.lss: %.elf
    @echo
    @echo $(MSG_EXTENDED_LISTING) $@
    $(OBJDUMP) -h -S -z $< > $@

# Create a symbol table from ELF output file.
%.sym: %.elf
    @echo
    @echo $(MSG_SYMBOL_TABLE) $@
    $(NM) -n $< > $@



# Create library from object files.
.SECONDARY : $(TARGET).a
.PRECIOUS : $(OBJ)
%.a: $(OBJ)
    @echo
    @echo $(MSG_CREATING_LIBRARY) $@
    $(AR) $@ $(OBJ)


# Link: create ELF output file from object files.
.SECONDARY : $(TARGET).elf
.PRECIOUS : $(OBJ)
%.elf: $(OBJ)
    @echo
    @echo $(MSG_LINKING) $@
    $(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)


# Compile: create object files from C source files.
$(OBJDIR)/%.o : %.c
    @echo
    @echo $(MSG_COMPILING) $<
    $(CC) -c $(ALL_CFLAGS) $< -o $@ 


# Compile: create object files from C++ source files.
$(OBJDIR)/%.o : %.cpp
    @echo
    @echo $(MSG_COMPILING_CPP) $<
    $(CC) -c $(ALL_CPPFLAGS) $< -o $@ 


# Compile: create assembler files from C source files.
%.s : %.c
    $(CC) -S $(ALL_CFLAGS) $< -o $@


# Compile: create assembler files from C++ source files.
%.s : %.cpp
    $(CC) -S $(ALL_CPPFLAGS) $< -o $@


# Assemble: create object files from assembler source files.
$(OBJDIR)/%.o : %.S
    @echo
    @echo $(MSG_ASSEMBLING) $<
    $(CC) -c $(ALL_ASFLAGS) $< -o $@


# Create preprocessed source for use in sending a bug report.
%.i : %.c
    $(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@ 


# Target: clean project.
clean: begin clean_list end

clean_list :
    @echo
    @echo $(MSG_CLEANING)
    $(REMOVE) $(TARGET).hex
    $(REMOVE) $(TARGET).eep
    $(REMOVE) $(TARGET).cof
    $(REMOVE) $(TARGET).elf
    $(REMOVE) $(TARGET).map
    $(REMOVE) $(TARGET).sym
    $(REMOVE) $(TARGET).lss
    $(REMOVE) $(SRC:%.c=$(OBJDIR)/%.o)
    $(REMOVE) $(SRC:%.c=$(OBJDIR)/%.lst)
    $(REMOVE) $(SRC:.c=.s)
    $(REMOVE) $(SRC:.c=.d)
    $(REMOVE) $(SRC:.c=.i)
    $(REMOVEDIR) .dep


# Create object files directory
$(shell mkdir $(OBJDIR) 2>/dev/null)


# Include the dependency files.
-include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)


# Listing of phony targets.
.PHONY : all begin finish end sizebefore sizeafter gccversion \
build elf hex eep lss sym coff extcoff \
clean clean_list program debug gdb-config
```
Puse en modo consola "make all" y me compiló el .hex en Ubuntu 10.10. 

Siguiendo investigando y me quedé en 
*Details In The Blinky Source Code*


No se que hacer.


----------



## Moyano Jonathan (Dic 22, 2010)

Pero meta si para Windows tenés WinAVR que es mucho más sencillo de usar....decargatelo instalalo y después te paso un programa de ejemplo.


----------



## Meta (Dic 22, 2010)

Ni se cuál es el más sencillo, ahora acaba de avanzar un poco y me volví a atascar.

Buenas:

Por ahora lo que puedo mostrar son capturas de pantalla. 






Estoy atascado y no se que hacer a partir de aquí. Recuerdo que no tengo  ni la más idea de los AVR de Atmel y me cuesta el Inglés.
*Details In The Blinky Source Code*

Using avr-gcc with the Teensy USB development board

Compilé el archivo make y me generó el .hex del AT90USB1826.

Parece que hay que seguir con este archivo llamado blicky.c, su código interior es:


```
/* LED Blink Example with USB Debug Channel for Teensy USB Development Board
 * http://www.pjrc.com/teensy/
 * Copyright (c) 2008, 2010 PJRC.COM, LLC
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "usb_debug_only.h"
#include "print.h"


// Teensy 2.0: LED is active high
#if defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB1286__)
#define LED_ON        (PORTD |= (1<<6))
#define LED_OFF        (PORTD &= ~(1<<6))

// Teensy 1.0: LED is active low
#else
#define LED_ON    (PORTD &= ~(1<<6))
#define LED_OFF    (PORTD |= (1<<6))
#endif

#define LED_CONFIG    (DDRD |= (1<<6))
#define CPU_PRESCALE(n)    (CLKPR = 0x80, CLKPR = (n))
#define DIT 80        /* unit time for morse code */

void morse_character(char c);
void morse_P(const char *s);
const unsigned char morse_code_table[];


int main(void)
{
    unsigned char i;

    // set for 16 MHz clock, and make sure the LED is off
    CPU_PRESCALE(0);
    LED_CONFIG;
    LED_OFF;

    // initialize the USB, but don't want for the host to
    // configure.  The first several messages sent will be
    // lost because the PC hasn't configured the USB yet,
    // but we care more about blinking than debug messages!
    usb_init();

    // blink morse code messages!
    while (1) {
        for (i=0; i<6; i++) {
            morse_P(PSTR("SOS"));
            _delay_ms(1500);
        }
        morse_P(PSTR("DOES ANYBODY STILL KNOW MORSE CODE?"));
        _delay_ms(4000);
    }
}

// blink a single character in Morse code
void morse_character(char c)
{
    unsigned char code, count;

    if (c == ' ') {
        print("Space\n");
        _delay_ms(DIT * 7);
        return;
    }
    if (c < 'A' || c > 'Z') {
        print("Opps, unsupported character: ");
        pchar(c);
        print("\n");
        return;    
    }
    print("Char ");
    pchar(c);
    pchar(':');
    code = pgm_read_byte(morse_code_table + (c - 'A'));
    for (count = code & 0x07; count > 0; count--) {
        LED_ON;
        if (code & 0x80) {
            print(" dah");
            _delay_ms(DIT * 3);
        } else {
            print(" dit");
            _delay_ms(DIT);
        }
        LED_OFF;
        _delay_ms(DIT);
        code = code << 1;
    }
    print("\n");
    _delay_ms(DIT * 2);
}

// blink an entire message in Morse code
// the string must be in flash memory (using PSTR macro)
void morse_P(const char *s)
{
    char c;
    
    while (1) {
        c = pgm_read_byte(s++);
        if (!c) break;
        morse_character(c);
    }
    print("\n");
}

// lookup table for all 26 letters.  Upper 5 bits are the pulses
// to send (MSB first), and the lower 3 bits are the number of
// bits to send for this letter.
const unsigned char PROGMEM morse_code_table[] = {
    0x40 + 2,    // A: .-
    0x80 + 4,    // B: -...
    0xA0 + 4,    // C: -.-.
    0x80 + 3,    // D: -..
    0x00 + 1,    // E: .
    0x20 + 4,    // F: ..-.
    0xC0 + 3,    // G: --.
    0x00 + 4,    // H: ....
    0x00 + 2,    // I: ..
    0x70 + 4,    // J: .---
    0xA0 + 3,    // K: -.-
    0x40 + 4,    // L: .-..
    0xC0 + 2,    // M: --
    0x80 + 2,    // N: -.
    0xE0 + 3,    // O: ---
    0x60 + 4,    // P: .--.
    0xD0 + 4,    // Q: --.-
    0x40 + 3,    // R: .-.
    0x00 + 3,    // S: ...
    0x80 + 1,    // T: -
    0x20 + 3,    // U: ..-
    0x10 + 4,    // V: ...-
    0x60 + 3,    // W: .--
    0x90 + 4,    // X: -..-
    0xB0 + 4,    // Y: -.--
    0xC0 + 4    // Z: --..
};
```
No veo ni rastro de esquema eléctrico para poner un Led. Como no  conozco este dispositivo, no me quiero arriesgar a quemar, romper o lo  que sea del Teensy y no es mio. Bastante he quemado PIC16F84A y 16F88  como para quemar un AVR sin estrenar, ejjejejeejejej. 
	

	
	
		
		

		
		
	


	



Por ahí debe haber algúl esquemita de lo que me está hablando, más que el Inglés me cuestra, capaz que me salté algo.

Subiré más fotos y vídeos del primer Led intermitente.






Parece que ahora falta un toque de acción. Antes ver esquema para  conectar los Led y resistencias en sus debidos pines del Teensy ++ 2.0.

Saludo.


----------



## Moyano Jonathan (Dic 22, 2010)

Que raro ....3% de la memoria ocupada...es mucho para prender y apagar un led..


----------



## Meta (Dic 22, 2010)

Arriba tienes el código fuente. Parece que hace más cosas. Recuerda que los AVR necesitan más memoria que los PIC sea en asm o en C.


----------



## Moyano Jonathan (Dic 22, 2010)

No está bien meta, ahí lo vi perdon. Disculpame pero me parece que te equivocas...los AVR fueron inventados pensando en la ejecución eficiente de código c compilado.


----------



## Meta (Dic 22, 2010)

Lo se, ya lo había leído por ahí. Eso en los 8 bit se dice que están por encima de los PIC. En cuanto a los 16 bits los supera los dsPIC firmemente, en cuanto a los 32 bits no tengo idea.

Lo que no sabía que hay muchos microcontroladores en el mercado de diferentes casa, incluso ya con 4 y 8 núcleos. 

Seguro que me faltan algunas más en la pequeña lista.



ARM
Atmel
Cypress
Diodes
Fairchildsemi
FreeScale
FTDIchip
Fujitsu
Hitachi
Holtek
IDT
Infineon
Intersil
JMicron
LSI
Maxim-IC
Micrel
Microchip
Microsemi
National
NEC
Nuvoton
On Semi
Parallax
Philips
Picaxe
Rabbit
Renesas
Samsung
Semtech
Silabs
STMicroelectronics
TI
Toshiba
Winbond USA
Xmos
Saludo.


----------



## Meta (Dic 22, 2010)

Gracias por la información.

Esta parte del código viene así:

```
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include "usb_debug_only.h"
#include "print.h"
```
Por lo que veo, hay que quitar los # que son  como comentarios, si los deja los lee como comentario y el compilador lo  ignora.


```
include <avr/io.h>
include <avr/pgmspace.h>
include <util/delay.h>
include "usb_debug_only.h"
include "print.h"
```
En esta otra parte del código que se muestra  abajo, corríjanme si me equivoco hay que usar la configuración adecuada.


```
// Teensy 2.0: LED is active high
#if defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB1286__)
#define LED_ON        (PORTD |= (1<<6))
#define LED_OFF        (PORTD &= ~(1<<6))

// Teensy 1.0: LED is active low
#else
#define LED_ON    (PORTD &= ~(1<<6))
#define LED_OFF    (PORTD |= (1<<6))
#endif

#define LED_CONFIG    (DDRD |= (1<<6))
#define CPU_PRESCALE(n)    (CLKPR = 0x80, CLKPR = (n))
#define DIT 80        /* unit time for morse code */

void morse_character(char c);
void morse_P(const char *s);
const unsigned char morse_code_table[];
```
Como el que uso es el Teensy 2, quitaré las # y el código puede quedar así:

```
// Teensy 2.0: LED is active high
if defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB1286__)
define LED_ON        (PORTD |= (1<<6))
define LED_OFF        (PORTD &= ~(1<<6))

// Teensy 1.0: LED is active low
#else
#define LED_ON    (PORTD &= ~(1<<6))
#define LED_OFF    (PORTD |= (1<<6))
#endif

define LED_CONFIG    (DDRD |= (1<<6))
define CPU_PRESCALE(n)    (CLKPR = 0x80, CLKPR = (n))
define DIT 80        /* unit time for morse code */

void morse_character(char c);
void morse_P(const char *s);
const unsigned char morse_code_table[];
```
Justo debajo del Teensy 1 quité también las # del código de arriba.

Ahora voy a compilar y generar el .hex. Quiero saber el esquema eléctrico que todavía no conozco para hacer pruebas.

Leyendo bien puede ser quitando todas las #.

```
// Teensy 2.0: LED is active high
if defined(__AVR_ATmega32U4__) || defined(__AVR_AT90USB1286__)
define LED_ON        (PORTD |= (1<<6))
define LED_OFF        (PORTD &= ~(1<<6))

// Teensy 1.0: LED is active low
else
define LED_ON    (PORTD &= ~(1<<6))
define LED_OFF    (PORTD |= (1<<6))
endif

define LED_CONFIG    (DDRD |= (1<<6))
define CPU_PRESCALE(n)    (CLKPR = 0x80, CLKPR = (n))
define DIT 80        /* unit time for morse code */

void morse_character(char c);
void morse_P(const char *s);
const unsigned char morse_code_table[];
```
Sigo investigando...


----------



## Meta (Dic 23, 2010)

Voy a seguir con la otra parte del tutorial que me sale mejor.






He estado investigando y he aprendido solo cargar el hex al Teensy. Con  todo lo que aprenda y que no se me olvide, les paso un mini manual de lo  que he hecho hasta el momento, por ahora no es gran cosa. Según voy  aprendiendo y descubirendo cosas con Teensy, lo iré actualizando con  cualquier ejemplo, pondré fotos y vídeos.

Descargar manual: (PDF)

Sigo investigando...


----------



## electroconico (Dic 23, 2010)

Buen tuto.

Solo falta que aprendas a usar el teensy.

Los "#" que quitaste de los define no son comentarios.
Son propias del lenguaje "C" para no escribir chorradas y hacer más entendible la programación para el usuario.


```
#define LED_ON        (PORTD |= (1<<6))
```

Cada vez que el compilador vea esto LED_ON  lo interpretara como esto (PORTD |= (1<<6))

Que es poner a 1 el bit 6 del puerto D

Lo mismo con los include que llaman a otros archivos con funciones y tener mas ordenado el programa.

Si agarras un libro de C  seguro te saca de muchas dudas.


----------



## Dr. Zoidberg (Dic 23, 2010)

electroconico dijo:


> Son propias del lenguaje "C" para no escribir chorradas y hacer más entendible la programación para el usuario.



Los # indican que lo que viene a continuación es una directiva para el pre-procesador del lenguaje C. Los resultados de esas directivas se procesan antes de que "pase" el compilador, así que son analizadas un buen rato antes...y efectivamente, NO SON comentarios.


----------



## Meta (Dic 23, 2010)

Gracias por la ayuda. Pensé que son comentarioslos #, se que el C estandar es el // y el /* comentarios de varias líneas */






Saludo y gracias por la información. Sigo investigando.


----------



## Meta (Dic 23, 2010)

Otro pequeño avanse. Por fin llegué la parte de hacer el código y compilar. En cuanto al PDF me queda hacer la comunicación del teensy como si fuera a tra vez del HyperTerminal.






Sigo investigando y ampliando el manual...


----------



## Moyano Jonathan (Dic 23, 2010)

Te ha quedado exelente meta. Tenés para jugar para rato con ese micro...yo ahora estoy con el diseño de un entrenador para ATmega de 28 y 40 pines. Ahora es GCC o Arduino lo que estás ocupando para programar ?


----------



## Meta (Dic 24, 2010)

Hola:

Estoy con Arduino. Teensy++ 2.0 es un AVR AT90USB1826 de 64 pines. Por ahora estoy metiéndome en el mundo de los AVR de Atmel para ver como es, nunca había programado estos bichos y me parecen más fáciles que los PIC, cosa rara ya que los PIC tiene fama de ser más fácil. Voy a completar el manual del Teensy paso a paso, así muchas personas se animan a probar nuevos horizontes.

De todas maneras me centraré en los PIC, que los manejo mejor. Lo que no sabía que los AVR fueran tan potentes. Desde que salió el tema de la PS3 y el USB, todo el mundo está conociendo el mundo de Atmel cualquier persona que nunca jamás ha visto un microcontrlador antes. (También PIC, claro que los AVR aumentaron sus ventas desde ese día). 

Deja ver si acabo el manual v1.00 al menos este año. Probaré ejemplos que viene en teensyduino y míos propios.

Luego sigo peleándome con la adaptación del 16F84A al 16F88 para el temporizdor de la futura insoladora.

Suerte con tu manual del USB, esa tarea la tienes ocupada desde el 2008.


----------



## Moyano Jonathan (Dic 24, 2010)

Si es verdad....el manual meta en si....es grande por que el protocolo es complejo y requiere mucho estudio...algunas cosas está fuera de mi alcance como simple técnico...ahora el mini - manual de aplicación va tomando forma y espero tenerlo listo pronto.


----------



## Meta (Dic 24, 2010)

El mini manual es lo primero para dar un pequeño paso, hasta que te des cuesta que es una puerta principal y la más importante. Nadie va a subir directamente al tercer escalón, primero es lo primero, lo que nadie sabe cuanto tardarás es dar el segundo paso, pero lo das. 

Ánimo, no sabía que tardarías tanto en el manual pequeño para empezar a controlar E/S digitales. Debe ser muy complejo. A partir del 2012 que cuando Intel ya saca el chipset USB 3.0, muchas empresas, Mac OS incluido y las demás empezarás con esa tecnología, también los fabricantes de microcontroladores también.

Muchas suerte, ahora estoy investigando esta parte para comprender mejor el Teensy y haciendo el manual para el futuro.

http://www.pjrc.com/teensy/td_digital.html

Menos mal aunque no se muy bueno, este traductor me ha salvado de muchas cosas del Inglés.

http://translate.google.com/transla...&u=http://www.pjrc.com/teensy/td_digital.html

Adelante con tu manual. No creo que me dedique a los AVR más allá que los PIC. Parece que este AVR es más fácil que los PIC al usar una especie de lenguaje C, tendré que probar con el C18.


----------



## Moyano Jonathan (Dic 24, 2010)

El problema meta con C18 es que está enfocado a los PIC18 nada más. Yo en estos días estuve probando la versión más estable del compilador CCS hasta el momento la 4.114 y te digo que genera un código muy compacto y funcional para todos los PIC hasta la serie PIC18F.....todavía no he probado nada para PIC24, PIC30F y dsPIC33F.

La ventaja que tiene AVR es que el nucleo es el mismo para todos los dispositivos , con las mismas instrucciones lo que te da una gran ventaja a la hora de programar. Tienen una alta eficiencia al ejecutar código C compilado...incluso usando un ATtiny (la familia más chica).


----------



## Meta (Dic 24, 2010)

El que el C18 es para PIC18F, cada C tiene su compilador interno por cada familia, por eso los dsPIC tiene le propio y el PIC32 el suyo. No veo problema, sólo un orden, si lo quires tener todos, lo instala todos.

Los AVR tienen todo en un mismo banco. Que los PIC del futuro hagan lo mismo de una vez.. jejejej.

Cada uno con ventajas y desventajas.


----------



## cristian_elect (Dic 24, 2010)

Yo utilizo los atmel ya hace varios años son casi tan antiguos como los pic.
Los atmega son más rápidos que los pic18. Su asm es mas completo por eso son mas eficientes que los pic.
Un pic a 16mhz y un atmega a 4mhz el atmega le gana por un aproximado de 45% en proceso funciones matemáticas por eso lo usan para la carrera de Ing. Telecomunicaciones en vez de pic para los electrónicos en peru.
El compilador de mayor performance para los atmel es el iar


----------



## Moyano Jonathan (Dic 24, 2010)

Hola cristian , yo estoy de acuerdo con vos. Ahora me gusta usar más ATMEL pero PIC tiene sus aplicaciones también no hay que centralizarse en una familia.
Con respecto a la perfomance tenés razón , aunque el precio de dicho compilador es excesivo U$S 900. En cambio WinAVR tiene mucha documentación en la red...es gratuito...y una performance muy similar al IAR.


----------



## Meta (Dic 24, 2010)

Hola:

He estado infomrando por la red, los AVR de 8 bits son superiores a los PIC en muchas cosas. No es superior a los PIC18F así sin más, es superior a la mayoría, hay PIC18F que son superiores, solo algunos, claro que la ventaja de AVR se lo lleva Atmel más que los PIC de la gama 8 bits. 

En cuanto a los 16 Bits, he estado leyendo por foros de Atmel, hay dos tipos de PIC de 16 bits. El que tiene la arquitectura de los 8 bits pero en 16 bits y los dsPIC con una arquitectura muy superior. Los de AVR admiten que la gama 16 bits de dsPIC son muy superiores a los de Atmel y está demostrado. En cuanto a los 32 bits no se mucho, más bien los ARM superan al resto.

Como dice el dicho, da igual cual sea mejor o peor, solo se usa uno o otro por las necesidades de un proyecto concreto. ¿Por qué vas a pagar un bidón de agua de 16 Litros si sólo usas 1 Litro?

Lo que me tocas las narices de los PIC de 8 bits son los bancos de memoria que lo tiene por partes y AVR de 8 bits de una pasada. El asm de los AVR es más grande y engorroso. En temas de C, tiene mejor rendimiento los AVR según leo por ahí.

Hay muchos microcontroladores, está claro que por muy conocido que sea no signifique el mejor que se adapta a tus necesidades. 

https://www.forosdeelectronica.com/f24/teensy-2-0-estrenarlo-48736/#post419802

Saludo.


----------



## cristian_elect (Dic 24, 2010)

Yo solo ice una comparación del sin(X)
El atmega8 lo desarrolla un 45% mas rápido que el pic18f2550 a la misma frecuencia de proceso. Bueno no probé con la serie j y k de pic estos son mejorados.
Los compiladores que use es el ccs 4.xxx y el codevisionavr 2.xx.
No me acuerdo la versión exacta.
En ese tiempo un atmega8 costaba la mitad que un pic16f873 eso fue ace 2 años atras.


----------



## Meta (Dic 24, 2010)

El 45 % es mucho. ¿Estás seguro de eso? Es casi la mitad y la mayoría con PIC, entre ello me incluyo, hasta me gustan los PIC, menos los bancos de memoria.

Por si se lo han pasado por alto. Miren los microcontroladores que hay aquí. Son muchos mejores en rendimeinto y potencia que los PIC y AVR de cualquier familia.



ARM
Atmel
Cypress
Diodes
Fairchildsemi
FreeScale
FTDIchip
Fujitsu
Hitachi
Holtek
IDT
Infineon
Intersil
JMicron
LSI
Maxim-IC
Micrel
Microchip
Microsemi
National
NEC
Nuvoton
On Semi
Parallax
Philips
Picaxe
Rabbit
Renesas
Samsung
Semtech
Silabs
STMicroelectronics
TI
Toshiba
Winbond USA
Xmos
Jejejejejje, el que me llamó la atención es este:
http://www.rabbit.com/products/rab6000/


Tienen hasta compilador en C.
http://www.rabbit.com/products/dc/index.shtml

Hay que mirar bien cada fabricante, muchos ni se molestan en leer algún enlace que he puesto arriba, 

Hay más alternativas que escoger. La mayoría de la gente coge PIC o AVR por tema de que tiene más posibilidades de aprender el que tenga más información.


----------



## cristian_elect (Dic 24, 2010)

No exageres con los micros, estamos discutiendo en los micros de 8bits.
Hay de 16 y 32bits no se compara un DSPic con un ARM CORTEX R4.
AVR fabrica ARM9, cortex m3 y mas.


----------



## Meta (Dic 24, 2010)

Si saben más microcontroladores que no esté en la lista avisen, ejjeje. Hay que probar de todo. Muchoas empezamos aprendiendo pero no acabamos proyectos, a veces pasas estas cosas.


----------



## cristian_elect (Dic 24, 2010)

En tu lista no esta MIPS el que que diseño el nucleo del pic32 y altera, xilinx...


----------



## Meta (Dic 25, 2010)

Hola:

MIPS no es un microcontrolador, es un microprocesador.
http://es.wikipedia.org/wiki/MIPS_%28procesador%29

Altera es un FPGA. Si tiene microcontroladores avisa, no lo veo.
http://www.altera.com/

Tampoco veo que sea un microcontrolador el http://www.xilinx.com/

Gracias por las nuevas listas.


*Edito:*

Digo con pequeños avances para el manual en PDF.

Descargar manual Teensy++ 2.0 en PDF DEMO 2.

Saludo.


----------



## cristian_elect (Dic 25, 2010)

Marcas hay varias.
ACTEL, AustriaMicroSistems, Cirrus Logic, Ember, Energy Micro, Oki, ROHM, Sharp, Zilog, socle technology corp.
Tendría que hacer un estudio de todos los fabricantes cual el mejor rinde a un bajo precio y mejor soporte en información.

NPX tiene un Cortex M0 muy bajo precio, imaginate 32bits, 50MHZ con 13PWM compilador C gratis desde $1.
Tiene mas caracteristicas LPC111x.


----------



## Meta (Dic 25, 2010)

Zilog lo he dado en clase con un Z80 y es un microprocesador, por eso no lo he incluido. ejjejej. Está antes que el 8085.
http://www.zilog.com/docs/z80/um0080.pdf

Actel es un FPGA.

AustriaMicroSistems, parece un deribado de ARM.
http://www.austriamicrosystems.com/...ertainment/Analog-Integrated-Microcontrollers

Cirrus Logic no parece ser un microcontrolador.

Este si es un microcontrolador. (Añadido en la lista).
http://www.ember.com

También un microcontrolador, ahora en la lista.
http://www.energymicro.com

Oki también. Medio raro, pero lo es.
http://www.oki.com

¿Estás seguro que http://www.sharp.eu/es/ es un microcontrolador?

¿Qué es esto http://www.soletechnology.com/?



*Nota:* No meter microprocesadores, para eso meto Intel y AMD, ARM que ya está en la lista y no hace falta deribados de ella, tampoco FPAG.

Lista nueva:


ARM
Atmel
Cypress
Diodes
Ember
Energy Micro
Fairchildsemi
FreeScale
FTDIchip
Fujitsu
Hitachi
Holtek
IDT
Infineon
Intersil
JMicron
LSI
Maxim-IC
Micrel
Microchip
Microsemi
National
NEC
Nuvoton
Oki
On Semi
Parallax
Philips
Picaxe
Rabbit
Renesas
Rohm
Samsung
Semtech
Silabs
STMicroelectronics
TI
Toshiba
Winbond USA
Xmos
Tantas marcar que hay, no he visto foros ni Web en español que se metan en otro tipo de marcas. Me he metido con AVR por que me lo prestaron y porprobaron, me causó buen impresión.

Me iba a meter con rabbit, vi que es duro de conseguir y cara, eso si, tiene compilador gratis y en C con ejemplos incluidos.



Edito:
Algunos vídeos de los microcrontoladores poco conocidos.


----------



## cristian_elect (Dic 25, 2010)

Zilog fabrica ARM9.


----------



## Meta (Ene 16, 2011)

Les dejo un vídeo más probando el Led del Teensy++ 2.0. Muy interesante y se programa rápido y bien.

https://www.forosdeelectronica.com/f24/presento-manual-teensy-2-0-a-49923/

Saludo.


----------



## brunito47 (Ago 28, 2012)

donde se consiguen los teensy aca en argentina?


----------

