Using optiboot without Arduino IDE

[SbsinKs]

Hello,

I would like to use the Optiboot bootloader on an ATTiny841 and make an update via the serial communication from another processor. A digital output of the other processor is used to control the reset Pin of the Tiny so there is no problem to enter the bootloader. Unfortunatly I have found no documentation of the protocol which must be used to update via serial line. Before I start with try and error, I would like to ask the Optiboot experts if there is a documentation about the protocol or/and an example how to update without Arduino IDE.

Thanks

Sebastian

[hecko]

If you are asking about the avrdude protocol then its arduino

../avrdude-v7.0-windows-x64/avrdude -C ../avrdude-v7.0-windows-x64/avrdude.conf -c arduino -P COM9 -b 57600 -U flash:w:../GccApplication1/Release/H1AT.hex:i

If you want to flash using another MCU then probably looking at avrdude implementation of arduino programmer is a way to go.
Sorry for not being more helpful.

[SbsinKs]

Hi,

thanks for the reply. The problem is, thas I have another processor which is connected to the atmel board. I cannot run the avrdude there because it is also an embedded system.

[hecko]

Yeah, I understand now, I have updated my reply.

[hecko]

I would believe though, that you could find an arduino demo code to turn arduino into standalone programmer for other arduinos. I am curious about this myself so please report back if you come across any such information.

[WestfW]

See https://github.com/Optiboot/optiboot/wiki/HowOptibootWorks
"Arduino" is a subset of STK500v1, which is described/defined in Atmel App Note AVR061.

[SbsinKs]

Nice work. This bootloader was easy to use. Here is an example of how to write firmware without Arduino IDE from another processor

/**************************************************************************
*
*  Redistribution and use in source and binary forms, with or without 
*  modification, are permitted provided that the following conditions 
*  are met:
*  
*  1. Redistributions of source code must retain the above copyright 
*     notice, this list of conditions and the following disclaimer.
*
*  2. Redistributions in binary form must reproduce the above copyright
*     notice, this list of conditions and the following disclaimer in the 
*     documentation and/or other materials provided with the distribution.
*
*  3. Neither the name of the author nor the names of its contributors may 
*     be used to endorse or promote products derived from this software 
*     without specific prior written permission.
*
*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 
*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 
*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 
*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
*  THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 
*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
*  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
*  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 
*  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF 
*  THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
*  SUCH DAMAGE.
**************************************************************************/

/* STK500v1 definitions */
#define Resp_STK_OK       0x10
#define Resp_STK_FAILED   0x11
#define Resp_STK_UNKNOWN  0x12
#define Resp_STK_NODEVICE 0x13
#define Resp_STK_INSYNC   0x14
#define Resp_STK_NOSYNC   0x15

#define STK_LOAD_ADDRESS    0x55 /* 'U' Note: 16bit word address, 128kb flash max. */
#define STK_PROG_PAGE       0x64 /* 'd' Flash only                                 */
#define STK_READ_PAGE       0x74 /* 't' Flash only                                 */
#define STK_READ_SIGN       0x75 /* 'u' Reads compiled-in signature.               */
#define STK_LEAVE_PROGMODE  0x51 /* 'Q' Starts application code via WDT reset.     */

#define STK_MEM_EEPROM 0x45 /* 'E' Program EEPROM */
#define STK_MEM_FLASH  0x46 /* 'F' Program flash area */
#define STK_CMD_EOP    0x20 /* ' ' End of command */
#define STK_CMD_SYNC   0x30 /* '0' sync command */

/* OPG return values */
#define OPG_RESULT uint8_t
#define OPG_OK          0
#define OPG_ERR_SYNC    1
#define OPG_ERR_VERIFY  2
#define OPG_ERR_TIMEOUT 3

/*Bytecut macros*/
#define HIGHBYTE(_u16) ( (uint8_t)( ( ( (uint16_t)_u16) >> 8 ) & 0x00FF ) )
#define LOWBYTE(_u16)  ( (uint8_t)( ( ( (uint16_t)_u16)      ) & 0x00FF ) )

MY_COM_PORT COMPort;

/* Open com port */
void opg_init (void);

/* reboot module and check for bootloader */
OPG_RESULT opg_start (void);

/* Send to optiboot(stk500v1 subset) via serial */
OPG_RESULT opg_prog (uint16_t u16Adr, uint8_t * data,uint16_t u16Size);

/* Close com port and reboot module */
void opg_end  (void);


/*=======================================================================*/
/*  Definition of all local Procedures                                   */
/*=======================================================================*/


/*************************************************************************/
/*  readAnswer                                                           */
/*                                                                       */
/*  read answer from opg request and check for valid sync and ok         */
/*                                                                       */
/*  In    : bufferpointer to read into, size of buffer                   */
/*  Out   : none                                                         */
/*  Return: none                                                         */
/*************************************************************************/
OPG_RESULT readAnswer(uint8_t * u8Buf, uint16_t u16BufSz)
{
   uint8_t u8Return;

   /*fill buffer*/
   for(uint16_t u16Cnt=0; u16Cnt < u16BufSz; u16Cnt++)
   {
      /*get character with timout*/
      if(MY_COM_OK == COMReceiveCharWait(&COMPort,&u8Return,50 /*ms*/ ))
      {
         u8Buf[u16Cnt] = u8Return;
      }
      else
      {
         /*No character received in time*/
         return OPG_ERR_TIMEOUT;
      }
   }
   /*Check Head and tail for sync and OK*/
   if(u8Buf[0] == Resp_STK_INSYNC && u8Buf[u16BufSz - 1] == Resp_STK_OK)
   {
      return OPG_OK;
   }
   else
   {
      return OPG_ERR_SYNC;
   }
}

/*=======================================================================*/
/*  Definition of all global Procedures                                   */
/*=======================================================================*/

/*************************************************************************/
/*  opg_init                                                             */
/*                                                                       */
/*  Initialize optiprog module                                           */
/*                                                                       */
/*  In    : none                                                         */
/*  Out   : none                                                         */
/*  Return: none                                                         */
/*************************************************************************/
void opg_init (void)
{
   COMOpen(&COMPort, COM1 , 57600, 8, 'N', 1);
}


/*************************************************************************/
/*  opg_start                                                            */
/*                                                                       */
/*  reboot module and check for bootloader                               */
/*                                                                       */
/*  In    : none                                                         */
/*  Out   : OPG result                                                   */
/*  Return: none                                                         */
/*************************************************************************/
OPG_RESULT opg_start (void)
{
   uint8_t u8Result[2] = {0x00,0x00};
   uint8_t u8Attempts  = 0;

   /*reset module*/
   digitalWrite(15,LOW);
   wait(100);   
   digitalWrite(15,HIGH);
   wait(10);

   /*Run up to ten times to wait for sync*/
   while((u8Result[0] != Resp_STK_INSYNC && u8Result[1] != Resp_STK_OK) && u8Attempts < 10)
   { 
      /*send sync signal*/
      COMSendChar(&COMPort,STK_CMD_SYNC);
      COMSendChar(&COMPort,STK_CMD_EOP);
      readAnswer(u8Result,sizeof(u8Result));
      u8Attempts++;
   }

   /*Check if 10 tries exceeded*/
   if(u8Attempts < 10)
   {
      return OPG_OK;
   }
   else
   {
      return OPG_ERR_SYNC;
   }
}


/*************************************************************************/
/* opg_prog                                                              */
/*                                                                       */
/* Send to optiboot(stk500v1 subset) via serial                          */
/*                                                                       */
/*  In    : 16 bit asdress to write to, chunk to write, chunk size       */
/*  Out   : OPG result                                                   */
/*  Return: none                                                         */
/*************************************************************************/
OPG_RESULT opg_prog (uint16_t u16Adr, uint8_t* data,uint16_t u16Size)
{
   uint8_t u8Result[2];
   uint8_t u8Verified[u16Size + 2];
   OPG_RESULT retVal;

   /* set adress to write */
   COMSendChar(&COMPort,STK_LOAD_ADDRESS);
   COMSendChar(&COMPort,LOWBYTE(u16Adr));
   COMSendChar(&COMPort,HIGHBYTE(u16Adr));
   COMSendChar(&COMPort,STK_CMD_EOP);

   /* read result */
   retVal = readAnswer(u8Result,sizeof(u8Result));
   if(retVal != OPG_OK)
   {
      return retVal;
   }

   /* Programm page */
   COMSendChar(&COMPort,STK_PROG_PAGE);
   COMSendChar(&COMPort,HIGHBYTE(u16Size));
   COMSendChar(&COMPort,LOWBYTE(u16Size));
   COMSendChar(&COMPort,STK_MEM_FLASH);
   COMSendBlock(&COMPort, data, u16Size);
   COMSendChar(&COMPort,STK_CMD_EOP);

   /* read result */
   retVal = readAnswer(u8Result,sizeof(u8Result));
   if(retVal != OPG_OK)
   {
      return retVal;
   }

   /* set adress to read */
   COMSendChar(&COMPort,STK_LOAD_ADDRESS);
   COMSendChar(&COMPort,LOWBYTE(u16Adr));
   COMSendChar(&COMPort,HIGHBYTE(u16Adr));
   COMSendChar(&COMPort,STK_CMD_EOP);

   /* read result */
   retVal = readAnswer(u8Result,sizeof(u8Result));
   if(retVal != OPG_OK)
   {
      return retVal;
   }

   /* read page */
   COMSendChar(&COMPort,STK_READ_PAGE);
   COMSendChar(&COMPort,HIGHBYTE(u16Size));
   COMSendChar(&COMPort,LOWBYTE(u16Size));
   COMSendChar(&COMPort,STK_MEM_FLASH);
   COMSendChar(&COMPort,STK_CMD_EOP);

   /* read result */
   retVal = readAnswer(u8Verified,sizeof(u8Verified));

   if(retVal != OPG_OK)
   {
      return retVal;
   }
   /* verify page */
   else if(0 == memcmp ( data, &u8Verified[1], u16Size ) ) 
   {
      return OPG_OK;
   }
   else
   {
      return OPG_ERR_VERIFY;
   }
}

void opg_end  (void)
{
   /*call the program*/
   COMSendChar(&COMPort,STK_LEAVE_PROGMODE);
   wait(100);
   COMClose(&COMPort);
}

[dsongdev]

How are you formatting your program to be sent over UART to the target controller using the above functions?

I am testing using a basic blink arduino sketch:
`const byte LED_PIN = 38;
void setup() {
pinMode(LED_PIN, OUTPUT);
}

void loop() {
digitalWrite(LED_PIN, HIGH);
delay(250);
digitalWrite(LED_PIN, LOW);
delay(250);
}`

Exported as hex and converted to binary c array:
unsigned char firmware[] = { 0x4f, 0xc0, 0x00, 0x00, 0x5d, 0xc0, 0x00, 0x00, 0x5b, 0xc0, 0x00, 0x00, 0x59, 0xc0, 0x00, 0x00, 0x57, 0xc0, 0x00, 0x00, 0x55, 0xc0, 0x00, 0x00, [...] 0x11, 0x24, 0x91, 0x1d, 0xb2, 0x9f, 0x70, 0x0d, 0x81, 0x1d, 0x11, 0x24, 0x91, 0x1d, 0x08, 0x95, 0xf8, 0x94, 0xff, 0xcf }; unsigned int firmware_len = 764;

Are you sending your program as a binary array? Thanks much.

[SbsinKs]

Hi, yes that is correct. I used the binry export from arduino and converted it to a bin file ./avr-objcopy -I ihex -O binary inFile.ino.hex outFile.bin. It can be sent via UART afterwards.

Please be aware to use the right COM Speed. I had to use 115200 in my precompiled bootloader.