¿Cómo se comunica AVRDUDE con el programador?

Estoy tratando de entender exactamente cómo AVRDUDE se comunica con el programador AVR, por ejemplo, USBtiny o el propio Arduino como programador, para enviar el firmware al microcontrolador.

Como motivación a mi pregunta, suponga que quiero construir un programador USB en el sistema para un microcontrolador AVR desde cero. Entonces, usando otro microcontrolador, construyo un ISP que puede cargar código al AVR.

Ahora, ¿qué pasa si quiero usar AVRDUDE para enviar a mi ISP un código para cargar en mi microcontrolador? ¿Qué tipo de protocolo utilizará AVRDUDE para enviar el código a través de USB, para poder leerlo correctamente y generar el SPI correcto para programar el AVR? ¿Cómo las personas que crearon USBtiny, por ejemplo, supieron (o especificaron) el protocolo que usaría avrdude para enviar los datos a USBtiny, para poder interpretarlos correctamente?

¡Cualquier ayuda es apreciada!

¡Gracias!

Avrdude es un programa de código abierto. Comenzaría buscando en su repositorio de origen. Si tienes suerte, habrá documentación de protocolo. Si no, usa la fuente, Luke.
En mi experiencia, no muy bien.

Respuestas (3)

Esto pertenece más a stackoverflow y está más relacionado con los controladores de dispositivos. Sin embargo,

Hoy en día, los controladores de dispositivos USB están escritos en ring3 en lugar de ring0. En inglés son drivers en modo usuario. Cualquier sistema operativo moderno expone la funcionalidad de nivel de interfaz de la pila USB al modo de usuario por API. Y hay librerías como libusb, winusb para acceder a ellas en modo usuario, así que en teoría solo necesitas estudiar cómo usar una librería como libusb.

Entonces, el tipo AVR, con suficientes permisos, puede acceder a sus puntos finales y escribir y leer desde ellos. Así es como funciona.

Y de la fuente avrdude, este es el archivo que define cómo comunicarme con mi programador (lo siento, estoy usando usbasp). http://svn.savannah.nongnu.org/viewvc/trunk/avrdude/usbasp.c?root=avrdude&view=markup

Puede ver que está usando libusb si está en Linux.

void usbasp_initpgm(PROGRAMMER * pgm)
{
  strcpy(pgm->type, "usbasp");

  /*
   * mandatory functions
   */

  pgm->initialize     = usbasp_initialize;
  pgm->display        = usbasp_display;
  pgm->enable         = usbasp_enable;
  pgm->disable        = usbasp_disable;
  pgm->program_enable = usbasp_spi_program_enable;
  pgm->chip_erase     = usbasp_spi_chip_erase;
  pgm->cmd            = usbasp_spi_cmd;
  pgm->open           = usbasp_open;
  pgm->close          = usbasp_close;
  pgm->read_byte      = avr_read_byte_default;
  pgm->write_byte     = avr_write_byte_default;

  /*
   * optional functions
   */

  pgm->paged_write    = usbasp_spi_paged_write;
  pgm->paged_load     = usbasp_spi_paged_load;
  pgm->setup          = usbasp_setup;
  pgm->teardown       = usbasp_teardown;
  pgm->set_sck_period = usbasp_spi_set_sck_period;

}

Puede ver que cada programador compatible con avrdude debe admitir esas funciones, por lo que puede comprender esta abstracción y cómo el archivo usbasp.c las convierte en específicas del programador. Te animo a que leas el código fuente de tu programador. Buena suerte.

FYI: para su programador usbtiny, la fuente está aquí :

Gracias por la respuesta. Entonces, dado que tendría que implementar el controlador del dispositivo USB y también todo el conjunto de funciones que mencionó que necesita avrdude, en realidad es posible crear su propio "protocolo" para comunicarse entre avrdude y el programador, ¿verdad? El único requisito es implementar funciones avrdude
Hay algunos cambios en el núcleo para agregar su programador a la lista de programadores existente. Y también a makefiles para incluir su archivo de controlador. Pero estoy bastante seguro de que lo descubrirás fácilmente. Lee la fuente siente la fuerza.

Debe leer AVRDude junto con la documentación de Atmel sobre AVRISP II

AVRDude no programa la MCU AVR, envía comandos/paquetes/bloques al programador a través de un canal serie en el caso de Arduino como ejemplo.
El programador (en Arduino, el cargador de arranque actúa como un AVRISP II) administra la programación Flash (auto) del dispositivo (el ATMega328 en Arduino) mientras deja intacto el cargador de arranque.

No está claro a partir de su pregunta exactamente lo que quiere hacer. Sin embargo, podrías:

  1. Cree su propio cargador de arranque para una MCU AVR y envíele datos en serie a través de uart o USB/serial
  2. Cree y programe su propio programador SPI o HV (para que actúe como un AVR ISP II) basado en un MCU AVR y envíe datos en serie (o USB/serie) a ese. Luego, los programadores podrían usar ICSP/SPI para programar su dispositivo final.

Para obtener buenas ideas sobre qué hacer para su proyecto, investigue el esquema Arduino Nano (esta es una implementación basada en un gestor de arranque con datos USB/serial) o el esquema Arduino UNO que usa un AtMega16u2 AVR separado como programador (el ATMega16U2 emula un AVRISP II, USB/serie.Programa el dispositivo final como serie a bootloader)

(el ATMega16U2 emula un AVRISP II, USB/serie. Programa el dispositivo final como serie para cargador de arranque)

Si ese es el caso de que el atmega18U2 actúa como un programador en sí mismo y no como un convertidor de USB a serie, ¿por qué cada vez que el gestor de arranque de 328p está dañado necesitamos volver a cargarlo usando encabezados ICSP? Por lo tanto, el 18U2 debe actuar como un convertidor de USB a serie.

¿Cómo se comunica AVRDUDE con el programador?
RespuestasAquíPolítica de privacidad1y, 0v