Haz una pregunta
  Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

21/12/2010 #1

Avatar de Meta

Teensy ++ 2.0 (A estrenarlo).
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.
21/12/2010 #2

Avatar de Meta

Hola:

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

Las fotos que he sacado por ahora.








Felices fiestas 2010.
21/12/2010 #3

Avatar de Moyano Jonathan

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.
21/12/2010 #4

Avatar de Meta

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.
21/12/2010 #5

Avatar de Dr. Zoidberg

Meta dijo: Ver Mensaje
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!!!!!
21/12/2010 #6

Avatar de Meta

: shock::s hock:




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

Código:
# 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.
22/12/2010 #7

Avatar de Moyano Jonathan

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.
22/12/2010 #8

Avatar de Meta

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:

Código:
/* 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.
22/12/2010 #9

Avatar de Moyano Jonathan

Que raro ....3% de la memoria ocupada...es mucho para prender y apagar un led..
22/12/2010 #10

Avatar de Meta

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.
22/12/2010 #11

Avatar de Moyano Jonathan

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.
22/12/2010 #12

Avatar de Meta

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.

Saludo.
22/12/2010 #13

Avatar de Meta

Gracias por la información.

Esta parte del código viene así:
Código:
#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.

Código:
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.

Código:
// 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í:
Código:
// 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 #.
Código:
// 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...
23/12/2010 #14

Avatar de Meta

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...
23/12/2010 #15

Avatar de electroconico

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.

Código:
#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.
23/12/2010 #16

Avatar de Dr. Zoidberg

electroconico dijo: Ver Mensaje
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.
23/12/2010 #17

Avatar de Meta

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.
23/12/2010 #18

Avatar de Meta

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

23/12/2010 #19

Avatar de Moyano Jonathan

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 ?
24/12/2010 #20

Avatar de Meta

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.
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Foros de Electrónica » Diseño digital » Microcontroladores y sistemas embebidos

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.