program stops working when you print a specific variable

hey, I’m having a weird problem with this code and the arduino mega 2560. In the code below in the part of the loop after the calculation of x and y, if I print in the serial the values ​​of x and y the program does not work anymore, I gave a researched and I did not find anything, I also tried to change the type of variable of x and y but I did not have any success. Every help is welcome. thank you

#include <Stepper.h>

// Isso é um COMENTÁRIO, e não afeta o código de programação.
// Na parte superior da programação fica a INTRODUÇÃO para o funcionamento do código,
// aqui as variáveis são declaradas (palavras coloridas) e são definidas para fazer algo.

// "stepsPerRevolution" ou, no português, Passos por Revolução, são quantos passos necessários
// para completar uma volta, e cada modelo de motor, tem um passo necessário diferente:
const int stepsPerRevolution = 500;

// "pininfra" é a variável do SENSOR de LUMINOSIDADE, e "A0" é a porta conectada:
int pininfra = A0;

// "pwm" e "mcaneta" são as variáveis da CANETA, e "5" e "4" são as portas conectadas:
int pwm = 5;
int mcaneta = 4;

// "seri" é a variável necessária para o funcionamento de certos SERIAIS:
int seri;

// Placa Branca (Rodas1): Portas: int1,2,3,4 = Fios Amarelos, 5v-gnd e 12v-5v = Fio Lilás e Roxo:
Stepper Rodas1(stepsPerRevolution, 28, 30, 29, 31);

Stepper Rodas2(stepsPerRevolution, 20, 22, 21, 23);

// Placa Verde (Trilhos): Portas: int1,2,3,4 = Fios Verdes, 5v-gnd e 12v-5v = Fios Marrom e Cinza:
Stepper Trilhos(stepsPerRevolution, 36, 38, 37, 39);



//protoboard, na esquerda, superior, para os fios da caneta alcançarem

//placa branca, rodas 2, int1-20, int2-21, int3-22, int4-23, fios vermelhos,12v-5v-vermelho, 5v-gnd-azul

//placa branca, rodas 1, int1-28, int2-29, int3-30, int4-31, fios amarelos,12v-5v-vermelho, 5v-gnd-azul

//placa verde, trilhos, int1-36 verde-branco, int2-37 verde-branco, int3-38 verde-marrom escuro, int4-39 verde-marrom claro, 12v-5v roxo-cinza, 5v-gnd azul-azul

//placa bluetooth, 5v-vcc-vermelho, gnd-gnd-azul, txd-rx0-azul , rxd-tx0-verde

//porta H, dois fios do moto da caneta (preto-preto e vermelho-preto) na entrada do motor A, vcc-5v-laranja, gnd-gnd-azul

//sensor Infra Vermelho, 5v vermelho-laranja, gnd preto-azul-amarelo, saida digital amarelo-amarelo-amarelo



// "void setup" é a configuração básica do código de programação:
void setup()
{
  // Configura a VELOCIDADE INICIAL dos MOTORES:
  // 50= Melhor Velocidade.
  // 45 = Velocidade para chegar a folha no sensor de luminosidade.
  Rodas1.setSpeed(55);
  Rodas2.setSpeed(55);
  Trilhos.setSpeed(55);

  // Configura o SENSOR de LUMINOSIDADE:
  pinMode(pininfra, INPUT);

  // Configura a CANETA:
  pinMode(pwm, OUTPUT);
  pinMode(mcaneta, OUTPUT);
  pinMode(A7, INPUT);

  // "Serial" ajuda na comunicação da PROGRAMAÇÃO e do Arduino, "9600" é a velocidade comunicativa:
  Serial.begin(9600);
}



int a = 0;

int cor1[1], ang[2], comp[1], cor1R[1], ang1R, comp1R;

float x, y, propor = 0;


// Aqui começa o DESENVOLVIMENTO da Programação
// "void loop" é utilizado para INICIAR VARIÁVEIS e o uso de BIBLIOTECAS:
void loop()
{


  cor1R[0] = corcer();
  cor1R[1] = corcer();

  Serial.print("codenadas do 1 ponto ");
  Serial.print(cor1R[0]);
  Serial.print(" , ");
  Serial.println(cor1R[1]);


  ang1R = angcer();

  Serial.print("Angulo do 1 ponto: ");
  Serial.println(ang1R);

  comp1R = corcer();

  Serial.print("distacia a ser percorrida do 1 ponto: ");
  Serial.println(comp1R);



  x = cos(ang1R) * comp1R;
  y = sin(ang1R) * comp1R;

 // Serial.println(x);           HERE
  //Serial.println(y);           AND HERE
  
  if (x < y) {

    propor = y / x;

    FolhaDentro();
    for (int i = 0; i < y * 360; i++) {

      Trilhos.step(-1);
      Rodas1.step(propor);
      Rodas2.step(-propor);

    }

  } else {

    propor = x / y;
  }


}


// Faz a FOLHA entrar na impressora e chegar no SENSOR de LUMINOSIDADE, pedindo o comando pelo APP:
void FolhaDentro() {
  Rodas1.setSpeed(55);
  Rodas2.setSpeed(55);
  Trilhos.setSpeed(55);
  Caneta(255, LOW);
  delay(2000);
  Caneta(0, LOW);
  delay(1000);
  for (int i = 0; analogRead(A0) > 750 ; i++) {
    //0Serial.println(analogRead(A0));
    Rodas1.step(+1);
    Rodas2.step(-1);
  }

  for (int i = 0; analogRead(A7) < 1000; i++) {
    //Serial.println(analogRead(A7));
    Trilhos.step(-1);
  }

}

void baixaCaneta() {

  Caneta(255, LOW);
  delay(4000);
  Caneta(0, HIGH);
  delay(3000);
  Caneta(0, LOW);

}


int corcer() {

  for (int i = 0; i < 2; i) {// lendo os primeiros numeros da 1 cordenada
    a = carnu(Serial.read());
    if (a != -1 and a != -2 ) {
      cor1[i] = a;
      i++;
    }
  }
  return ajecor(cor1);
}

int angcer() {

  for (int i = 0; i < 3; i) {// lendo os primeiros numeros da 1 angulo
    a = carnu(Serial.read());
    if (a != -1 and a != -2 ) {
      /*if(a == -3){
        for(j = i; j<3; j++){// fazendo uma melhor leitura do ang, se der tempo eu faco
          ang[j] = 0;
          }
        }*/
      ang[i] = a;
      i++;
    }
  }
  return ajeang(ang);
}

int ajecor(int a[1]) {

  int b = 0;

  b = a[0] * 10 + a[1];

  return b;
}

int ajeang(int a[2]) {

  int b = 0;

  b = a[0] * 100 + a[1] * 10 + a[2];

  return b;
}

int carnu(int a) {

  if (a != -1) {
    if (a == 48)
    {
      a = 0;
      return a;
    }
    if (a == 49)
    {
      a = 1;
      return a;
    }
    if (a == 50)
    {
      a = 2;
      return a;
    }
    if (a == 51)
    {
      a = 3;
      return a;
    }
    if (a == 52)
    {
      a = 4;
      return a;
    }
    if (a == 53)
    {
      a = 5;
      return a;
    }
    if (a == 54)
    {
      a = 6;
      return a;
    }
    if (a == 55)
    {
      a = 7;
      return a;
    }
    if (a == 56)
    {
      a = 8;
      return a;
    }
    if (a == 57)
    {
      a = 9;
      return a;
    }
    if (a == 47)
    {
      a = -3;
      return a;
    }
    return -2;
  }
  return a;//nesse caso -1
}


// Faz a FOLHA sair da impressora quando ela termina um desenho:
void FolhaFora() {
  Rodas1.setSpeed(55);
  Rodas2.setSpeed(55);
  Trilhos.setSpeed(55);
  Caneta(255, LOW);
  delay(2000);
  Caneta(0, LOW);
  delay(1000);
  Rodas1.step(-5000);
  Rodas2.step(+5000);
}

// Controla a CANETA para SUBIR, DESCER e PARAR:
void Caneta(int a, bool b) {
  analogWrite(pwm, a);
  digitalWrite(mcaneta, b);
  // Modelo Exemplo: Caneta(0, HIGH);.
  // 0 e LOW = Parado.
  // 0 e HIGH = Velocidade Máxima = Baixo.
  // 255 e LOW = Velocidade Máxima = Cima.
}

// Desenha um QUADRADO:
void Quadrado() {
  delay(1000);
  FolhaDentro();
  Rodas1.setSpeed(50);
  Rodas2.setSpeed(50);
  Trilhos.setSpeed(50);
  Caneta(0, HIGH);
  delay(4000);
  Caneta(0, LOW);
  delay(1000);
  Trilhos.step(+2000);
  for (int i = 0; i <= 2000; i++) {
    Rodas1.step(+1);
    Rodas2.step(-1);
  }
  Trilhos.step(-2000);
  for (int i = 0; i <= 2000; i++) {
    Rodas1.step(-1);
    Rodas2.step(+1);
  }
  delay(1000);
  FolhaFora();
  delay(1000);
}

// Desenha um TRIÂNGULO:
void Triangulo() {
  delay(1000);
  FolhaDentro();
  Rodas1.setSpeed(55);
  Trilhos.setSpeed(55);
  Rodas1.step(+2000);
  Rodas2.step(-2000);
  Caneta(0, HIGH);
  delay(4000);
  Caneta(200, HIGH);
  //delay(1000);
  for (int i = 0; i <= 2000; i++) {
    Rodas1.step(-1);
    Trilhos.step(+1);
  }
  for (int i = 0; i <= 2000; i++) {
    Rodas1.step(+1);
    Trilhos.step(+1);
  }
  Trilhos.step(-2500);
  delay(1000);
  Caneta(255, LOW);
  delay(2000);
  Caneta(0, LOW);
  delay(1000);
  FolhaFora();
  delay(1000);
}

// Desenha a LETRA A:
void LetraA() {
  delay(1000);
  FolhaDentro();
  Rodas1.setSpeed(50);
  Rodas2.setSpeed(50);
  Trilhos.setSpeed(50);
  Caneta(255, LOW);
  delay(2000);
  Caneta(0, LOW);
  delay(1000);
  for (int i = 0; i <= 1000; i++) {
    Rodas1.step(-1);
    Rodas2.step(+1);
    Trilhos.step(+1);
  }
  for (int i = 0; i <= 1000; i++) {
    Rodas1.step(+1);
    Rodas2.step(-1);
    Trilhos.step(+1);
  }
  for (int i = 0; i <= 500; i++) {
    Rodas1.step(-1);
    Rodas2.step(+1);
    Trilhos.step(-1);
  }
  Trilhos.step(-1000);
  delay(1000);
  Caneta(0, HIGH);
  delay(2000);
  Caneta(0, LOW);
  delay(1000);
  FolhaFora();
  delay(1000);
}

You have defined cor1R to have a single element which would be cor1R[0] yet you write to cor1R[1]. This leads to undefined and even surprising behavior. There is at least one other place where you do something similar. Why are your arrays so tiny? An array sized to 0 or 1 should be taken as a warning. There are occasional reasons for doing this but rarely and by experienced programmers only.

Yup. You're writing past the end of an array, corrupting other parts of memory. Once you do that, all bets are off for logical program behavior.

thanks a lot, now it worked. but why does the arduino have trouble with such tiny arrays?

why does the arduino have trouble with such tiny arrays?

It doesn't.

You were illegally writing into forbidden memory locations.

vaj4088:
There are occasional reasons for doing this but rarely and by experienced programmers only.

Can you give one or more examples?

On the Arduino, addressing is the same speed whether handled by pointer or by array subscript. On a processor that I used many years ago, this was not true and it was sometimes faster (but more painful) to allocate memory and then address the memory by a subscript where the array was declared to have a size of 0 or 1.

Alas, I no longer have the code and it did not belong to me anyway. This may have been for a TI or Analog Devices DSP with a poor compiler.

Thanks

sterretje:
Can you give one or more examples?

Aliasing…

struct PIDData
{
  float P;
  float I;
  float D;
  float Setpoint;
};

union PIDRaw
{
  uint8_t raw[1];
  PIDData data;
};

void setup( void )
{
  Serial.begin( 250000 );
}

void loop( void )
{
  static PIDRaw raw;
  static int i1 = 0;

  while ( (i1 < sizeof(raw.data)) && Serial.available() )
  {
    raw.raw[i1] = Serial.read();
    ++i1;
  }
}

But a short array is only needed by those too lazy to type “sizeof(PIDData)”.

Thanks for that example; will toy with it a bit.