Envió de señales de un EOG de forma inalambrica

Buenas noches !!

Estoy realizando un proyecto de un EOG con arduino. Tengo un circuito que capta a través de electrodos los movimientos oculares (izquierda a derecha y arriba hacia abajo) y dicho circuito amplifica la señal y la envía a un arduino uno, con su respectivo programa precargado se conecta el arduino uno a la computadora y se puede observar cada uno de los movimiento previamente mencionados.

Lo que queremos lograr es que, un Arduino uno va estar conectado directamente con el dispositivo que capta y amplifica la señal y transmitir esa señal por un nrf204l01; mientras que el otro arduino uno con otro nrf204l01 va recibir esas señales y mostrarlas en el computador.

Necesito un poco de ayuda con esta transmisión ya que, aun no logro realizar el código de transmisión y recepción que necesita el nrf204l01 para enviar y recibir señales.

El código propio del dispositivo para amplificar todas las señales que esta captando es el siguiente:

#define EKG A0 //estamos leyendo desde AnalogIn 0
#define BUFFER_SIZE 100  //tamaño del búfer de muestreo
#define SIZE_OF_COMMAND_BUFFER 30 //tamaño del búfer de comando
#define LENGTH_OF_MESSAGE_IMPULS 100 // longitud del impulso del mensaje en ms

// define para configurar y borrar bits de registro
#ifndef cbi
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#endif
#ifndef sbi
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))
#endif


int buffersize = BUFFER_SIZE;
int head = 0;//head index para muestreo circular buffer
int tail = 0;//índice de cola para el muestreo de buffer circular
byte writeByte;
char commandBuffer[SIZE_OF_COMMAND_BUFFER];//recibiendo el búfer de comandos
byte reading[BUFFER_SIZE]; //buffer de muestreo


int messageImpulsPin = 5;
int messageImpulseTimer = 0;

long debouncing_time = 15; //Tiempo de rebote en milisegundos
volatile unsigned long last_micros;

int redButton = 4;
int greenButton = 7;

int redLED = 13;
int redLEDCounter = 0;
int greenLED = 8;
int greenLEDCounter = 0;
int redButtonReady = 1;
int greenButtonReady = 1;


//// Esto configura los valores de comunicación serie pueden 9600, 14400, 19200, 28800, 31250, 38400, 57600 y 115200, también 300, 600, 1200, 2400, 4800, pero eso es demasiado lento para nosotros

/// Número de interrupción: muy importante en combinación con la tasa de bits para obtener datos precisos

int interrupt_Number=198; // Valor de los registros de comparación de salida = (16 * 10 ^ 6) / (Fs * 8) - 1 establecido en 1999 para muestreo de 1000 Hz,
//establecido en 3999 para muestreo de 500 Hz, configurado en 7999 para muestreo de 250Hz, 199 para muestreo de 10000 Hz
int numberOfChannels = 1;//número actual de muestreo de canales
int tempSample = 0; 
int commandMode = 0;//indicador para el modo de comando. No envíe datos cuando esté en modo comando

void setup(){ 
  Serial.begin(230400); //Velocidad en baudios de comunicación serie (alt. 115200) 

  delay(300); //espera para iniciar comunicacion serial
  Serial.println("StartUp!");
  Serial.setTimeout(2);
  pinMode(messageImpulsPin, OUTPUT);
   
  // CONFIGURACIÓN DEL TEMPORIZADOR: la interrupción del temporizador permite precarizar mediciones temporizadas del interruptor de lámina
  // para obtener más información sobre la configuración de los temporizadores arduino, consulte http://arduino.cc/playground/Code/Timer1
 
  cli (); // interrupciones de parada

   // Hacer la muestra de ADC más rápido. Cambiar reloj ADC
  // Cambia el factor de división preescala a 16
  sbi(ADCSRA,ADPS2);//1
  cbi(ADCSRA,ADPS1);//0
  cbi(ADCSRA,ADPS0);//0

  // establecer la interrupción del timer1 a 10kHz
  TCCR1A = 0; // establecer el registro TCCR1A completo en 0
  TCCR1B = 0; // igual para TCCR1B
  TCNT1 = 0; // inicializar el valor del contador a 0;
  OCR1A = interrupt_Number; // registros de comparación de salida 
  // activar el modo CTC
  TCCR1B |= (1 << WGM12);
  // Establecer CS11 bit para 8 prescaler
  TCCR1B |= (1 << CS11);   
  // habilitar el temporizador comparar interrupción
  TIMSK1 |= (1 << OCIE1A);
  
  
 sei (); // permitir interrupciones
  // CONFIGURACIÓN DEL TEMPORIZADOR FINAL
}


ISR (TIMER1_COMPA_vect) {
   // Interrumpir en la frecuencia de tiempo que configuró anteriormente para medir para medir la entrada analógica y llenar los buffers
  
   if(messageImpulseTimer>0)
   {
     messageImpulseTimer--;
     if(messageImpulseTimer==0)
     {
         digitalWrite(messageImpulsPin, LOW);
     }
   }
   
   
   if(commandMode!=1)
   {
     
     // Poner las muestras en el buffer de muestreo "leyendo". Como Arduino Mega tiene un ADC de 10 bits, dividiremos cada muestra en 2 bytes.
     // El primer byte contendrá 3 bits más significativos y el segundo byte contendrá 7 bits menos significativos.
     // El primer bit en todos los bytes no se utilizará para los datos sino para marcar el inicio del marco de datos (matriz de muestras de N canales)
     // Solo el primer byte en el cuadro tendrá el bit más significativo establecido en 1
     
       // Muestra el primer canal y ponlo en buffer
       tempSample = analogRead(A0);
       reading[head] =  (tempSample>>7)|0x80;// Marque el comienzo del marco configurando MSB en 1
       head = head+1;
       if(head==BUFFER_SIZE)
       {
         head = 0;
       }
       reading[head] =  tempSample & 0x7F;
       head = head+1;
       if(head==BUFFER_SIZE)
       {
         head = 0;
       }
      
   }
   
   
}
   
void serialEvent() 
{
   commandMode = 1; // frag que estamos recibiendo comandos a través de serie
   TIMSK1 &= ~(1 << OCIE1A); // deshabilitar el temporizador para el muestreo
  // lee hasta \ n desde el puerto serial:
  String inString = Serial.readStringUntil ('\ n');

  // convertir la cadena en nulo terminar la matriz de caracteres
  inString.toCharArray (commandBuffer, SIZE_OF_COMMAND_BUFFER);
  commandBuffer [inString.length ()] = 0;
  
  
  // rompe la cadena str en una serie de tokens usando delimitador ";"
  // Es decir, dividir cadenas en comandos
  char* command = strtok(commandBuffer, ";");
  while (command != 0)
  {
      // Dividir el comando en 2 partes: nombre y valor
      char* separator = strchr(command, ':');
      if (separator != 0)
      {
           // Dividir la cadena en 2: reemplazar ':' con 0
          *separator = 0;
          --separator;
          if(*separator == 'c') // si recibimos un comando para el número de canales
          {
            separator = separator+2;
            numberOfChannels = atoi(separator);//lee el número de canales
          }
           if(*separator == 's')//si recibimos un comando para la tasa de muestreo
          {
            //hacer nada. No cambie la frecuencia de muestreo en este momento.
            // Calculamos la tasa de muestreo más abajo como (máx. Fs) / (Número de canales)
          }
          
          if(*separator == 'p')// si recibimos un comando para el impulso
          {
            // Establecer impulso
            separator = separator+2;
            digitalWrite(messageImpulsPin, HIGH);
            messageImpulseTimer = (LENGTH_OF_MESSAGE_IMPULS * 10)/numberOfChannels;
          }
      }
      //  Encuentra el siguiente comando en la cadena de entrada
      command = strtok(0, ";");
  }
  //calcular la tasa de muestreo
  OCR1A = (interrupt_Number+1)*numberOfChannels - 1;
  TIMSK1 |= (1 << OCIE1A);//enable timer for sampling
  commandMode = 0;
}


void loop(){
    
    while(head!=tail && commandMode!=1)// mientras hay datos en el buffer de muestreo en funcionamiento
    {
      Serial.write(reading[tail]);
   
      //Move thail for one byte
      tail = tail+1;
      if(tail==BUFFER_SIZE)
      {
        tail = 0;
      }
    }

Tengo entendido que a este código tengo que agregarle las librerías y el programa necesario para transmitir dicha señal por el nrf204l01. Luego en el otro arduino tengo que colocar el código que recibe esa señal captada por el nrf204l01 conectado al mismo.

Si alguien puede ayudarme para realizar dichos programas, seria de muy gran ayuda. O si alguien tiene una manera mas fácil o distinta de enviar las señales de forma inalambrica, se lo agradecería.

Gracias

Te remcomiendo usar la librería de Tmrh20 RF24. Con eso será suficiente. Busca Arduino Tmrh20 y tendras respuestas.