Nano not responding after upload

0212995500229 · September 30, 2021, 5:35pm

Hy, any idea if it can be saved.
I uploaded sketch onto my nano (old bootloader) upload was done, after auto-reset nano is unresponsive, only power led is on. Nano was working fine before that last upload.
If I try to upload, IDE only says uploading and it stays like that. Rx light blinks from time to time while trying to upload and thats it.

Any ideas?

sterretje · September 30, 2021, 5:50pm

Please enable verbose output during upload under file -> preferences and disable verbose output during compilation.

Post the results after an attempted upload.

Schematic and code can be useful. For all I know you connected all IO pins together, made them all outputs and made some LOW and some HIGH; recipe for disaster

0212995500229 · September 30, 2021, 6:20pm

     System wide configuration file is "C:\Program Files (x86)\Arduino\hardware\tools\avr/etc/avrdude.conf"

     Using Port                    : COM2
     Using Programmer              : arduino
     Overriding Baud Rate          : 57600

avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x71

0212995500229 · September 30, 2021, 6:21pm

Its a long messy code, but it has worked with that code already... it uses rx, tx for serial and a4 a5 for i2c, pin10 is input for button



#include <Wire.h>
#include <DFRobot_BT401.h>


int nextButton = 1;
int nextButtonWasPressed = 0;

String nowPlaying;


long lastDebounceTime = 0; 
long debounceDelay = 200; //občutljivost gumba



int acolumn = 0;
int bcolumn = 1;
int ccolumn = 2;
int dcolumn = 3;
int ecolumn = 4;
int fcolumn = 5;
int gcolumn = 6;
int hcolumn = 7;
int icolumn = 8;




String inputText;
int inputText_len;

String smallDisplay = "33:54";
int smallDisplay_len = smallDisplay.length()+1;


constexpr size_t numColumns = 5;  //number of bytes -columns for 1 character 


//Pretty self-explenatory -here I store all my characters.
void getColumns(char c, uint8_t columns[numColumns]);

const uint8_t upperCase[][numColumns] PROGMEM = {
  {0X7E, 0X11, 0X11, 0X11, 0X7E}, // Column codes for 'A'
  {0X7F, 0X49, 0X49, 0X49, 0X36}, // Column codes for 'B'
  {0X3E, 0X41, 0X41, 0X41, 0X22}, // Column codes for 'C'
  {0X7F, 0X41, 0X41, 0X22, 0X1C}, // Column codes for 'D'
  {0X7F, 0X49, 0X49, 0X49, 0X41}, // Column codes for 'E'
  {0X7F, 0X09, 0X09, 0X09, 0X01}, // Column codes for 'F'
  {0X3E, 0X41, 0X49, 0X49, 0X7A}, // Column codes for 'G'
  {0X7F, 0X08, 0X08, 0X08, 0X7F}, // Column codes for 'H'
  {0X00, 0X41, 0X7F, 0X41, 0X00}, // Column codes for 'I'
  {0X20, 0X40, 0X41, 0X3F, 0X01}, // Column codes for 'J'
  {0X7F, 0X08, 0X14, 0X22, 0X41}, // Column codes for 'K'
  {0X7F, 0X40, 0X40, 0X40, 0X40}, // Column codes for 'L'
  {0X7F, 0X02, 0X0C, 0X02, 0X7F}, // Column codes for 'M'
  {0X7F, 0X04, 0X08, 0X10, 0X7F}, // Column codes for 'N'
  {0X3E, 0X41, 0X41, 0X41, 0X3E}, // Column codes for 'O'
  {0X7F, 0X09, 0X09, 0X09, 0X06}, // Column codes for 'P'
  {0X3E, 0X41, 0X41, 0X61, 0X3E}, // Column codes for 'Q'
  {0X7F, 0X09, 0X19, 0X29, 0X46}, // Column codes for 'R'
  {0X46, 0X49, 0X49, 0X49, 0X31}, // Column codes for 'S'
  {0X01, 0X01, 0X7F, 0X01, 0X01}, // Column codes for 'T'
  {0X3F, 0X40, 0X40, 0X40, 0X3F}, // Column codes for 'U'
  {0X07, 0X18, 0X60, 0X18, 0X07}, // Column codes for 'V'
  {0X3F, 0X40, 0X38, 0X40, 0X3F}, // Column codes for 'W'
  {0X63, 0X14, 0X08, 0X14, 0X63}, // Column codes for 'X'
  {0X07, 0X08, 0X70, 0X08, 0X07}, // Column codes for 'Y'
  {0X61, 0X51, 0X49, 0X45, 0X43} // Column codes for 'Z'
};

const uint8_t lowerCase[][numColumns] PROGMEM = {
  {0X20, 0X54, 0X54, 0X54, 0X78}, // Column codes for 'a'
  {0X7F, 0X48, 0X48, 0X48, 0X30}, // Column codes for 'b'
  {0X38, 0X44, 0X44, 0X44, 0X44}, // Column codes for 'c'
  {0X30, 0X48, 0X48, 0X48, 0X7F}, // Column codes for 'd'
  {0X38, 0X54, 0X54, 0X54, 0X58}, // Column codes for 'e'
  {0X00, 0X08, 0X7E, 0X09, 0X02}, // Column codes for 'f'
  {0X48, 0X54, 0X54, 0X54, 0X3C}, // Column codes for 'g'
  {0X7F, 0X08, 0X08, 0X08, 0X70}, // Column codes for 'h'
  {0X00, 0X00, 0X7A, 0X00, 0X00}, // Column codes for 'i'
  {0X20, 0X40, 0X40, 0X39, 0X00}, // Column codes for 'j'
  {0X00, 0X7F, 0X10, 0X28, 0X44}, // Column codes for 'k'
  {0X00, 0X41, 0X7F, 0X40, 0X00}, // Column codes for 'l'
  {0X7C, 0X04, 0X18, 0X04, 0X7C}, // Column codes for 'm'
  {0X7C, 0X08, 0X04, 0X04, 0X78}, // Column codes for 'n'
  {0X30, 0X48, 0X48, 0X30, 0X00}, // Column codes for 'o'
  {0X7C, 0X14, 0X14, 0X14, 0X08}, // Column codes for 'p'
  {0X7F, 0X04, 0X04, 0X04, 0X03}, // Column codes for 'q'
  {0X7C, 0X08, 0X04, 0X04, 0X08}, // Column codes for 'r'
  {0X48, 0X54, 0X54, 0X54, 0X24}, // Column codes for 's'
  {0X04, 0X04, 0X3F, 0X44, 0X24}, // Column codes for 't'
  {0X3C, 0X40, 0X40, 0X40, 0X3C}, // Column codes for 'u'
  {0X1C, 0X20, 0X40, 0X20, 0X1C}, // Column codes for 'v'
  {0X3C, 0X40, 0X30, 0X40, 0X3C}, // Column codes for 'w'
  {0X44, 0X28, 0X10, 0X28, 0X44}, // Column codes for 'x'
  {0X04, 0X48, 0X30, 0X18, 0X04}, // Column codes for 'y'
  {0X44, 0X64, 0X54, 0X4C, 0X44} // Column codes for 'z'
};

const uint8_t numerals[][numColumns] PROGMEM = {
  {0X3E, 0X45, 0X49, 0X51, 0X3E}, // Column codes for '0'
  {0X00, 0X42, 0X7F, 0X40, 0X00}, // Column codes for '1'
  {0X42, 0X61, 0X51, 0X49, 0X46}, // Column codes for '2'
  {0X22, 0X41, 0X49, 0X49, 0X36}, // Column codes for '3'
  {0X18, 0X14, 0X12, 0X7F, 0X10}, // Column codes for '4'
  {0X27, 0X45, 0X45, 0X45, 0X39}, // Column codes for '5'
  {0X3E, 0X49, 0X49, 0X49, 0X30}, // Column codes for '6'
  {0X01, 0X71, 0X09, 0X05, 0X03}, // Column codes for '7'
  {0X36, 0X49, 0X49, 0X49, 0X36}, // Column codes for '8'
  {0X06, 0X49, 0X49, 0X49, 0X3E} // Column codes for '9'
};

const uint8_t symbolsa[][numColumns] PROGMEM = {
  {0X00, 0X00, 0X5F, 0X00, 0X00}, // Column codes for '!'
  {0X00, 0X03, 0X00, 0X03, 0X00}, // Column codes for '"'
  {0X14, 0X7F, 0X14, 0X7F, 0X14}, // Column codes for '#'
  {0X24, 0X2A, 0X7F, 0X2A, 0X12}, // Column codes for '$'
  {0X23, 0X13, 0X08, 0X64, 0X62}, // Column codes for '%'
  {0X36, 0X49, 0X55, 0X22, 0X50}, // Column codes for '&'
  {0X04, 0X02, 0X02, 0X01, 0X00}, // Column codes for '''
  {0X00, 0X1C, 0X22, 0X41, 0X00}, // Column codes for '('
  {0X00, 0X41, 0X22, 0X1C, 0X00}, // Column codes for ')'
  {0X14, 0X08, 0X3E, 0X08, 0X14}, // Column codes for '*'
  {0X08, 0X08, 0X3E, 0X08, 0X08}, // Column codes for '+'
  {0X00, 0X00, 0X50, 0X30, 0X00}, // Column codes for ','
  {0X08, 0X08, 0X08, 0X08, 0X08}, // Column codes for '-'
  {0X00, 0X60, 0X60, 0X00, 0X00}, // Column codes for '.'
  {0X20, 0X10, 0X08, 0X04, 0X02} // Column codes for '/'
};

const uint8_t symbolsb[][numColumns] PROGMEM = {
  {0X00, 0X7F, 0X41, 0X41, 0X00}, // Column codes for '['
  {0X02, 0X04, 0X08, 0X10, 0X20}, // Column codes for '\'
  {0X00, 0X41, 0X41, 0X7F, 0X00}, // Column codes for ']'
  {0X04, 0X02, 0X01, 0X02, 0X04}, // Column codes for '^'
  {0X40, 0X40, 0X40, 0X40, 0X40}, // Column codes for '_'
  {0X00, 0X01, 0X02, 0X04, 0X00} // Column codes for '`'

};

const uint8_t symbolsc[][numColumns] PROGMEM = {
  {0X08, 0X36, 0X41, 0X41, 0X00}, // Column codes for '{'
  {0X00, 0X00, 0X7F, 0X00, 0X00}, // Column codes for '|'
  {0X00, 0X41, 0X41, 0X36, 0X08}, // Column codes for '}'
  {0X01, 0X02, 0X01, 0X20, 0X00}, // Column codes for '~'
};

const uint8_t equalSymbol [numColumns] PROGMEM = {0x14, 0x14, 0x14, 0x14, 0x14};

const uint8_t afnaSymbol [numColumns] PROGMEM = {0x32, 0x49, 0x71, 0x41, 0x3E};

const uint8_t space[numColumns] PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00};

const uint8_t unknown[numColumns] PROGMEM = {0x00, 0x00, 0x00, 0x00, 0x00};



DFRobot_BT401 bt;

void setup() {
 pinMode(10, INPUT_PULLUP); //next button
  Serial.begin(115200);

  /*Delay 2s for the BT401 to start*/
  delay(2000);
  while(!bt.begin(Serial)){
    delay(1000);
  }
  bt.setVOl(30);
  bt.switchFunction(bt.eUDisk);
  delay(100);

  bt.setPlayMode(bt.eDeviceCycle);
}

void loop() {

  ////////////////////////////////////////////////////////////
nextButton = digitalRead(10);

 if (nextButton != nextButtonWasPressed) {
    lastDebounceTime = millis();
  }
 if ((millis() - lastDebounceTime) > debounceDelay) {
if (nextButton == 0 && nextButtonWasPressed == 0)
{
bt.next();

nextButtonWasPressed = 1;


}
 }

if(nextButtonWasPressed == 1)
{


int acolumn = 0;
int bcolumn = 1;
int ccolumn = 2;
int dcolumn = 3;
int ecolumn = 4;
int fcolumn = 5;
int gcolumn = 6;
int hcolumn = 7;
int icolumn = 8;


}

if(nextButton == 1)
{
nextButtonWasPressed = 0;
}


//String inputText = (bt.getFilename()); 
nowPlaying = (bt.getFilename());
inputText = nowPlaying;
inputText_len = inputText.length() + 1;
  

      
  //bt.playControl(bt.ePlay);
///////////////////////////////////////////////////////////////////////////////////////////////////////
 char inputText_array[inputText_len];
  inputText.toCharArray(inputText_array, inputText_len);
  //Serial only for troubleshooting -I can remove it when it works.

  uint8_t ahr[numColumns];
  getColumns(inputText[acolumn], ahr);  //This would store all 5 bytes (columns)of letter A in "xxx"


uint8_t bhr[numColumns];
getColumns(inputText[bcolumn], bhr);  //This would store all 5 bytes (columns)of letter A in "xxx"


  uint8_t chr[numColumns];
  getColumns(inputText[ccolumn], chr);  //This would store all 5 bytes (columns)of letter A in "xxx"


  uint8_t dhr[numColumns];
  getColumns(inputText[dcolumn], dhr);  //This would store all 5 bytes (columns)of letter A in "xxx"

  uint8_t ehr[numColumns];
  getColumns(inputText[ecolumn], ehr);  //This would store all 5 bytes (columns)of letter A in "xxx"


  uint8_t fhr[numColumns];
  getColumns(inputText[fcolumn], fhr);  //This would store all 5 bytes (columns)of letter A in "xxx"


  uint8_t ghr[numColumns];
  getColumns(inputText[gcolumn], ghr);  //This would store all 5 bytes (columns)of letter A in "xxx"


  uint8_t hhr[numColumns];
  getColumns(inputText[hcolumn], hhr);  //This would store all 5 bytes (columns)of letter A in "xxx"


  uint8_t ihr[numColumns];
  getColumns(inputText[icolumn], ihr);  //This would store all 5 bytes (columns)of letter A in "xxx"

 
 char smallDisplay_array[smallDisplay_len];
  smallDisplay.toCharArray(smallDisplay_array, smallDisplay_len);

  uint8_t smla[numColumns];
  getColumns(smallDisplay[0], smla);  //This would store all 5 bytes (columns)of letter A in "xxx"
  uint8_t smlb[numColumns];
  getColumns(smallDisplay[1], smlb);  //This would store all 5 bytes (columns)of letter A in "xxx"
  uint8_t smlc[numColumns];
  getColumns(smallDisplay[2], smlc);  //This would store all 5 bytes (columns)of letter A in "xxx"
  uint8_t smld[numColumns];
  getColumns(smallDisplay[3], smld);  //This would store all 5 bytes (columns)of letter A in "xxx"
  uint8_t smle[numColumns];
  getColumns(smallDisplay[4], smle);  //This would store all 5 bytes (columns)of letter A in "xxx"



  
     //COMMANDS TO SET UP THE DISPLAY
  Wire.begin(); // join i2c bus
    Wire.beginTransmission(0x3C); // transmit to device
  Wire.write(0x55);             // set_mode  -normal video, mixed mode, MUX 1:8
  Wire.endTransmission();     // stop transmitting

      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x3e); // RAM access
  Wire.endTransmission();     // stop transmitting

      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x7c); //set start bank 0
  Wire.endTransmission();     // stop transmitting

      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x62); //device select
  Wire.endTransmission();     // stop transmitting


//WRITING TO DISPLAY STARTS HERE

      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x0F); //load x address

Wire.write(bhr[3]);             // DATA column 10
Wire.write(bhr[2]);             // DATA column 9
Wire.write(bhr[1]);             // DATA column 8
Wire.write(bhr[0]);             // DATA column 7
Wire.write(0x00);             // DATA column 6
Wire.write(ahr[4]);             // DATA column 5
Wire.write(ahr[3]);             // DATA column 4
Wire.write(ahr[2]);             // DATA column 3
Wire.write(ahr[1]);             // DATA column 2
Wire.write(ahr[0]);             // DATA column 1

  Wire.endTransmission();     // stop transmitting


      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x05); //load x address
      
Wire.write(dhr[1]);             // DATA column 20
Wire.write(dhr[0]);             // DATA column 19
Wire.write(0x00);             // DATA column 18
Wire.write(chr[4]);             // DATA column 17
Wire.write(chr[3]);             // DATA column 16
Wire.write(chr[2]);             // DATA column 15
Wire.write(chr[1]);             // DATA column 14
Wire.write(chr[0]);             // DATA column 13
Wire.write(0x00);             // DATA column 12
Wire.write(bhr[4]);             // DATA column 11

  Wire.endTransmission();     // stop transmitting


      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x00); //load x address

Wire.write(0x00);             // DATA MISSING COLUMN -BLANK
Wire.write(0x00);             // DATA column 24
Wire.write(dhr[4]);             // DATA column 23
Wire.write(dhr[3]);             // DATA column 22
Wire.write(dhr[2]);             // DATA column 21
  
  Wire.endTransmission();     // stop transmitting


        Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x61); //device select   
  Wire.endTransmission();     // stop transmitting


Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x1f); //load x address

Wire.write(fhr[3]);             // DATA column 34
Wire.write(fhr[2]);             // DATA column 33
Wire.write(fhr[1]);             // DATA column 32
Wire.write(fhr[0]);             // DATA column 31
Wire.write(0x00);             // DATA column 30
Wire.write(ehr[4]);             // DATA column 39
Wire.write(ehr[3]);             // DATA column 28
Wire.write(ehr[2]);             // DATA column 27
Wire.write(ehr[1]);             // DATA column 26
Wire.write(ehr[0]);             // DATA column 25
  
  Wire.endTransmission();     // stop transmitting


      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x61); //device select   
  Wire.endTransmission();     // stop transmitting


Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x14); //load x address

Wire.write(hhr[2]);             // DATA column 45
Wire.write(hhr[1]);             // DATA column 44
Wire.write(hhr[0]);             // DATA column 43
Wire.write(0x00);             // DATA column 42
Wire.write(ghr[4]);             // DATA column 41
Wire.write(ghr[3]);             // DATA column 40
Wire.write(ghr[2]);             // DATA column 39
Wire.write(ghr[1]);             // DATA column 38
Wire.write(ghr[0]);             // DATA column 37
Wire.write(0x00);             // DATA column 36
Wire.write(fhr[4]);             // DATA column 35

  Wire.endTransmission();     // stop transmitting


      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x61); //device select 
    Wire.endTransmission();     // stop transmitting



Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x0A); //load x address
      
Wire.write(0x00);             // DATA column 55
Wire.write(0x00);             // DATA column 54
Wire.write(ihr[4]);             // DATA column 53
Wire.write(ihr[3]);             // DATA column 52
Wire.write(ihr[2]);             // DATA column 51
Wire.write(ihr[1]);             // DATA column 50
Wire.write(ihr[0]);             // DATA column 49
Wire.write(0x00);             // DATA column 48
Wire.write(hhr[4]);             // DATA column 47
Wire.write(hhr[3]);             // DATA column 46
  
  Wire.endTransmission();     // stop transmitting



//MALI DISPLAY -URA

      //ČETRTA
      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x60); //device select 
    Wire.endTransmission();     // stop transmitting
Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x0A); //load x address

Wire.write(0x00);
Wire.write(smle[4]);             // DATA column 50
Wire.write(smle[3]);             // DATA column 49
Wire.write(smle[2]);             // DATA column 48
Wire.write(smle[1]);             // DATA column 47
Wire.write(smle[0]);             // DATA column 46

  
  Wire.endTransmission();     // stop transmitting

      //TRETJA
      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x60); //device select 
    Wire.endTransmission();     // stop transmitting
Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x10); //load x address


Wire.write(smld[4]);             // DATA column 50
Wire.write(smld[3]);             // DATA column 49
Wire.write(smld[2]);             // DATA column 48
Wire.write(smld[1]);             // DATA column 47
Wire.write(smld[0]);             // DATA column 50

  
  Wire.endTransmission();     // stop transmitting


      //DVOPIČJE ALI ČRTA
      Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x60); //device select 
    Wire.endTransmission();     // stop transmitting
Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x15); //load x address
      
Wire.write(0x22);             // 0x22 je dvopičje, 0x7F je črta

  Wire.endTransmission();     // stop transmitting

        //DRUGA
        Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x60); //device select 
    Wire.endTransmission();     // stop transmitting
Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x16); //load x address


Wire.write(smlb[4]);             // DATA column 50
Wire.write(smlb[3]);             // DATA column 49
Wire.write(smlb[2]);             // DATA column 48
Wire.write(smlb[1]);             // DATA column 47
Wire.write(smlb[0]);             // DATA column 50

  
  Wire.endTransmission();     // stop transmitting

      //PRVA
        Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x60); //device select 
    Wire.endTransmission();     // stop transmitting
Wire.beginTransmission(0x3C); // transmit to device
      Wire.write(0x1c); //load x address


Wire.write(smla[4]);             // DATA column 50
Wire.write(smla[3]);             // DATA column 49
Wire.write(smla[2]);             // DATA column 48
Wire.write(smla[1]);             // DATA column 47
Wire.write(smla[0]);             // DATA column 50

  
  Wire.endTransmission();     // stop 

  
if(inputText_len > 9 && icolumn < inputText_len){
acolumn = (acolumn + 1);
bcolumn = (bcolumn + 1);
ccolumn = (ccolumn + 1);
dcolumn = (dcolumn + 1);
ecolumn = (ecolumn + 1);
fcolumn = (fcolumn + 1);
gcolumn = (gcolumn + 1);
hcolumn = (hcolumn + 1);
icolumn = (icolumn + 1);
delay(350);
}else{
acolumn = 0;
bcolumn = 1;
ccolumn = 2;
dcolumn = 3;
ecolumn = 4;
fcolumn = 5;
gcolumn = 6;
hcolumn = 7;
icolumn = 8;
    }


}
 //I don`t get this part fully.
void getColumns(char c, uint8_t columns[numColumns]) {
  switch (c) {
    case 'A'...'Z':
      memcpy_P(&columns[0], &upperCase[c - 'A'][0], numColumns); //I think that this "A" changes depending if it`s case A or B or C ... something like if it`s "A" do that, if it`s "B" do that...
      break;

    case 'a'...'z':
      memcpy_P(&columns[0], &lowerCase[c - 'a'][0], numColumns);
      break;

    case '0'...'9':
      memcpy_P(&columns[0], &numerals[c - '0'][0], numColumns);
      break;

    case ' ':
      memcpy_P(&columns[0], &space[0], numColumns);
      break;

    case '!'...'/':
      memcpy_P(&columns[0], &symbolsa[c - '!'][0], numColumns);
      break;

    case '['...'`':
      memcpy_P(&columns[0], &symbolsb[c - '['][0], numColumns);
      break;

    case '{'...'~':
      memcpy_P(&columns[0], &symbolsc[c - '{'][0], numColumns);
      break;


    case '=':
      memcpy_P(&columns[0], &equalSymbol[0], numColumns);
      break;

    case '@':
      memcpy_P(&columns[0], &afnaSymbol[0], numColumns);
      break;


      
    default:
      memcpy_P(&columns[0], &unknown[0], numColumns);
      break;
  }

}

c-richmond · September 30, 2021, 7:22pm

I had that with an uno and changing the usb port fixed it

sterretje · September 30, 2021, 7:28pm

Looks like you have something connected to the RX and TX pins That will interfere with uploads.

You will have to disconnect whatever is on RX/TX, do the upload and next reconnect.

0212995500229 · October 1, 2021, 9:43am

I always disconnect tx rx before upload, I had disconnected everything and its the same.
Will buy new one.

system · March 30, 2022, 9:44am

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.

Topic		Replies	Views
Upload to Nano board fails: "stk500_recv(): programmer is not responding" Uploading	11	574	March 23, 2025
Errors in uploading in arduino nano type c development board Uploading	12	86	December 15, 2025
Arduino not uploading sketches anymore but still runs previous code help! Classic Nano	8	120	August 24, 2025
Kann einen Nano nicht neu programieren Deutsch	14	163	January 1, 2026
Unable to upload to UNO or Nano Uploading	31	484	September 19, 2025

Nano not responding after upload

Related topics