Строки и массивы

Строки #

Изменить раскладку (RU в QWERTY) - String #

const char _qwerty_ru[] PROGMEM = "F<DULT:PBQRKVYJGHCNEA{WXIO}SM\">Zf,dult;pbqrkvyjghcnea[wxio]sm'.z~`";

String ru_to_qw(const String& ru) {
  String qw;
  uint8_t prev = 0;
  for (int i = 0; i < ru.length(); i++) {
    uint8_t cur = ru[i];
    if (cur > 127) {
      uint8_t thiscur = cur;
      if (cur > 191) cur = 0;
      else if (prev == 209 && cur == 145) cur = 193;   // ё
      else if (prev == 208 && cur == 129) cur = 192;   // Ё
      prev = thiscur;
    }
    if (!cur) continue;

    if (cur <= 127) {
      qw += (char)cur;
      continue;
    }
    else if (cur <= 143) cur -= 80;
    else if (cur <= 191) cur -= 144;
    else cur -= 128;
    qw += (char)pgm_read_byte(&_qwerty_ru[cur]);
  }
  return qw;
}

Serial.println(ru_to_qw("123abcПривет")); // 123abcGhbdtn

Изменить раскладку (RU в QWERTY) - char* #

const char _qwerty_ru[] PROGMEM = "F<DULT:PBQRKVYJGHCNEA{WXIO}SM\">Zf,dult;pbqrkvyjghcnea[wxio]sm'.z~`";

uint16_t ru_to_qw(const char* ru, char* qw) {
  uint16_t len = strlen(ru);
  uint16_t idx = 0;
  uint8_t prev = 0;
  for (int i = 0; i < len; i++) {
    uint8_t cur = ru[i];
    if (cur > 127) {
      uint8_t thiscur = cur;
      if (cur > 191) cur = 0;
      else if (prev == 209 && cur == 145) cur = 193;   // ё
      else if (prev == 208 && cur == 129) cur = 192;   // Ё
      prev = thiscur;
    }
    if (!cur) continue;

    if (cur <= 127) {
      qw[idx++] = (char)cur;
      continue;
    }
    else if (cur <= 143) cur -= 80;
    else if (cur <= 191) cur -= 144;
    else cur -= 128;
    qw[idx++] = (char)pgm_read_byte(&_qwerty_ru[cur]);
  }
  qw[idx] = 0;
  return idx;
}

char* ru = "Привет";
char qw[strlen(ru)];
ru_to_qw(ru, qw);

Serial.println(qw);  // Ghbdtn

Длина строки с кириллицей #

int strlen_ru(const char* data) {
  int i = 0;
  int count = 0;
  while (data[i]) {
    if ((data[i] & 0xc0) != 0x80) count++;
    i++;
  }
  return count;
}

strlen_ru("Привет");    // 6

Encode unicode #

String u_encode(uint32_t c) {
  char b1 = 0, b2 = 0, b3 = 0, b4 = 0;
  if (c < 0x80) {
    b1 = c & 0x7F | 0x00;
  } else if (c < 0x0800) {
    b1 = c >> 6 & 0x1F | 0xC0;
    b2 = c >> 0 & 0x3F | 0x80;
  } else if (c < 0x010000) {
    b1 = c >> 12 & 0x0F | 0xE0;
    b2 = c >> 6 & 0x3F | 0x80;
    b3 = c >> 0 & 0x3F | 0x80;
  } else if (c < 0x110000) {
    b1 = c >> 18 & 0x07 | 0xF0;
    b2 = c >> 12 & 0x3F | 0x80;
    b3 = c >> 6 & 0x3F | 0x80;
    b4 = c >> 0 & 0x3F | 0x80;
  }
  String s;
  s.reserve(4);
  s += b1;
  s += b2;
  s += b3;
  s += b4;
  return s;
}

Serial.println(u_encode(0x2605));  // ★

wchar_t строка в String #

wchar_t str[] = {'П', 'р', 'и', 'в', 'е', 'т'};
  char* p = (char*)str;
  for (int i = 0; i < sizeof(str); i += 2) {
  Serial.print(p[i + 1]);
  Serial.print(p[i]);
}

Массивы #

Переворот #

void setup() {
  Serial.begin(9600);
  byte bytes[] = {0, 1, 2, 3, 4, 5, 6, 7};

  // выводим в порт
  for (byte i = 0; i < 8; i++) {
    Serial.print(bytes[i]);
    Serial.print(' ');
  }
  Serial.println();

  // копируем массив в буфер
  byte buf[8];
  for (byte i = 0; i < 8; i++) {
    buf[i] = bytes[i];
  }

  // переписываем наоборот
  for (byte i = 0; i < 8; i++) {
    bytes[i] = buf[7 - i];
  }

  // выводим для проверки
  for (byte i = 0; i < 8; i++) {
    Serial.print(bytes[i]);
    Serial.print(' ');
  }
}

Сравнение элементов (диагональный цикл) #

// len - размер массива
for (int i = 0; i < len - 1; i++) {
  for (int j = i + 1; j < len; j++) {
    // сравниваем [i] и [j]
  }
}

Рекурсивная сортировка #

Быстрый алгоритм сортировки, но потребляет много оперативной памяти для вызова (рекурсия):

void quickSort(int arr[], int low, int high) {
  if (low < high) {
    int pivot = arr[high];
    int idx = low;
    for (int i = low; i <= high; i++) {
      if (arr[i] <= pivot) {
        int buf = arr[idx];
        arr[idx] = arr[i];
        arr[i] = buf;
        idx++;
      }
    }
    idx--;
    quickSort(arr, low, idx - 1);
    quickSort(arr, idx + 1, high);
  }
}

int arr[] = {53, 2, 654, 32, 34, 6843, 84, 358};
quickSort(arr, 0, sizeof(arr)/sizeof(arr[0]) - 1);
// quickSort(массив, 0, длина - 1)