Autor Tema: Bootloader encriptado para Attiny88  (Leído 30617 veces)

0 Usuarios y 2 Visitantes están viendo este tema.

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re: Bootloader encriptado para Attiny88
« Respuesta #90 en: 02 de Octubre de 2015, 13:25:53 »
Citar
avr-ld -e init -o foo.elf foo.o

Código: [Seleccionar]
    .global init
init:
    rjmp main

Citar
-e entry
--entry=entry
    Use entry as the explicit symbol for beginning execution of your program, rather than the default entry point. If there is no symbol named entry, the linker will try to parse entry as a number, and use that as the entry address (the number will be interpreted in base 10; you may use a leading 0x for base 16, or a leading 0 for base 8).

Ahi esta la opcion xD

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #91 en: 03 de Octubre de 2015, 05:12:07 »
Con esa opción por fín lo conseguí.  :-/

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #92 en: 03 de Octubre de 2015, 05:14:06 »
Código: [Seleccionar]
avr-ld.exe  -section-start=.bootloader=8000  --entry=main -o prog.elf   prog1.o  prog2.o  prog3.o
Enlaza con main, pero directamente, sin incluir las rutinas de inicialización.

Ahora me toca inicializar a mí a mano. Creo que inicializando el puntero de stack y algún puerto será suficiente.
Sobre todo tengo que pensar en los agujeros de seguridad.


Un saludo.
« Última modificación: 03 de Octubre de 2015, 05:17:39 por Picuino »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #93 en: 03 de Octubre de 2015, 16:51:59 »
Última versión del algoritmo XTEA:

Código: [Seleccionar]
;
;  XTEA DECIPHER ROUTINE
;

; *******************************************************************
;   DECLARATIONS
; *******************************************************************
#define DATA_REGISTER_INIT_ADDRESS   0x02
#define  data0       r2
#define  data1       r3
#define  data2       r4
#define  data3       r5
#define  data4       r6
#define  data5       r7
#define  data6       r8
#define  data7       r9
#define  temp0       r10
#define  temp1       r11
#define  temp2       r12
#define  temp3       r13
#define  buff0       r14
#define  buff1       r15

#define  rounds      r17
#define  sum0        r18
#define  sum1        r19
#define  sum2        r20
#define  sum3        r21
#define  r_index     r22
#define  r_loop      r23
#define  temp4       r24
#define  temp5       r25
#define  temp6       r26
#define  temp7       r27

#define  YL          r28
#define  YH          r29
#define  ZL          r30
#define  ZH          r31


#define  XTEA_ROUNDS  32
#define  DELTA        0x9E3779B9

#define  XTEA_KEY1    0x87654321
#define  XTEA_KEY2    0x87654321
#define  XTEA_KEY3    0x87654321
#define  XTEA_KEY4    0x87654321

#define  DELTA_SUM   (DELTA*XTEA_ROUNDS)
#define  CARRY        0


; *******************************************************************
;   SRAM DATA
; *******************************************************************
.data
.extern data_buff

; *******************************************************************
;   PROGRAM
; *******************************************************************
.text


; *******************************************************************
;   MODULE: XTEA_DECODE                          144 bytes
; *******************************************************************
;
; xtea_decode_block
;
; Inputs:
;   data0 ... data7 = 8 bytes of coded data
;
; Outputs:
;   data0 ... data7 = 8 bytes of decoded data
;

xtea_decode:

   ; sum = 0xC6EF3720 = DELTA*32
   ldi    sum0, lo8(DELTA_SUM)
   ldi    sum1, hi8(DELTA_SUM)
   ldi    sum2, hlo8(DELTA_SUM)
   ldi    sum3, hhi8(DELTA_SUM)


   ; rounds = XTEA_ROUNDS * 2
   ldi   rounds, XTEA_ROUNDS*2

   ; do {
xtea_decode_loop:

   ; temp_a = data0
   movw  temp0, data0
   movw  temp2, data2

   ; temp_b = data0
   movw  temp4, data0
   movw  temp6, data2

   ; data0 = data1
   movw  data0, data4
   movw  data2, data6

   ; data1 = temp_a
   movw  data4, temp0
   movw  data6, temp2


   ; temp_a <<= 4
   ldi   r_index, 4
xtea_shift_left:
   lsl   temp0
   rol   temp1
   rol   temp2
   rol   temp3
   dec   r_index
   brne  xtea_shift_left


   ; temp_b >>= 5
   ldi   r_index, 5
xtea_shift_right:
   lsr   temp7
   ror   temp6
   ror   temp5
   ror   temp4
   dec   r_index
   brne  xtea_shift_right


   ; temp_a ^= temp_b
   eor   temp0, temp4
   eor   temp1, temp5
   eor   temp2, temp6
   eor   temp3, temp7


   ; temp_a += data1
   add   temp0, data4
   adc   temp1, data5
   adc   temp2, data6
   adc   temp3, data7


   ; r1 = ((sum>>11) & 3)*4
   mov   r_index, sum1
   lsr   r_index
   ; if ((rounds & 1) == 1):
   ;    r1 = (sum & 3)*4
   sbrs  rounds, 0
   rjmp  xtea_label_2
   mov   r_index, sum0
   lsl   r_index
   lsl   r_index
xtea_label_2:
   andi  r_index, 0x0C


   ; temp_b = xtea_key[r1*4]
   ldi   ZH, hi8(xtea_key_table)
   ldi   ZL, lo8(xtea_key_table)
   add   ZL, r_index
#ifndef BOOTLOADER_IN_PAGE
   ldi   r_index, 0
   adc   ZH, r_index
#endif

   lpm   temp4, Z+
   lpm   temp5, Z+
   lpm   temp6, Z+
   lpm   temp7, Z+


   ; temp_b += sum
   add   temp4, sum0
   adc   temp5, sum1
   adc   temp6, sum2
   adc   temp7, sum3


   ; temp_a ^= temp_b
   eor   temp0, temp4
   eor   temp1, temp5
   eor   temp2, temp6
   eor   temp3, temp7


   ; data0 -= temp_a
   sub   data0, temp0
   sbc   data1, temp1
   sbc   data2, temp2
   sbc   data3, temp3


   ; if ((rounds & 1) == 0):
   ;    sum -= 0x9E3779B9
   sbrc  rounds, 0
   rjmp  xtea_label_3
   subi  sum0, lo8(DELTA)
   sbci  sum1, hi8(DELTA)
   sbci  sum2, hlo8(DELTA)
   sbci  sum3, hhi8(DELTA)
xtea_label_3:


   ;    rounds -= 1
   ; } while(rounds);
   dec   rounds
   breq  xtea_end_loop
   rjmp  xtea_decode_loop

xtea_end_loop:
   ret


; *******************************************************************
;   XTEA KEY TABLE                               16 bytes 
; *******************************************************************
xtea_key_table:
   .long  XTEA_KEY1
   .long  XTEA_KEY2
   .long  XTEA_KEY3
   .long  XTEA_KEY4

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re: Bootloader encriptado para Attiny88
« Respuesta #94 en: 03 de Octubre de 2015, 17:14:42 »
Ya casi lo tenes. A que te referis con agujeros de seguridad ?

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #95 en: 04 de Octubre de 2015, 04:23:30 »
Casi tenía completada una versión, cuando me dí cuenta que reduciéndo el tamaño al máximo ocupaba 420 bytes.
Es demasiado, así que me he planteado quitar todo lo que no sea imprescindible.

He quitado un bucle de la rutina xtea, para que sólo reciba y decodifique 8bytes a la vez. Ahora escribir la página de flash por completo depende del bootloader del PC

Otras cuestiones no puedo delegarlas, porque tengo que imaginar que el bootloader es hostil. Por ejemplo, mantener el vector de reset apuntando al bootloader o impedir la escritura en las páginas donde está alojado el bootloader.

En la rutina de inicialización colocaré lo imprescindible: un cli (no quiero que salte a otro sitio durante la carga), inicialización del stack, puertos y alguna cosa más.
« Última modificación: 04 de Octubre de 2015, 04:27:02 por Picuino »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #96 en: 04 de Octubre de 2015, 04:31:06 »
La duda que me surge es, ¿dónde recolocar la dirección de inicio de la aplicación de usuario? (el vector de reset de usuario)
Lo más cómodo y rápido sería utilizar otro vector de interrupción dentro de los 4 primeros:
INT0, INT1, PCINT0

A mí me sirve, pero si más adelante quiero utilizar el bootloader para otra aplicación con esas interrupciones utilizadas, tendría que cambiarlo.

Un saludo.

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re: Bootloader encriptado para Attiny88
« Respuesta #97 en: 04 de Octubre de 2015, 06:31:41 »
Yo pensaba en poner el bootloader junto con la tabla de vectores y no al final. De esa forma nunca se puede escribir los mismos.

Luego en tu programa que vas a cargar en el linker definis que la flash no comienza en 0x0000 sino ( supongamos que es la pagina que sigue) en 0x100, Lo que haces vos en tu tabla de vectores es:

- El de reset apuntarlo al bootloader y cuando finaliza el bootloader hacer un salto a 0x100 (que seria el nuevo vector de reset),
- El siguiente vector supongamos que esta en 0x04 , hacer un salto a 0x104. Y asi para todos los vectores que tenga el microcontrolador.  A no ser que quieras usar alguno para el bootloader  El cual seria algo parecido al de reset. ( es decir pasaria por un codigo antes )

Lo que estarias haciendo es crear una tabla alternativa de vectores. Con el correspondiente penalidad que es la de tener ese salto agregado. Pero que seguro no te va a afectar.
Ventajas? Te olvidas de que si hay algun cambio en los vectores de interrupcion, no tengas que obligar al bootloader que el vector de reset sea SI o SI el bootlader, ya que este va a estar fijo, todos los vectores van a estar disponibles, si en algun momento decidis usar otra interrupcion, esta va a estar lista para usarse, sin necesidad de cambiar nada. de tu bootloader y creando la interrupcion en el programa en C como lo haces siempre.

El bootloader solo escribiria apartir de la primer pagina desocupada (en el ejemplo 0x100) y para el programa en C seria como si nada hubiese ocurrido. Ya que va a ocupar desde 0x100 en adelante.

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #98 en: 04 de Octubre de 2015, 07:32:53 »
El problema que veo es ocupar 40 bytes extra.
Imagino que los vectores del Attiny al estar implementados con saltos relativos, no van a tener problema con el desplazamiento.
Pero eso significa desplazar todo el código. Todo el código debe ser relativo, sin saltos absolutos... (por ejemplo icall Z)

Ahora mismo me estoy peleando con el tamaño. He conseguido ocupar menos de 6 páginas de 64 bytes y no sé si llegaré a las 5 páginas:

  160 bytes   XTEA Decipher
    50 bytes   UART routines
  152 bytes   Bootloader

Bootloader: (152 bytes)
   14 bytes   Init routine
   28 bytes   Rutina de entrada al bootloader (pulso de 15ms)
   18 bytes   Recepción de datos uart y llamada a decodificación xtea
   20 bytes   Comprobar la dirección de escritura en flash (cambio de vector de reset y no escribir páginas de bootloader)
   18 bytes   Mover datos a la memoria temporal de flash
     8 bytes   Si la dirección es el final de una página, grabar datos en flash
   12 bytes   Rutinas de grabación de la flash
   28 bytes   Comprobar el checksum de la Flash. Si es correcto, saltar a la rutina de usuario. (previene errores ante un corte de corriente)
     6 bytes   Saltos varios.

Total = 362 bytes

De las dos primeras hay ya poco donde rascar. El bootloader no veo cómo reducirle en 42 bytes para que ocupe una página menos.
Si no consigo reducirle, todavía tengo 22 bytes (11 instrucciones) para mejorar lo presente.



Me estoy planteando si alguna de esas rutinas las podría pasar al bootloader del PC (o del Arduino) sin peligro de corromper la memoria


Un saludo.
« Última modificación: 04 de Octubre de 2015, 07:37:14 por Picuino »

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re: Bootloader encriptado para Attiny88
« Respuesta #99 en: 04 de Octubre de 2015, 15:06:11 »
A mi consideracion:

Si, crear una tabla alternativa son 40 bytes extra (20 instrucciones si implementas todos los vectores), lamentablemente no se puede reposicionar. Pero pienso que te solucionaría la vida. Haciendo lo que dije esto no seria necesario:

 - 20 bytes   Comprobar la dirección de escritura en flash (cambio de vector de reset y no escribir páginas de bootloader)

Por que directamente comenzas de cierta pagina. Haciendo que C crea que tiene el mismo integrado pero esta ves con 6 paginas menos de memoria.
Es algo facil de modificar en el archivo de linker. y solo tendrias 20 bytes mas, tal ves gracias a eso tengas otro ahorro. Obviamente tu programa solo requiere una modificacion en el linker que seria la direccion final o el largo de la flash.

Otra ventaja que tendrias es que NUNCA pero NUNCA ante un corte de luz mientras estes programando vas a perder el bootloader, en tu caso aunque sea pequeña la ventana entre borrado de esa pagina de flash + grabacion tenes posiblidades de que ocurra. Si ocurre ¿como pensas "arreglarlo", enviandole el bootloader para que lo grabe la otra persona? ¿un bootloader desencriptado con las llaves a la vista? No serviria de nada tener un bootloader asi a mi parecer, ya que nunca deberia caer en las manos de los demas. Como vos dijiste, creer que te enfrentas al usuario mas bruto posible.

Sino como bien decis tenes que reducir 11 instrucciones. Aunque parezca poco si observas es casi uno de los items mas grandes de tu bootloader y a no ser que saques ( externalizes  o quites) uno de esos items no lo veo factible. Y conviene ocupar toda la pagina, completando las 6.

Un posible ahorro seria. Estas usando CALLs/PUSH/POP ? o simplemente son JMP ? si solo usas JMP y no usas el stack podrias evitar iniciarlo.
O si lo usas crear un stack en un punto que no moleste y sea mas facil de cargar, ejemplo que solo la parte alta del stack se cargue. en el registro del espacio I/O y no ambos, son 2 nstrucciones menos.

No se que mas decirte, imagino que lo tenes bien programado y que reducir esos 22 bytes van a doler y mucho. Asi que queda en vos si ves como achicarlo en 5 paginas si es posible o irte por las 6.

Citar
Imagino que los vectores del Attiny al estar implementados con saltos relativos, no van a tener problema con el desplazamiento.
Pero eso significa desplazar todo el código. Todo el código debe ser relativo, sin saltos absolutos... (por ejemplo icall Z)

Son todos RJMP, que si ocupas 6 paginas , son 384 bytes y la "nueva tabla" ( tabla del verdadero programa ) comenzaria desde 385, los RJMP ( ocupan 1 palabra ) y acepta valores entre -2K y 2k
El programa en C se manejara como quiera, con RJMP k , con RCALL k, ICALL Z, es decir de forma indirecta o relativa, eso por que cambies las dimensiones de las FLASH no vas a tener control o no va a cambiar.
Tu bootloader lo haces todos RJMP y RCALL ( que ocupan menos cantidad de memoria ) ya que estas dentro del posible direccionamiento de los mismos que es 2K. Y como nombre en la primer oracion, tu maximo objetivo es llegar a la pagina 7 y que esta al alcance por demasia.

Una cosa mas que estas mas al tanto vos del Attiny y tal ves estamos divagando demasiado.
La proteccion contra lectura de la FLASH ¿como funciona?,¿es un bit como en el caso de los PIC ?, ¿hay sectores no protegidos?.
Cuando necesitas grabar en la flash, ¿tenes que deshabilitar la proteccion ?

Si la ultima pregunta es correcta entonces estas ante uno de los agujeros de seguridad que buscas, cualquier persona podria darle actualizar  el Attiny y a mitad de programacion desconectarlo, luego leer y con un poco de suerte, si se estaba escribiendo o borrando en ese momento va a tener acceso a toda la FLASH incluido tu bootloader con las Keys. ya que va a estar desprotegido.
« Última modificación: 04 de Octubre de 2015, 15:23:51 por KILLERJC »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #100 en: 04 de Octubre de 2015, 16:29:17 »
Con lo que me has comentado, creo que la opción de colocar el bootloader al comienzo es mejor.
Nunca se borrará y eso es importante.

Los 20 bytes sirven para comprobar dos direcciones (la del vector de reset y la del bootloader) Si cambio al comienzo, sólo hay una dirección que comprobar y eso se reduce.

Lo de recolocar el programa con el linker, lo estudiaré. No creo que vaya a ser complicado y el linker se encargará de recolocar todas las direcciones.

He estado revisando todo y ahora el bootloader es un poco más grande . Entre otras cosas, al reducir tamaño borré el envío por UART de una señal ACK para sincronizar las dos partes.


El Attiny tiene muchas opciones de seguridad, creo que más que un PIC.
Antes de grabar el uC hay que borrarle entero (en esto creo que no hay problema)
También se puede impedir el acceso al uC por el interface serie ICSP. Sólo borrando el micro en modo paralelo puedes volver a utilizarle.

Todas estas opciones de los FUSES tengo que estudiarlas mejor para optimizarlas. La idea es que una vez que el bootloader esté instalado, se impida por completo con un fuse la conexión ICSP. Después todos esos pines se pueden utilizar como entradas/salidas.

El init del stack ya está optimizado:
Código: [Seleccionar]
   ; Setup Stack Pointer Address
   ldi    temp4, hi8(RAMEND)
   out    SPH, temp4
Da igual dónde esté SPL, siempre va a funcionar porque habrá como mínimo 256 bytes debajo.
Ahora no utilizo SRAM, así que la pila no me molesta.


Voy a hacer el cambio del bootloader a las direcciones bajas y a ver cómo queda.

Un saludo.

Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re: Bootloader encriptado para Attiny88
« Respuesta #101 en: 04 de Octubre de 2015, 16:46:21 »
Citar
Los 20 bytes sirven para comprobar dos direcciones (la del vector de reset y la del bootloader) Si cambio al comienzo, sólo hay una dirección que comprobar y eso se reduce.

No vas a tener que comprobar nada. Si lo cambias al comienzo, todo el bootloader no se va a mover. Y los vectores de tu programa en C comenzaran ocupando los 40 bytes de la pagina 7 ( si es que ocupas 6 paginas ) en el orden como si estuvieran desde la posicion 0x00.

Incluso tu bootloader podria ni siquiera necesitar un salto al final. Si no que directamente siga su camino hasta la primer instruccion del programa en C ( que es el vector de reset del mismo )

PD: Espero no estar repitiendo algo que ya lo tenes claro  :mrgreen:

Y cuando puedas fijate sobre eso de la memoria, si podes deshabilitar la lectura de la EEPROM desde el exterior sea por ICSP o como sea es algo muy poderoso, tanto que si te confundiste no podrias grabar mas el micro a traves de un programador externo :).
« Última modificación: 04 de Octubre de 2015, 16:48:53 por KILLERJC »

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #102 en: 04 de Octubre de 2015, 18:28:43 »
Tengo que comprobar que la dirección de escritura es mayor que la zona de bootloader (ahora ocupa unos 420 bytes en total) . En realidad son sólo 3 instrucciones que ocupan 6 bytes.
La dirección de escritura a la flash la envía el bootloader del PC después de los datos.

Si, es un modo muy poderoso. Lo descubrí con un uC al que ya no puedo acceder. Se quedó congelado con un programa que enciende y apaga leds.
La solución que me queda es desoldarle y poner otro.

Cuando el bootloader esté suficientemente probado, usaré ese modo. También por eso me interesa que sea tan seguro. Un fallo y no hay vuelta atrás.

Saludos.


Desconectado KILLERJC

  • Colaborador
  • DsPIC33
  • *****
  • Mensajes: 8242
Re: Bootloader encriptado para Attiny88
« Respuesta #103 en: 04 de Octubre de 2015, 19:01:42 »
A lo que voy es que no debes comprobar eso. Por que tu bootloader deberia escribir desde donde termina en adelante ( una direccion fija, y hablo de paginas obviamente ).
A no ser que quieras cargar por partes tu programa.. Pero no creo que generes 3 codigos distintos y envies 1 por uno.
Tu bootloader escriibiria desde donde termina ( una direccion fija de memoria, algunos compiladores ofrecen funciones para esto ) hasta el final de la flash ( otra direccion fija, algunos compiladores ofrecen una constante para esto ). Suponiendo que envias los datos en orden para ser escritos asi no necesitas una posicion de memoria.

Lo unico que deberia asegurarse es que el programa en C no supere el tamaño de flash que dispone y esto lo hace el linker.

Si por X causa vos no modificaste el linker y comienza en 0x00 ahi vas a tener problemas sea como sea el bootloader. Saltos realtivos no va a tener problemas pero saltos indirectos si ya que la direccion generada por el linker va a ser otra. ( a nos ser que sean todas relativas y te salves)

Otro problema que puede presentarse y su solucion, es que el bootloader se asegure con un loop infinito en la ultima posicion de memoria + encender una salida para indicar ese fallo ( 2 instrucciones ). En el caso que el programa C tenga un error y no tenga un loop infinito. Asi no entra al bootloader nuevamente, en caso de este error y solo se cumple tu modo de entrada al bootloader. Esto sirve tambien para el primer error en el caso que le erres con el linker.

Cualquier fallo nunca el bootloader se modificaria, ya que no esta dentro del rango de memoria que va a programar el mismo, el unico error que puede existir es de programacion que le erres a esa posicion de memoria inicial y lo termines reescribiendo vos.
Al no modificarse el bootloader es totalmente recuperable.

Desconectado Picuino

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 5892
    • Picuino
Re: Bootloader encriptado para Attiny88
« Respuesta #104 en: 05 de Octubre de 2015, 18:11:30 »
Comento avances.
Ya funciona el bootloader del Attiny88 en ensamblador.
Ahora estoy programando el bootloader del lado PC en Python.
Menuda diferencia. El paso de ensamblador a Python es como haber dado un paseo de varias horas hasta lo alto de una montaña y luego viajar en helicóptero. De repente en Python los avances son rapidísimos, el código sale solo, los errores se corrijen sin dificultad, es como ir volando.
Cada día me gusta más Python.

Bueno, al grano.
Esto de programar en assembler para el Attiny me ha recordado la época en la que programaba en ensamblador para el Z80 del Spectrum o aquel primer microcontrolador 8051 que programé en código máquina con un montón de interruptores para asignar las direcciones y los datos en binario.
Esto no lo vuelvo a repetir ni harto de vino. La próxima vez desarrollo todo en C y me lo pienso dos veces antes de optimizar tamaño o velocidad en ensamblador.

Lo que me queda claro es que la arquitectura AVR es muy distinta a la del PIC. Tiene un montón de registros (32 bytes) con los que operar rapidísimo (1 instrucción por ciclo de reloj) incluso en modo 16 bits (copia de registros, resta, comparación con cero, etc.)
Se pueden hacer virguerías con los registros sin necesidad de memoria SRAM (nada menos que todo un bootloader de 420 bytes con encriptado XTEA)
La pila es estupenda, puede llenar toda la SRAM con llamadas a funciones y con almacenamiento de datos. Eso hace a la arquitectura muy flexible y preparada para compiladores C. Desde luego la arquitectura de máquina me gusta mucho más que la de los PIC.
Por otro lado se echan de menos algunas instrucciones, por ejemplo: "decrementa y salta si no vale zero" que son habituales en otras arquitecturas.

Por el precio que tiene el Attiny88 (0.50€ una unidad), la potencia de su arquitectura y de sus herramientas de desarrollo, el número de pines (32), el tamaño de memoria (8kbytes flash, 512 bytes ram, 64bytes eeprom), no encuentro un sustituto igual.
La documentación del compilador/ensamblador es escasa y difícil de encontrar, pero al final he conseguido resolver todos los problemas, que no eran pocos.
Hay que tener en cuenta que el tool chain (compilador, ensamblador, linker, etc) es completamente open-source y gratuíto (GNU)

Del PIC sólo echo de menos los estupendos periféricos que tienen algunos de sus micros.
 
Un saludo.
« Última modificación: 05 de Octubre de 2015, 18:18:00 por Picuino, Razón: Modifico precio Attiny y añado enlace »


 

anything