Форум arduino.ua

#define PARSE_AMOUNT 8    // максимальное количество значений в массиве, который хотим получить
#define header '$'        // стартовый символ
#define divider ','       // разделительный символ
#define ending ';'        // завершающий символ
int intData[PARSE_AMOUNT];     // массив численных значений после парсинга
boolean recievedFlag;
String request = "1234567891011121314151617181920";
boolean getStarted;
byte index;
String string_convert = "";
boolean parseString, getString;

void bluetoothTick() {
  parsing();              // функция парсинга
  if (recievedFlag) {     // если получены данные
    recievedFlag = false;
    if (getString) {
      getString = false;
      loadingFlag = true;
      thisLength = runningText.length();
      showText = true;
      updateSettings();
      return;
    }

    switch (intData[0]) {
      case 0:   // запрос онлайна
        request = "OK ";
        request += String(random(0, 100));
        btSerial.print(request);
        break;
      case 1: // вкл/выкл
        toggleText(intData[1]);
        break;
      case 2: // скорость
        thisSpeed = 110 - intData[1];
        scrollTimer.setInterval(thisSpeed);
        break;
      case 3: // яркость
        thisBright = intData[1];
        matrix.setIntensity(thisBright);
        break;
      case 4: // режим
        thisMode = intData[1];
        break;
      case 5: // цвет
        thisColor = intData[1];
        break;
      case 6: // авто
        autoFlag = intData[1];
        if (autoFlag) showText = true;
        break;
    }
    if (intData[0] > 0) updateSettings();
  }
}

void parsing() {
  if (btSerial.available() > 0) {
    char incomingByte;
    if (parseString) {
      runningText = "";
      runningText = btSerial.readString();  // принимаем всю
      incomingByte = ending;              // сразу завершаем парс
    } else {
      incomingByte = btSerial.read();      // обязательно ЧИТАЕМ входящий символ
    }
    if (getStarted) {                         // если приняли начальный символ (парсинг разрешён)
      if (incomingByte != divider && incomingByte != ending) {  // если это не пробел И не конец
        string_convert += incomingByte;       // складываем в строку
      } else {                                // если это пробел или ; конец пакета
        intData[index] = string_convert.toInt();  // преобразуем строку в int и кладём в массив
        string_convert = "";                  // очищаем строку
        index++;                              // переходим к парсингу следующего элемента массива
      }
    }
    if (incomingByte == header) {             // если это $
      getStarted = true;                      // поднимаем флаг, что можно парсить
      index = 0;                              // сбрасываем индекс
      string_convert = "";                    // очищаем строку
      parseString = false;
    }
    if (incomingByte == '#') {                // если это #
      getStarted = true;                      // поднимаем флаг, что можно парсить
      index = 0;                              // сбрасываем индекс
      string_convert = "";                    // очищаем строку
      parseString = true;
      getString = true;
    }
    if (incomingByte == ending) {             // если таки приняли ; - конец парсинга
      getStarted = false;                     // сброс
      recievedFlag = true;                    // флаг на принятие
      parseString = false;
    }
  }
}

 private class ConnectThread extends Thread {

    private BluetoothSocket bluetoothSocket = null;
    private BluetoothDevice device;

    public ConnectThread(BluetoothDevice device) {
        try {
            Method method = device.getClass().getMethod("createRfcommSocket", new Class[]{int.class});
            bluetoothSocket = (BluetoothSocket) method.invoke(device, 1);
            this.device = device;
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            bluetoothSocket.connect();
            success = true;

        } catch (IOException e) {
            e.printStackTrace();

            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    mProgressDialog.dismiss();
                    Toast.makeText(MainActivity.this, "Не могу соединиться!", Toast.LENGTH_SHORT).show();
                }
            });

            cancel();
        }

        if (success) {
            connectedThread = new ConnectedThread(bluetoothSocket);
            connectedThread.start();


            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    showFrameDeviceControls();
                    txtDeviceConnectedName.setText(device.getName());
                    txtDeviceConnectedName.setTextColor(getResources().getColor(R.color.colorGreen));
                }
            });
        }
    }

    public boolean isConnect() {
        return bluetoothSocket.isConnected();
    }

    public void cancel() {
        try {
            bluetoothSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}



private class ConnectedThread extends Thread {

    private final InputStream inputStream;
    private final OutputStream outputStream;

    public ConnectedThread(BluetoothSocket bluetoothSocket) {
        InputStream inputStream = null;
        OutputStream outputStream = null;

        try {
            inputStream = bluetoothSocket.getInputStream();
            outputStream = bluetoothSocket.getOutputStream();
        } catch (IOException e) {
            e.printStackTrace();
        }

        this.inputStream = inputStream;
        this.outputStream = outputStream;
    }

    @Override
    public void run() {

    }

    public void write(String command) {
        byte[] bytes = command.getBytes();
        if (outputStream != null) {
            try {
                outputStream.write(bytes);
                outputStream.flush();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public void cancel() {
        try {
            inputStream.close();
            outputStream.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

    /*
  Скетч к проекту "Бегущая строка"
  Страница проекта (схемы, описания): https://alexgyver.ru/GyverString/
  Исходники на GitHub: https://github.com/AlexGyver/GyverString/
  Нравится, как написан код? Поддержи автора! https://alexgyver.ru/support_alex/
  Автор: AlexGyver, AlexGyver Technologies, 2019
  https://AlexGyver.ru/
*/

//  Версия 1.2 - исправлена ошибка с количеством матриц
// Версия 1.3 - исправлена скорость

// ================ НАСТРОЙКИ ================
#define MATR_NUM 8            // количество матриц последовательно

// ============ ДЛЯ РАЗРАБОТЧИКОВ ============
// ПИНЫ
#define BT_RX 3
#define BT_TX 2

// БИБЛИОТЕКИ
#include <SoftwareSerial.h>
#include <avr/eeprom.h>
#include <SPI.h>
#include <Adafruit_GFX.h>
#include <Max72xxPanel.h>
#include "fonts.h"
#include "timerMinim.h"

#define WIDTH MATR_NUM*8      // ширина матрицы
#define HEIGHT 8              // высота матрицы

Max72xxPanel matrix = Max72xxPanel(10, MATR_NUM, 1);
SoftwareSerial btSerial(BT_TX, BT_RX); // RX, TX
timerMinim scrollTimer(100);
timerMinim eepromTimer(5000);

String runningText = "";
boolean loadingFlag, fullTextFlag, runningState = true, eepromFlag = false, autoFlag = true, showText = true;
byte thisSpeed, thisBright, thisMode, thisColor, thisLength;

void setup() {
  //Serial.begin(9600);
  btSerial.begin(9600);
  btSerial.setTimeout(100);
  randomSeed(analogRead(0));
  if (eeprom_read_byte((uint8_t*)1023) != 123) {
    eeprom_write_byte((uint8_t*)1023, 123);
    for (int i = 10; i < 300; i++) eeprom_write_byte((uint8_t*)i, 0);
    eeprom_write_byte((uint8_t*)0, 60);
    eeprom_write_byte((uint8_t*)1, 60);
    eeprom_write_byte((uint8_t*)2, 0);
    eeprom_write_byte((uint8_t*)3, 0);
    eeprom_write_byte((uint8_t*)4, 0);
  }
  thisSpeed = eeprom_read_byte((uint8_t*)0);
  thisBright = eeprom_read_byte((uint8_t*)1);
  thisMode = eeprom_read_byte((uint8_t*)2);
  thisColor = eeprom_read_byte((uint8_t*)3);
  thisLength = eeprom_read_byte((uint8_t*)4);

  for (byte i = 10; i < thisLength + 10; i++) {
    runningText += (char)eeprom_read_byte((uint8_t*)i);
  }

  matrix.setIntensity(50);
  for (byte i = 0; i < MATR_NUM; i++) {
    // матрицы расположены криво, здесь поворачиваем
    matrix.setRotation(i, 1);
  }
  matrix.fillScreen(LOW);
  matrix.write();

  scrollTimer.setInterval(thisSpeed);
}

void loop() {
  bluetoothTick();  // парсинг блютус
  if (runningState) fillString(runningText, thisMode);
  eepromTick();
}

void toggleText(boolean state) {
  if (state) {
    runningState = true;
    loadingFlag = true;
  } else {
    runningState = false;
    matrix.fillScreen(LOW);
    matrix.write();
  }
}

   // --------------- РАБОТА С EEPROM --------------
// EEPROM MAP
// 0 - скорость
// 1 - яркость
// 2 - режим
// 3 - цвет
// 4 - длина строки
// 10-300 - строка


void eeprom_update_byte(int addr, byte value) {
  byte buf = eeprom_read_byte((uint8_t*)addr);
  if (value != buf) eeprom_write_byte((uint8_t*)addr, value);
}

void updateSettings() {
  eepromFlag = true;    // ставим галочку, что данные изменились
  eepromTimer.reset();
}

void eepromTick() {
  eepromFlag = false;
  eeprom_update_byte(0, thisSpeed);
  eeprom_update_byte(1, thisBright);
  eeprom_update_byte(2, thisMode);
  eeprom_update_byte(3, thisColor);
  eeprom_update_byte(4, thisLength);

  for (byte i = 10; i < thisLength + 10; i++) {
    eeprom_update_byte(i, runningText[i - 10]);
  }
}