programmer.cpp

用于开发Atmel的AVR系列单片机的GCC集成开发环境

   buf += 128;
   i += 127;
  }
  Progress->Position = i;
  Application->ProcessMessages ();
 }
 for (i = chip.flashsize;i > 0;i--)
 {
  if (*(flashbuffer + i - 1) != 0xff) break;
 }
 if (ProgrammerType == PGM_PAR) StopPGM ();
 else STK500->DisablePGM ();
 Progress->Position = 0;
 if (i & 0x01) i++;
 if (PrgOpt->shortenhex) flashbufsize = i;
 else flashbufsize = chip.flashsize;
 StatusLabel->Caption = "Ready";
 temp.printf ("%X", (flashbufsize / 2));
 FlashFileSize->Caption = temp;
 DisableUIF (false);
}
//---------------------------------------------------------------------------

void __fastcall TPgmDlg::EditFlButtonClick(TObject *Sender)
{
 AnsiString temp;

 memstream->Clear ();
 memstream->Write (flashbuffer, flashbufsize);
 HexEdit->maxsize = chip.flashsize;
 HexEdit->Editor->LoadFromStream (memstream);
 HexEdit->Position = poScreenCenter;
 if (HexEdit->ShowModal () == mrOk)
 {
  if (HexEdit->Editor->DataSize > chip.flashsize) flashbufsize = chip.flashsize;
  else flashbufsize = HexEdit->Editor->DataSize;
  HexEdit->Editor->ReadBuffer (flashbuffer, 0, flashbufsize);
  temp.printf ("%X", BSizeToWSize (flashbufsize));
  FlashFileSize->Caption = temp;
 }
}
//---------------------------------------------------------------------------

void __fastcall TPgmDlg::EditEEButtonClick(TObject *Sender)
{
 AnsiString temp;

 memstream->Clear ();
 memstream->Write (eeprombuffer, eeprombufsize);
 HexEdit->maxsize = chip.eepromsize;
 HexEdit->Editor->LoadFromStream (memstream);
 HexEdit->Position = poScreenCenter;
 if (HexEdit->ShowModal () == mrOk)
 {
  if (HexEdit->Editor->DataSize > chip.eepromsize) eeprombufsize = chip.eepromsize;
  else eeprombufsize = HexEdit->Editor->DataSize;
  HexEdit->Editor->ReadBuffer (eeprombuffer, 0, eeprombufsize);
  temp.printf ("%X", eeprombufsize);
  EEFileSize->Caption = temp;
 }
}
//---------------------------------------------------------------------------
bool __fastcall TPgmDlg::WriteFlashByte (void)
{
 int i;
 unsigned char *buf;
 DWORD lasttick, acttick;

 StatusLabel->Caption = "Programming Flash ...";
 buf = flashbuffer;
 Progress->Max = flashbufsize;
 Progress->Position = 0;
 Application->ProcessMessages ();

 for (i = 0;i < flashbufsize;i += 2)
 {
  if (*buf != 0xff) // Don't write FF's (Empty Flash is already FF)
  {
   if (!ParPgm->WriteByte (*(buf++), i / 2, false)) // Write Low Byte
   {
    ErrorMessage ("Error during Write Byte");
    return false;
   }
   DelayMS (chip.WD_Flash);
  }
  else buf++;
  if (*buf != 0xff)
  {
   if (!ParPgm->WriteByte (*(buf++), i / 2, true)) // Write High Byte
   {
    ErrorMessage ("Error during Write Byte");
    return false;
   }
   DelayMS (chip.WD_Flash);
  }
  else buf++;

  Progress->Position = i;
  Application->ProcessMessages ();
 }
 return true;
}
//---------------------------------------------------------------------------
bool __fastcall TPgmDlg::ChipErase (void)
{
 int waittime;

 StatusLabel->Caption = "Erasing Chip ...";
 if (ProgrammerType == PGM_PAR)
 {
  if (!ParPgm->ChipErase ())
  {
   ErrorMessage ("Can't initiate Chip Erase");
   return false;
  }
 }
 else
 {
  if (!STK500->ChipErase ())
  {
   ErrorMessage ("Can't initiate Chip Erase");
   return false;
  }
 }
 waittime = 10;
 Progress->Max = 10;
 while (waittime)
 {
  Progress->Position = 10 - waittime;
  waittime--;
  Application->ProcessMessages ();
  DelayMS (100);
 }
 if (ProgrammerType == PGM_PAR)
 {
  StopPGM ();
  DelayMS (100);
  if (!StartPGM ())
  {
   ErrorMessage ("Can't restart Communication");
   return false;
  }
 }
 else
 {
  STK500->DisablePGM ();
  DelayMS (100);
  if (!STK500->EnablePGM (&chip))
  {
   ErrorMessage ("Can't restart Communication");
   return false;
  }
 }
 return true;
}
//---------------------------------------------------------------------------
bool __fastcall TPgmDlg::VerifyFlash (void)
{
 unsigned char *buf, buf2[128];
 int i, d;
 AnsiString temp;

 buf = flashbuffer;
 StatusLabel->Caption = "Verifying Flash ...";
 Progress->Max = flashbufsize / 2;
 if (ProgrammerType == PGM_STK500) STK500->LoadAddress (0);
 for (i = 0;i < (flashbufsize / 2);i++)
 {
  if (ProgrammerType == PGM_PAR)
  {
   ParPgm->ReadFlash (i, buf2);
   if (*buf2 != *buf || *(buf2 + 1) != *(buf + 1))
   {
    temp.printf ("Verify Error at: %Xh", i);
    ErrorMessage (temp);
    return false;
   }
   buf += 2;
  }
  else
  {
   STK500->ReadPage (buf2, 128, 'F');
   for (d = 0;d < 128;d++)
   {
    if (*(buf + d) != buf2[d])
    {
     temp.printf ("Verify Error at: %Xh", i + d);
     ErrorMessage (temp);
     return false;
    }
   }
   buf += 128;
   i += 63;
  }
  Progress->Position = i;
  Application->ProcessMessages ();
 }
 return true;
}
//---------------------------------------------------------------------------
bool __fastcall TPgmDlg::BlankCheck (void)
{
 int i, d;
 unsigned char buf[128];

 StatusLabel->Caption = "Blank Checking ...";
 Progress->Max = chip.flashsize / 2;
 Progress->Position = 0;
 Application->ProcessMessages ();
 if (ProgrammerType == PGM_STK500) STK500->LoadAddress (0);
 for (i = 0;i < (chip.flashsize / 2);i++)
 {
  if (ProgrammerType == PGM_PAR)
  {
   ParPgm->ReadFlash (i, buf);
   if (*buf != 0xff || *(buf + 1) != 0xff)
   {
    ErrorMessage ("Flash is not Empty");
    return false;
   }
  }
  else
  {
   STK500->ReadPage (buf, 128, 'F');
   for (d = 0;d < 128;d++)
   {
    if (buf[d] != 0xff)
    {
     ErrorMessage ("Flash is not Empty");
     return false;
    }
   }
   i += 63;
  }
  Progress->Position = i;
  Application->ProcessMessages ();
 }
 return true;
}
//---------------------------------------------------------------------------
bool __fastcall TPgmDlg::WriteEEProm (void)
{
 int i;

 StatusLabel->Caption = "Programming EEPROM ...";
 Progress->Max = eeprombufsize;
 if (ProgrammerType == PGM_STK500) STK500->LoadAddress (0);
 for (i = 0;i < eeprombufsize;i++)
 {
  if (ProgrammerType == PGM_PAR)
  {
   ParPgm->WriteEEPROM (i, *(eeprombuffer + i));
  }
  else
  {
   if (!STK500->WritePage (eeprombuffer + i, 32, 'E'))
   {
    ErrorMessage ("Error during Write Page");
    return false;
   }
   i += 31;
  }
  Progress->Position = i;
  Application->ProcessMessages ();
  if (ProgrammerType == PGM_PAR) DelayMS (chip.WD_EEPROM);
 }
 return true;
}
//---------------------------------------------------------------------------
bool __fastcall TPgmDlg::VerifyEEProm (void)
{
 int i, d;
 unsigned char ch, buf[32];
 AnsiString temp;

 StatusLabel->Caption = "Verifying EEPROM ...";
 Progress->Max = eeprombufsize;
 if (ProgrammerType == PGM_STK500) STK500->LoadAddress (0);
 for (i = 0;i < eeprombufsize;i++)
 {
  if (ProgrammerType == PGM_PAR)
  {
   ParPgm->ReadEEPROM (i, &ch);
   if (ch != *(eeprombuffer + i))
   {
    temp.printf ("Verify Error at: %Xh", i);
    ErrorMessage (temp);
    return false;
   }
  }
  else
  {
   if (!STK500->ReadPage (buf, 32, 'E'))
   {
    ErrorMessage ("Error during Page Read");
    return false;
   }
   for (d = 0;d < 32;d++)
   {
    if (buf[d] != *(eeprombuffer + i + d) && (i + d) < eeprombufsize)
    {
     temp.printf ("Verify Error at: %Xh", i + d);
     ErrorMessage (temp);
     return false;
    }
   }
   i += 31;
  }
  Progress->Position = i;
  Application->ProcessMessages ();
 }
 return true;
}
//---------------------------------------------------------------------------
void __fastcall TPgmDlg::StartButtonClick(TObject *Sender)
{
 bool result = true;
 unsigned char sig[3];
 AnsiString temp;

 if (ProgFlBox->Checked && flashbufsize == 0)
 {
  ErrorMessage ("No Data available\nto write into Flash");
  return;
 }
 if (ProgEEBox->Checked && eeprombufsize == 0)
 {
  ErrorMessage ("No Data available\nto write into EEProm");
  return;
 }
 if (ProgrammerType == PGM_PAR)
 {
  if (!StartPGM ())
  {
   ErrorMessage ("Can't start Communication");
   StopPGM ();
   return;
  }
 }
 else
 {
  if (!STK500->CheckPresence ())
  {
   ErrorMessage ("STK500 not available");
   return;
  }
  if (!STK500->EnablePGM (&chip))
  {
   ErrorMessage ("Can't start Communication");
   STK500->DisablePGM ();
   return;
  }
 }
 DisableUIF (true);
 if (SignBox->Checked)
 {
  if (ProgrammerType == PGM_PAR) ParPgm->GetSignature (sig);
  else STK500->GetSignature (sig);
  temp.printf ("%2.2X : %2.2X : %2.2X", (int)sig[0], (int)sig[1], (int)sig[2]);
  Signature->Caption = temp;
  if (sig[0] != 0x1E)
  {
   ErrorMessage ("No Atmel Device (Signature Check)");
   if (ProgrammerType == PGM_PAR) StopPGM ();
   else STK500->DisablePGM ();
   DisableUIF (false);
   return;
  }
  if (sig[1] != ((chip.signature >> 8) & 0xff) ||
      sig[2] != (chip.signature & 0xff))
  {
   temp.printf ("Chip Signature doesn't match\nTarget : 1E:%2.2X:%2.2X",
          (int)((chip.signature >> 8) & 0xff), (int)(chip.signature & 0xff));
   ErrorMessage (temp);
   if (ProgrammerType == PGM_PAR) StopPGM ();
   else STK500->DisablePGM ();
   DisableUIF (false);
   return;
  }
 }
 if (EraseBox->Checked) result = ChipErase ();
 DelayMS (100);
 if (BlankBox->Checked && result) result = BlankCheck ();
 DelayMS (100); // Prevent problems on fast Computers
 if (ProgFlBox->Checked && result)
 {
  if (ProgrammerType == PGM_PAR)
  {
   if (chip.paged) result = WriteFlashPage ();
   else result = WriteFlashByte ();
  }
  else result = WriteFlashPage ();
 }
 DelayMS (100);
 if (ProgEEBox->Checked && result) result = WriteEEProm ();
 DelayMS (100);
 if (VerifyFlBox->Checked && result) result = VerifyFlash ();
 DelayMS (100);
 if (VerifyEEBox->Checked && result) result = VerifyEEProm ();
 if (ProgrammerType == PGM_PAR) StopPGM ();
 else STK500->DisablePGM ();
 StatusLabel->Caption = "Ready";
 Progress->Position = 0;
 DisableUIF (false);
 if (result)
 {
  Application->MessageBox ("Successfully done", "Info", MB_OK | MB_ICONINFORMATION);
 }
}
//---------------------------------------------------------------------------
void __fastcall TPgmDlg::TrackBar1Change(TObject *Sender)
{
 switch (TrackBar1->Position)
 {
  case 0: if (ProgrammerType == PGM_PAR) ParPgm->SetSCKLen (1);
          else STK500->SetSCKLen (2);
          break;
  case 1: if (ProgrammerType == PGM_PAR) ParPgm->SetSCKLen (2);
          else STK500->SetSCKLen (4);
          break;