센서에서 출력하는 데이터를 1초마다 읽고 있는 상태입니다. 
샘플링은 1/512 초 이지만 데이터 패킷을 받아오는 속도는 1초입니다. 
제 생각에는 이 속도를 변화시킬 수 없다고 생각하는데 
제가 초보이기에 혹시나 방법이 있는지 궁금하여 질문드립니다.
아래는 헤더파일과 cpp파일, 아두이노 코드입니다.
 
1. mindwave.h
#ifndef Mindwave_h
#define Mindwave_h
#include <inttypes.h>
#if defined(ARDUINO) && ARDUINO >= 100
  #include "Arduino.h"
#else
  #include "WProgram.h"
  #include <pins_arduino.h>
#endif
//baud rate
#define MINDWAVE_BAUDRATE         57600
//states
#define MINDWAVE_WAIT_FOR_FIRST_A        0
#define MINDWAVE_WAIT_FOR_SECOND_A       1
#define MINDWAVE_WAIT_FOR_PAYLOAD_LENGTH 2
#define MINDWAVE_WAIT_FOR_PAYLOAD        3
#define MINDWAVE_WAIT_FOR_CHECKSUM       4
//EEG
#define MINDWAVE_EEG_SIZE        8
#define MINDWAVE_PACKET_MAX_SIZE     173
#define MINDWAVE_PAYLOAD_MAX_SIZE    169
typedef void (*MindwaveDataCallback) ();
class Mindwave
{

  public:
    Mindwave();
    void update(Stream &stream,MindwaveDataCallback onData);
    int  attention();
    int  meditation();
    int  quality();
    long lastUpdate();
    int* eeg();
    int  delta();
    int  theta();
    int  lowAlpha();
    int  highAlpha();
    int  lowBeta();
    int  highBeta();
    int  lowGamma();
    int  midGamma();
  private:
    // checksum variables
    byte _generatedChecksum = 0;
    byte _checksum = 0; 
    int  _payloadLength = 0;
    int  _payloadIndex;
    byte _payloadData[MINDWAVE_PACKET_MAX_SIZE] = {0};
    
    byte _poorQuality = 0;
    byte _attention;
    byte _meditation;
    int  _eeg[MINDWAVE_EEG_SIZE];
    // system variables
    long _lastReceivedPacket = 0, _lastUpdate = 0;
    boolean _bigPacket = false;
    int _state = 0;
    
    void parsePayload(MindwaveDataCallback onData);
};
#endif
 
 
 
2. mindwave.cpp
#include "Mindwave.h"
Mindwave::Mindwave(){}
void Mindwave::update(Stream &stream,MindwaveDataCallback onData){
  if(stream.available() > 0){
      switch(_state){
        case MINDWAVE_WAIT_FOR_FIRST_A:
          if(stream.read() == 0xAA) _state = MINDWAVE_WAIT_FOR_SECOND_A;
        break;
        case MINDWAVE_WAIT_FOR_SECOND_A:
          if(stream.read() == 0xAA) _state = MINDWAVE_WAIT_FOR_PAYLOAD_LENGTH;
        break;
        case MINDWAVE_WAIT_FOR_PAYLOAD_LENGTH:
          _payloadLength = stream.read();
          if(_payloadLength > MINDWAVE_PAYLOAD_MAX_SIZE){
            _state = MINDWAVE_WAIT_FOR_FIRST_A;
            return;
          }
          _generatedChecksum = _payloadIndex = 0;
          _state = MINDWAVE_WAIT_FOR_PAYLOAD;
        break;
        case MINDWAVE_WAIT_FOR_PAYLOAD:
          if(_payloadIndex < _payloadLength){
            _payloadData[_payloadIndex] = stream.read();
            _generatedChecksum += _payloadData[_payloadIndex];
            _payloadIndex++;
          }else{
            _state = MINDWAVE_WAIT_FOR_CHECKSUM;
          }
        break;
        case MINDWAVE_WAIT_FOR_CHECKSUM:
          _checksum = stream.read();
          _generatedChecksum = 255 - _generatedChecksum;
          if(_checksum == _generatedChecksum) {
            parsePayload(onData);
            _state = MINDWAVE_WAIT_FOR_FIRST_A;
          }else{
            _state = MINDWAVE_WAIT_FOR_FIRST_A;
          }
        break;
      }
  } 
}
void Mindwave::parsePayload(MindwaveDataCallback onData){
  _poorQuality = 200;
  _attention = 0;
  _meditation = 0;
  for (int j = 0; j < MINDWAVE_EEG_SIZE; j++) _eeg[j] = 0;
  for(int i = 0; i < _payloadLength; i++) {    // Parse the payload
    switch (_payloadData[i]) {
    case 2:
      i++;            
      _poorQuality = _payloadData[i];
      _bigPacket = true;            
      break;
    case 4:
      i++;
      _attention = _payloadData[i];                        
      break;
    case 5:
      i++;
      _meditation = _payloadData[i];
      break;
    case 0x80:
      i = i + 3;
      break;
    case 0x83:
      i++;
    for (int j = 0; j < MINDWAVE_EEG_SIZE; j++) {
    _eeg[j] = ((int)_payloadData[++i] << 16) | ((int)_payloadData[++i] << 8) | (int)_payloadData[++i];
    }      
      break;
    default:
      break;
    } // switch
  } // for loop
  if(_bigPacket) {
    _lastUpdate = millis() - _lastReceivedPacket;
    _lastReceivedPacket = millis();
    onData();
  }
  _bigPacket = false;   
}
int Mindwave::attention(){
  return _attention;
}
int Mindwave::meditation(){
  return _meditation;
}
int Mindwave::quality(){
  return (100-(_poorQuality/2));
}
long Mindwave::lastUpdate(){
  return _lastUpdate;
}
int* Mindwave::eeg(){
  return _eeg;  
}
int Mindwave::delta(){
  return _eeg[0];
}
int Mindwave::theta(){
  return _eeg[1];
}
int Mindwave::lowAlpha(){
  return _eeg[2];
}
int Mindwave::highAlpha(){
  return _eeg[3];
}
int Mindwave::lowBeta(){
  return _eeg[4];
}
int Mindwave::highBeta(){
  return _eeg[5];
}
int Mindwave::lowGamma(){
  return _eeg[6];
}
int Mindwave::midGamma(){
  return _eeg[7];
}
 
 
 
3. EEG(arduino code)
 
#include <Mindwave.h>
Mindwave mindwave;
int*     eeg;
int meditation;
int attention;
int quality;
long lastUpdate;
void setup() {
  Serial.begin(MINDWAVE_BAUDRATE);
  Serial.println("delta\ttheta\tlowAlpha\thighAlpha\tlowBeta\thightBeta\tlowGamma\thighGamma\tmeditation\tattention\tlastupdate\tpoorquality");
}
void onMindwaveData(){
  eeg = mindwave.eeg();
  meditation = mindwave.meditation();
  attention = mindwave.attention();
  lastUpdate = mindwave.lastUpdate();
  quality = mindwave.quality();
  for(int i = 0 ; i < MINDWAVE_EEG_SIZE; i++){
    Serial.print(eeg[i]);                                              -----------------------> 이 값들을 더 빨리 읽고 싶습니다.
    if(i < MINDWAVE_EEG_SIZE) Serial.print('\t');
  }
  Serial.print(meditation);
  Serial.print('\t');
  Serial.print(attention);
  Serial.print('\t');
  Serial.print(lastUpdate);
  Serial.print('\t');
  Serial.print(quality);
  Serial.println();
  //alternatively get individual value via delta(),theta() ,lowAlpha() ,highAlpha() ,lowBeta() ,highBeta() ,lowGamma() ,midGamma() functions
}
void loop() {
  mindwave.update(Serial,onMindwaveData);
}