Arduino.ru

полный лог давай

C:\Users\1\Desktop\_12345\_12345.ino: In function 'calculateLegIK':

_12345:449: error: unable to find a register to spill in class 'POINTER_REGS'

 }

 ^

_12345:449: error: this is the insn:

(insn 48 47 50 3 (set (reg:SF 66 [ D.2227 ])

        (mem:SF (post_inc:HI (reg:HI 16 r16 [orig:152 ivtmp.96 ] [152])) [12 MEM[base: _136, offset: 0B]+0 S4 A8])) C:\Users\1\Desktop\_12345\_12345.ino:433 100 {*movsf}

     (expr_list:REG_INC (reg:HI 16 r16 [orig:152 ivtmp.96 ] [152])

        (nil)))

C:\Users\1\Desktop\_12345\_12345.ino:449: confused by earlier errors, bailing out

lto-wrapper: C:\Program Files\Arduino\hardware\tools\avr/bin/avr-gcc returned 1 exit status

c:/program files/arduino/hardware/tools/avr/bin/../lib/gcc/avr/4.9.2/../../../../avr/bin/ld.exe: lto-wrapper failed

collect2.exe: error: ld returned 1 exit status

exit status 1
unable to find a register to spill in class 'POINTER_REGS'

collect2.exe: error: ld returned 1 exit status

версия виндовс какая?

Windows 7 Начальная 32-разрядная

у народа на XP обычно collect2.exe ошибки выдавал.

у меня на семёрке пару раз выскакивало, но после перезагрузки ИДЕ пропадало.

подожди, может кто что посоветует.

Если бы Вы дали полный код, чтобы я мог его покомпилировать у себя, я бы попытался Вам помочь. Если будете давать, заодно давайте ссылки на используемые бибилиотеки.

Библиотеки: Speedtrig - https://github.com/Anon-Penguin/SpeedTrig; TimerOner11 - https://code.google.com/archive/p/arduino-timerone/downloads; PS2X_lib - https://github.com/madsci1016/Arduino-PS2X;

Полный код:

#include <math.h>
#include <SpeedTrig.h>
#include <TimerOne.h>
#include <PS2X_lib.h>

#define MATH_PI 3.141592

#define COXA_LENGTH 28
#define FEMUR_LENGTH 84
#define TIBIA_LENGTH 122

#define RF_BODY_COXA_OFFSET_X 40.5
#define RF_BODY_COXA_OFFSET_Y 76

#define RM_BODY_COXA_OFFSET_X 65.5
#define RM_BODY_COXA_OFFSET_Y 0

#define RR_BODY_COXA_OFFSET_X 40.5
#define RR_BODY_COXA_OFFSET_Y -76

#define LF_BODY_COXA_OFFSET_X -40.5
#define LF_BODY_COXA_OFFSET_Y 76

#define LM_BODY_COXA_OFFSET_X -65.5
#define LM_BODY_COXA_OFFSET_Y 0

#define LR_BODY_COXA_OFFSET_X -40.5
#define LR_BODY_COXA_OFFSET_Y -76

#define RF_C_SERVO_OFFSET -100
#define RF_F_SERVO_OFFSET -60
#define RF_T_SERVO_OFFSET 0

#define RM_C_SERVO_OFFSET 80
#define RM_F_SERVO_OFFSET -80
#define RM_T_SERVO_OFFSET 80

#define RR_C_SERVO_OFFSET 80
#define RR_F_SERVO_OFFSET 40
#define RR_T_SERVO_OFFSET -20

#define LF_C_SERVO_OFFSET 60
#define LF_F_SERVO_OFFSET 40
#define LF_T_SERVO_OFFSET -20

#define LM_C_SERVO_OFFSET 60
#define LM_F_SERVO_OFFSET 0
#define LM_T_SERVO_OFFSET -20

#define LR_C_SERVO_OFFSET 0
#define LR_F_SERVO_OFFSET 0
#define LR_T_SERVO_OFFSET -20

#define C_SIT_STEP 0
#define F_SIT_STEP 500
#define T_SIT_STEP 500

#define C_STAND_STEP 0
#define F_STAND_STEP 250
#define T_STAND_STEP 250

#define WALK 0
#define BODY 1
#define SINGLE_LEG 2

#define BTN_START 1
#define BTN_SELECT 2
#define BTN_UP 3
#define BTN_DOWN 4

PS2X ps2x;

const uint8_t rightFrontLegNum[] = {2, 3, 4};
const uint8_t rightMidLegNum[] = {6, 7, 9};
const uint8_t rightRearLegNum[] = {11, 12, 13};

const uint8_t leftFrontLegNum[] = {18, 19, 20};
const uint8_t leftMidLegNum[] = {22, 23, 25};
const uint8_t leftRearLegNum[] = {27, 28, 29};

const long interval = 100;

unsigned int servoTime = 100;

uint8_t mode = 0;
uint8_t newState = 0;
uint8_t currentState = 0;

//bool positionsEqual = false;

//bool stateChanged = false;

unsigned long previousMillis = 0;

uint8_t posX;
uint8_t posY;
uint8_t posZ;

uint8_t rotX;
uint8_t rotY;
uint8_t rotZ;

float bodyCoxaOffsetX[6];
float bodyCoxaOffsetY[6];

int initFeetPosX[6];
int initFeetPosY[6];
int initFeetPosZ[6];

float totalX[6];
float totalY[6];
float totalZ[6];

float sinrotX;
float cosrotX;

float sinrotY;
float cosrotY;

float sinrotZ;
float cosrotZ;

float bodyIKX[6];
float bodyIKY[6];
float bodyIKZ[6];

float newPosX[6];
float newPosY[6];
float newPosZ[6];

float transformX[6];
float transformY[6];
float transformZ[6];

float coxaFeetDist[6];

float IKSW[6];

float IKA1[6];
float IKA2[6];

float tAngle[6];

float tibiaAngle[6];
float femurAngle[6];
float coxaAngle[6];

unsigned int coxaMidPositions[6];
unsigned int femurMidPositions[6];
unsigned int tibiaMidPositions[6];

unsigned int coxaSittingPositions[6];
unsigned int femurSittingPositions[6];
unsigned int tibiaSittingPositions[6];

unsigned int coxaStandingPositions[6];
unsigned int femurStandingPositions[6];
unsigned int tibiaStandingPositions[6];

unsigned int coxaServoOffsets[6];
unsigned int femurServoOffsets[6];
unsigned int tibiaServoOffsets[6];

unsigned int coxaMicroseconds[6];
unsigned int femurMicroseconds[6];
unsigned int tibiaMicroseconds[6];

void initPos() {
  posX = 0;
  posY = 0;
  posZ = 0;

  rotX = 0;
  rotY = 0;
  rotZ = 0;
}

void setServoOffsetsArrays() {
  coxaServoOffsets[0] = RF_C_SERVO_OFFSET;
  coxaServoOffsets[1] = RM_C_SERVO_OFFSET;
  coxaServoOffsets[2] = RR_C_SERVO_OFFSET;
  coxaServoOffsets[3] = LF_C_SERVO_OFFSET;
  coxaServoOffsets[4] = LM_C_SERVO_OFFSET;
  coxaServoOffsets[5] = LR_C_SERVO_OFFSET;

  femurServoOffsets[0] = RF_F_SERVO_OFFSET;
  femurServoOffsets[1] = RM_F_SERVO_OFFSET;
  femurServoOffsets[2] = RR_F_SERVO_OFFSET;
  femurServoOffsets[3] = LF_F_SERVO_OFFSET;
  femurServoOffsets[4] = LM_F_SERVO_OFFSET;
  femurServoOffsets[5] = LR_F_SERVO_OFFSET;

  tibiaServoOffsets[0] = RF_T_SERVO_OFFSET;
  tibiaServoOffsets[1] = RM_T_SERVO_OFFSET;
  tibiaServoOffsets[2] = RR_T_SERVO_OFFSET;
  tibiaServoOffsets[3] = LF_T_SERVO_OFFSET;
  tibiaServoOffsets[4] = LM_T_SERVO_OFFSET;
  tibiaServoOffsets[5] = LR_T_SERVO_OFFSET;
}
void calculateMidPositions() {
  coxaMidPositions[0] = 1500 + RF_C_SERVO_OFFSET;
  coxaMidPositions[1] = 1500 + RM_C_SERVO_OFFSET;
  coxaMidPositions[2] = 1500 + RR_C_SERVO_OFFSET;
  coxaMidPositions[3] = 1500 + LF_C_SERVO_OFFSET;
  coxaMidPositions[4] = 1500 + LM_C_SERVO_OFFSET;
  coxaMidPositions[5] = 1500 + LR_C_SERVO_OFFSET;

  femurMidPositions[0] = 1500 + RF_F_SERVO_OFFSET;
  femurMidPositions[1] = 1500 + RM_F_SERVO_OFFSET;
  femurMidPositions[2] = 1500 + RR_F_SERVO_OFFSET;
  femurMidPositions[3] = 1500 + LF_F_SERVO_OFFSET;
  femurMidPositions[4] = 1500 + LM_F_SERVO_OFFSET;
  femurMidPositions[5] = 1500 + LR_F_SERVO_OFFSET;

  tibiaMidPositions[0] = 1500 + RF_T_SERVO_OFFSET;
  tibiaMidPositions[1] = 1500 + RM_T_SERVO_OFFSET;
  tibiaMidPositions[2] = 1500 + RR_T_SERVO_OFFSET;
  tibiaMidPositions[3] = 1500 + LF_T_SERVO_OFFSET;
  tibiaMidPositions[4] = 1500 + LM_T_SERVO_OFFSET;
  tibiaMidPositions[5] = 1500 + LR_T_SERVO_OFFSET;
}

void calculateSittingPositions() {
  coxaSittingPositions[0] = coxaMidPositions[0] + C_SIT_STEP;
  coxaSittingPositions[1] = coxaMidPositions[1];
  coxaSittingPositions[2] = coxaMidPositions[2] - C_SIT_STEP;
  coxaSittingPositions[3] = coxaMidPositions[2] - C_SIT_STEP;
  coxaSittingPositions[4] = coxaMidPositions[2];
  coxaSittingPositions[5] = coxaMidPositions[2] + C_SIT_STEP;

  femurSittingPositions[0] = femurMidPositions[0] - F_SIT_STEP;
  femurSittingPositions[1] = femurMidPositions[1] - F_SIT_STEP;
  femurSittingPositions[2] = femurMidPositions[2] - F_SIT_STEP;
  femurSittingPositions[3] = femurMidPositions[3] + F_SIT_STEP;
  femurSittingPositions[4] = femurMidPositions[4] + F_SIT_STEP;
  femurSittingPositions[5] = femurMidPositions[5] + F_SIT_STEP;

  tibiaSittingPositions[0] = tibiaMidPositions[0] - T_SIT_STEP;
  tibiaSittingPositions[1] = tibiaMidPositions[1] - T_SIT_STEP;
  tibiaSittingPositions[2] = tibiaMidPositions[2] - T_SIT_STEP;
  tibiaSittingPositions[3] = tibiaMidPositions[3] + T_SIT_STEP;
  tibiaSittingPositions[4] = tibiaMidPositions[4] + T_SIT_STEP;
  tibiaSittingPositions[5] = tibiaMidPositions[5] + T_SIT_STEP;
}

void calculateStandingPositions() {
  coxaStandingPositions[0] = coxaMidPositions[0] + C_STAND_STEP;
  coxaStandingPositions[1] = coxaMidPositions[1];
  coxaStandingPositions[2] = coxaMidPositions[2] - C_STAND_STEP;
  coxaStandingPositions[3] = coxaMidPositions[2] - C_STAND_STEP;
  coxaStandingPositions[4] = coxaMidPositions[2];
  coxaStandingPositions[5] = coxaMidPositions[2] + C_STAND_STEP;

  femurStandingPositions[0] = femurMidPositions[0] - F_STAND_STEP;
  femurStandingPositions[1] = femurMidPositions[1] - F_STAND_STEP;
  femurStandingPositions[2] = femurMidPositions[2] - F_STAND_STEP;
  femurStandingPositions[3] = femurMidPositions[3] + F_STAND_STEP;
  femurStandingPositions[4] = femurMidPositions[4] + F_STAND_STEP;
  femurStandingPositions[5] = femurMidPositions[5] + F_STAND_STEP;

  tibiaStandingPositions[0] = tibiaMidPositions[0] - T_STAND_STEP;
  tibiaStandingPositions[1] = tibiaMidPositions[1] - T_STAND_STEP;
  tibiaStandingPositions[2] = tibiaMidPositions[2] - T_STAND_STEP;
  tibiaStandingPositions[3] = tibiaMidPositions[3] + T_STAND_STEP;
  tibiaStandingPositions[4] = tibiaMidPositions[4] + T_STAND_STEP;
  tibiaStandingPositions[5] = tibiaMidPositions[5] + T_STAND_STEP;
}

void setMidPositions() {
  for (uint8_t i = 0; i < 6; i++) {
    coxaMicroseconds[i] = coxaMidPositions[i];
    femurMicroseconds[i] = femurMidPositions[i];
    tibiaMicroseconds[i] = tibiaMidPositions[i];
  }
}

void setSittingPositions() {
  for (uint8_t i = 0; i < 6; i++) {
    coxaMicroseconds[i] = coxaSittingPositions[i];
    femurMicroseconds[i] = femurSittingPositions[i];
    tibiaMicroseconds[i] = tibiaSittingPositions[i];
  }
}

void setStandingPositions() {
  for (uint8_t i = 0; i < 6; i++) {
    coxaMicroseconds[i] = coxaStandingPositions[i];
    femurMicroseconds[i] = femurStandingPositions[i];
    tibiaMicroseconds[i] = tibiaStandingPositions[i];
  }
}

void setBodyOffsets() {
  bodyCoxaOffsetX[0] = RF_BODY_COXA_OFFSET_X;
  bodyCoxaOffsetX[1] = RM_BODY_COXA_OFFSET_X;
  bodyCoxaOffsetX[2] = RR_BODY_COXA_OFFSET_X;
  bodyCoxaOffsetX[3] = LF_BODY_COXA_OFFSET_X;
  bodyCoxaOffsetX[4] = LM_BODY_COXA_OFFSET_X;
  bodyCoxaOffsetX[5] = LR_BODY_COXA_OFFSET_X;

  bodyCoxaOffsetY[0] = RF_BODY_COXA_OFFSET_Y;
  bodyCoxaOffsetY[1] = RM_BODY_COXA_OFFSET_Y;
  bodyCoxaOffsetY[2] = RR_BODY_COXA_OFFSET_Y;
  bodyCoxaOffsetY[3] = LF_BODY_COXA_OFFSET_Y;
  bodyCoxaOffsetY[4] = LM_BODY_COXA_OFFSET_Y;
  bodyCoxaOffsetY[5] = LR_BODY_COXA_OFFSET_Y;
}

void calculateFeetPositions() {
  float tmp = round(cos(60 * MATH_PI / 180) * (COXA_LENGTH + FEMUR_LENGTH));

  initFeetPosX[0] = tmp;
  initFeetPosX[1] = COXA_LENGTH + FEMUR_LENGTH;
  initFeetPosX[2] = tmp;
  initFeetPosX[3] = -tmp;
  initFeetPosX[4] = -(COXA_LENGTH + FEMUR_LENGTH);
  initFeetPosX[5] = -tmp;

  tmp = round(sin(60 * MATH_PI / 180) * (COXA_LENGTH + FEMUR_LENGTH));

  initFeetPosY[0] = tmp;
  initFeetPosY[1] = 0;
  initFeetPosY[2] = -tmp;
  initFeetPosY[3] = -tmp;
  initFeetPosY[4] = 0;
  initFeetPosY[5] = tmp;

  for (uint8_t i = 0; i < 6; i++) {
    initFeetPosZ[i] = TIBIA_LENGTH;
  }
}

void calculateBodyIK() {
  for (uint8_t i = 0; i < 6; i++) {
    totalX[i] = initFeetPosX[i] + bodyCoxaOffsetX[i] + posX;
    totalY[i] = initFeetPosY[i] + bodyCoxaOffsetY[i] + posY;
    totalZ[i] = TIBIA_LENGTH;
  }

  sinrotX = sin(rotX * MATH_PI / 180);
  cosrotX = cos(rotX * MATH_PI / 180);

  sinrotY = sin(rotY * MATH_PI / 180);
  cosrotY = cos(rotY * MATH_PI / 180);

  sinrotZ = sin(rotZ * MATH_PI / 180);
  cosrotZ = cos(rotZ * MATH_PI / 180);

  for (uint8_t i = 0; i < 6; i++) {
    bodyIKX[i] = totalX[i] * cosrotY * cosrotZ - totalY[i] * cosrotY * sinrotZ + totalZ[i] * sinrotY - totalX[i];
    bodyIKY[i] = (totalX[i] * cosrotX * sinrotZ + totalX[i] * cosrotZ * sinrotY * sinrotX + totalY[i] * cosrotZ * cosrotX - totalY[i] * sinrotZ * sinrotY * sinrotX - totalZ[i] * cosrotY * sinrotX) - totalY[i];
    bodyIKZ[i] = (totalX[i] * sinrotZ * sinrotX - totalX[i] * cosrotZ * cosrotX * sinrotY + totalY[i] * cosrotZ * sinrotX + totalY[i] * cosrotX * sinrotZ * sinrotY + totalZ[i] * cosrotY * cosrotX) - totalZ[i];
  }

  for (uint8_t i = 0; i < 6; i++) {
    newPosX[i] = initFeetPosX[i] + bodyIKX[i] + posX;
    newPosY[i] = initFeetPosY[i] + bodyIKY[i] + posY;
    newPosZ[i] = initFeetPosZ[i] + bodyIKZ[i] + posZ;
  }
}

void setIKPositions() {
  for (uint8_t i = 0; i < 6; i++) {
    coxaMicroseconds[i] = (coxaAngle[i] + 90) / 180 * 1800 + (600 + coxaServoOffsets[i]);
    femurMicroseconds[i] = (femurAngle[i] + 90) / 180 * 1800 + (600 + femurServoOffsets[i]);
    tibiaMicroseconds[i] = (tibiaAngle[i] + 90) / 180 * 1800 + (600 + tibiaServoOffsets[i]);
  }
}

void moveServos(unsigned int servoTime) {
  String tmpStr = String("#") + String(rightFrontLegNum[0]) + String("P") + String(coxaMicroseconds[0]) + String(" ") +
                  String("#") + String(rightFrontLegNum[1]) + String("P") + String(femurMicroseconds[0]) + String(" ") +
                  String("#") + String(rightFrontLegNum[2]) + String("P") + String(tibiaMicroseconds[0]) + String(" ") +
                  String("#") + String(rightMidLegNum[0]) + String("P") + String(coxaMicroseconds[1]) + String(" ") +
                  String("#") + String(rightMidLegNum[1]) + String("P") + String(femurMicroseconds[1]) + String(" ") +
                  String("#") + String(rightMidLegNum[2]) + String("P") + String(tibiaMicroseconds[1]) + String(" ") +
                  String("#") + String(rightRearLegNum[0]) + String("P") + String(coxaMicroseconds[2]) + String(" ") +
                  String("#") + String(rightRearLegNum[1]) + String("P") + String(femurMicroseconds[2]) + String(" ") +
                  String("#") + String(rightRearLegNum[2]) + String("P") + String(tibiaMicroseconds[2]) + String(" ") +
                  String("#") + String(leftFrontLegNum[0]) + String("P") + String(coxaMicroseconds[3]) + String(" ") +
                  String("#") + String(leftFrontLegNum[1]) + String("P") + String(femurMicroseconds[3]) + String(" ") +
                  String("#") + String(leftFrontLegNum[2]) + String("P") + String(tibiaMicroseconds[3]) + String(" ") +
                  String("#") + String(leftMidLegNum[0]) + String("P") + String(coxaMicroseconds[4]) + String(" ") +
                  String("#") + String(leftMidLegNum[1]) + String("P") + String(femurMicroseconds[4]) + String(" ") +
                  String("#") + String(leftMidLegNum[2]) + String("P") + String(tibiaMicroseconds[4]) + String(" ") +
                  String("#") + String(leftRearLegNum[0]) + String("P") + String(coxaMicroseconds[5]) + String(" ") +
                  String("#") + String(leftRearLegNum[1]) + String("P") + String(femurMicroseconds[5]) + String(" ") +
                  String("#") + String(leftRearLegNum[2]) + String("P") + String(tibiaMicroseconds[5]) + String(" ") +
                  String("T") + String(servoTime) + String("\r\n");

  if (currentState != newState) {
    //Serial1.print(tmpStr);
    Serial.print(tmpStr);
    delay(servoTime);

    currentState = newState;
  }
}

void checkButtons() {
  if (ps2x.ButtonPressed(PSB_START)) {
    newState = BTN_START;
  }

  if (ps2x.ButtonPressed(PSB_PAD_UP)) {
    newState = BTN_UP;
  }

  if (ps2x.ButtonPressed(PSB_PAD_DOWN)) {
    newState = BTN_DOWN;
  }
}

void timerHandler() {
  ps2x.read_gamepad();
}

void calculateLegIK() {
  unsigned int tmp = 30;

  for (uint8_t i = 0; i < 6; i++) {
    transformX[i] = newPosX[i] * cos(tmp * MATH_PI / 180) - newPosY[i] * sin(tmp * MATH_PI / 180);
    transformY[i] = newPosX[i] * sin(tmp * MATH_PI / 180) + newPosY[i] * cos(tmp * MATH_PI / 180);
    transformZ[i] = newPosZ[i];
    tmp += 60;
 
    coxaFeetDist[i] = sqrt(transformX[i] * transformX[i] + transformY[i] * transformY[i]);
   
    IKSW[i] = sqrt((coxaFeetDist[i] - COXA_LENGTH) * (coxaFeetDist[i] - COXA_LENGTH) + (transformZ[i] * transformZ[i]));
    IKA1[i] = atan((coxaFeetDist[i] - COXA_LENGTH) / transformZ[i]);
    IKA2[i] = acos((TIBIA_LENGTH * TIBIA_LENGTH - FEMUR_LENGTH * FEMUR_LENGTH - IKSW[i] * IKSW[i]) / (-2 * IKSW[i] * FEMUR_LENGTH));
    tAngle[i] = acos((IKSW[i] * IKSW[i] - TIBIA_LENGTH * TIBIA_LENGTH - FEMUR_LENGTH * FEMUR_LENGTH) / (-2 * FEMUR_LENGTH * TIBIA_LENGTH));

    tibiaAngle[i] = round(90 - (tAngle[i] * 180 / MATH_PI));
    femurAngle[i] = round(((IKA1[i] + IKA2[i]) * 180 / MATH_PI) - 90);
    coxaAngle[i] = round(90 - (atan2(transformY[i], transformX[i]) * 180 / MATH_PI));
  }
}

void setup() {
  // put your setup code here, to run once:

  initPos();

  setServoOffsetsArrays();

  calculateMidPositions();
  calculateSittingPositions();
  calculateStandingPositions();

  setBodyOffsets();

  calculateFeetPositions();

  Serial.begin(115200);
  //Serial1.begin(115200);

  Timer1.initialize(10000);
  Timer1.attachInterrupt(timerHandler);
  
  while (!Serial) {
    ;
  }

  ps2x.config_gamepad(13, 11, 10, 12, false, false);
}

void loop() {
  // put your main code here, to run repeatedly:
  unsigned long currentMillis = millis();

  asm("nop\n\t");
  

  checkButtons();

  if (newState == BTN_START) {
    if (currentState != newState) {
      setMidPositions();
    }
  }

  if (newState == BTN_UP) {
    if (currentState != newState) {
      rotX = 10;
      calculateBodyIK();
      calculateLegIK();
      setIKPositions();
    }
  }

  if (newState == BTN_DOWN) {
    if (currentState != newState) {
      rotX = -10;
      calculateBodyIK();
      calculateLegIK();
      setIKPositions();
    }
  }

  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    moveServos(servoTime);
  }
}

В общем, это действительно недоработка оптимизатора. У Вас в строка 422-423 происходит много сложных вещей

1) дважды вычисляются одинаковые sin и cos
2) четырежды вычисляется один и тот же аргумент для этих sin и cos
3) всё это на фоне неявного преобразования типов с потерей точности (т.к. sin и cos вообще-то double, а Вы присваиваете float)

Всё это смешалось в большую кучу и оптимизатор немного слетает с катушек.

Решений несколько. Можно, например, выключить оптимизацию, но это очень плохая идея, хочется сохранить её . Самое простое - немного помочь оптимизатору (упростить ему задачу), например, вручную вынести одинаковые вычисления. И тогда он перестанет дурить.

Просто вместо строк 422-423 поставьте вот такие

    const float sinTmp = sin(tmp * MATH_PI / 180);
    const float cosTmp = cos(tmp * MATH_PI / 180);
    transformX[i] = newPosX[i] * cosTmp - newPosY[i] * sinTmp;
    transformY[i] = newPosX[i] * sinTmp + newPosY[i] * cosTmp;

и проблема уйдёт. Я проверил в 1.8.1. В 1.6.13 не проверял, у меня её нет.

ЕвгенийП, спасибо Вам большое! Код компилируется! Подскажите пожалуйста, как правильно оформить такие вычисления? У меня получается каждый раз 18 значений хранятся в 3-х разных массивах, и и все это глобальные переменные. Может тут будет правильнее создать класс и в нем описать все эти функции с формулами?

Не могу ответить на этот вопрос. Структура данных настолько неразрывно связана с алгоритмом обработки - это надо с головой в Вашу задачу погружаться.