RC bil med nRF24l1 ping/pong problemer (Læst 10988x)

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
RC bil med nRF24l1 ping/pong problemer
« Dato: August 23, 2014, 13:51:40 »
Hey.

Jeg har et problem med at sende de nederstående F,B,A,S signaler fra min ene nRF24l01 til den anden.

Modtageren har denne kode, og jeg har fået slettet 'sende koden'
Kode:
/*
 Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

/**
 * Example for Getting Started with nRF24L01+ radios. 
 *
 * This is an example of how to use the RF24 class.  Write this sketch to two 
 * different nodes.  Put one of the nodes into 'transmit' mode by connecting 
 * with the serial monitor and sending a 'T'.  The ping node sends the current 
 * time to the pong node, which responds by sending the value back.  The ping 
 * node can then see how long the whole cycle took.
 */

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//
// Hardware configuration
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

int right01 = 4;
int right02 = 5;
int left01 = 6;
int left02 = 7;



void setup(void)
{
  pinMode(right01, OUTPUT);
  pinMode(right02, OUTPUT);
  pinMode(left01, OUTPUT);
  pinMode(left02, OUTPUT);
  //
  // Print preamble
  //

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  //
  // Setup and configure rf radio
  //

  radio.begin();

  // optionally, increase the delay between retries & # of retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to
  // improve reliability
  //radio.setPayloadSize(8);

  //
  // Open pipes to other nodes for communication
  //

  // This simple sketch opens two pipes for these two nodes to communicate
  // back and forth.
  // Open 'our' pipe for writing
  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

  //if ( role == role_ping_out )
  {
    //radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
  }
  //else
  {
    //radio.openWritingPipe(pipes[1]);
    //radio.openReadingPipe(1,pipes[0]);
  }

  //
  // Start listening
  //

  radio.startListening();

  //
  // Dump the configuration of the rf unit for debugging
  //

  radio.printDetails();
}

void loop(void)
{
  //
  // Ping out role.  Repeatedly send the current time
  //

  if (role == role_ping_out)
  {
    // First, stop listening so we can talk.
    radio.stopListening();

    // Take the time, and send it.  This will block until complete
    unsigned long time = millis();
    printf("Now sending %lu...",time);
    bool ok = radio.write( &time, sizeof(unsigned long) );
    
    if (ok)
      printf("ok...");
    else
      printf("failed.\n\r");

    // Now, continue listening
    radio.startListening();

    // Wait here until we get a response, or timeout (250ms)
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;

    // Describe the results
    if ( timeout )
    {
      printf("Failed, response timed out.\n\r");
    }
    else
    {
      // Grab the response, compare, and send to debugging spew
      unsigned long got_time;
      radio.read( &got_time, sizeof(unsigned long) );

      // Spew it
      printf("Got response %lu, round-trip delay: %lu\n\r",got_time,millis()-got_time);
    }

    // Try again 1s later
    delay(1000);
  }

  //
  // Pong back role.  Receive each packet, dump it out, and send it back
  //

  if ( role == role_pong_back )
  {
    /*
    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      unsigned long got_time;
      bool done = false;
      while (!done)
      {
        // Fetch the payload, and see if this was the last one.
        done = radio.read( &got_time, sizeof(unsigned long) );

        // Spew it
        printf("Got payload %lu...",got_time);

	// Delay just a little bit to let the other unit
	// make the transition to receiver
	delay(20);
      }

      // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &got_time, sizeof(unsigned long) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
    }
    */
  }

  //
  // Change roles
  //

  if ( Serial.available() )
  {
    /*
    int analoger = analogRead(1);
    int fremad = 4800/(analoger - 20);
    
    int analogen = analogRead(2);
    int tilbage = 4800/(analogen - 20);
    */
    char c = toupper(Serial.read());
    
    
    
    
    //F = fremad
    if ( c == 'F' && role == role_pong_back )
    {
       forwards();
    }

    //F = fremad
    if ( c == 'B' && role == role_pong_back )
    {
       backwards();
    }
    
    //F = fremad
    if ( c == 'A' && role == role_pong_back )
    {
       around();
    }


    //F = fremad
    if ( c == 'S' && role == role_pong_back )
    {
       stopper();
    }

    /*
    if ( c == 'T' && role == role_pong_back )
    {
      printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

      // Become the primary transmitter (ping out)
      role = role_ping_out;
      radio.openWritingPipe(pipes[0]);
      radio.openReadingPipe(1,pipes[1]);
    }
    else if ( c == 'R' && role == role_ping_out )
    {
      printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
      
      // Become the primary receiver (pong back)
      role = role_pong_back;
      radio.openWritingPipe(pipes[1]);
      radio.openReadingPipe(1,pipes[0]);
    }
    */
  }
}
// vim:cin:ai:sts=2 sw=2 ft=cpp


void forwards(){
  digitalWrite(right02, LOW);
  digitalWrite(right01, HIGH);
  digitalWrite(left02, LOW);
  digitalWrite(left01, HIGH);  
}

void backwards(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, HIGH);
  digitalWrite(left01, LOW);
  digitalWrite(left02, HIGH);
}

void around(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, HIGH);
  digitalWrite(left02, LOW);
  digitalWrite(left01, HIGH);
  
}

void stopper(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, LOW);
  digitalWrite(left02, LOW);
  digitalWrite(left01, LOW);
}

Nogen der kan hjælpe?
« Senest Redigeret: August 23, 2014, 23:36:57 af Danni-Hansen »
Mvh. Danni Hansen.

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #1 Dato: August 23, 2014, 23:36:33 »
Og forsøgte så med denne kode på begge arduino nano, men jeg har på fornemmelsen af at jeg koder det forkerte sted?

Kode:
/*
 Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

/**
 * Example for Getting Started with nRF24L01+ radios. 
 *
 * This is an example of how to use the RF24 class.  Write this sketch to two 
 * different nodes.  Put one of the nodes into 'transmit' mode by connecting 
 * with the serial monitor and sending a 'T'.  The ping node sends the current 
 * time to the pong node, which responds by sending the value back.  The ping 
 * node can then see how long the whole cycle took.
 */

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//
// Hardware configuration
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

int right01 = 4;
int right02 = 5;
int left01 = 6;
int left02 = 7;



void setup(void)
{
  pinMode(right01, OUTPUT);
  pinMode(right02, OUTPUT);
  pinMode(left01, OUTPUT);
  pinMode(left02, OUTPUT);
  //
  // Print preamble
  //

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  //
  // Setup and configure rf radio
  //

  radio.begin();

  // optionally, increase the delay between retries & # of retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to
  // improve reliability
  //radio.setPayloadSize(8);

  //
  // Open pipes to other nodes for communication
  //

  // This simple sketch opens two pipes for these two nodes to communicate
  // back and forth.
  // Open 'our' pipe for writing
  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

  //if ( role == role_ping_out )
  {
    //radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
  }
  //else
  {
    //radio.openWritingPipe(pipes[1]);
    //radio.openReadingPipe(1,pipes[0]);
  }

  //
  // Start listening
  //

  radio.startListening();

  //
  // Dump the configuration of the rf unit for debugging
  //

  radio.printDetails();
}

void loop(void)
{
  //
  // Ping out role.  Repeatedly send the current time
  //

  if (role == role_ping_out)
  {
    // First, stop listening so we can talk.
    radio.stopListening();

    // Take the time, and send it.  This will block until complete
    unsigned long time = millis();
    printf("Now sending %lu...",time);
    bool ok = radio.write( &time, sizeof(unsigned long) );
    
    if (ok)
      printf("ok...");
    else
      printf("failed.\n\r");

    // Now, continue listening
    radio.startListening();

    // Wait here until we get a response, or timeout (250ms)
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;

    // Describe the results
    if ( timeout )
    {
      printf("Failed, response timed out.\n\r");
    }
    else
    {
      // Grab the response, compare, and send to debugging spew
      unsigned long got_time;
      radio.read( &got_time, sizeof(unsigned long) );

      // Spew it
      printf("Got response %lu, round-trip delay: %lu\n\r",got_time,millis()-got_time);
    }

    // Try again 1s later
    delay(1000);
  }

  //
  // Pong back role.  Receive each packet, dump it out, and send it back
  //

  if ( role == role_pong_back )
  {
    
    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      unsigned long got_time;
      bool done = false;
      while (!done)
      {
        // Fetch the payload, and see if this was the last one.
        done = radio.read( &got_time, sizeof(unsigned long) );

        // Spew it
        printf("Got payload %lu...",got_time);

	// Delay just a little bit to let the other unit
	// make the transition to receiver
	delay(20);
      }

      // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &got_time, sizeof(unsigned long) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
    }
    
  }

  //
  // Change roles
  //

  if ( Serial.available() )
  {
    char c = toupper(Serial.read());
    
    if ( (c == 'F' || c == 'B' || c == 'A' || c == 'S' ) && role == role_pong_back )
    {
      if(c == 'F'){
       forwards();
      }
      if(c == 'B'){
       backwards();
      }
      if(c == 'A'){
       around();
      }
      if(c == 'S'){
       stopper();
      }
      
      printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

      // Become the primary transmitter (ping out)
      role = role_ping_out;
      radio.openWritingPipe(pipes[0]);
      radio.openReadingPipe(1,pipes[1]);
    }
    //else 
    
    if ( (c == 'F' || c == 'B' || c == 'A' || c == 'S' ) && role == role_ping_out )
    {
      if(c == 'F'){
       forwards();
      }
      if(c == 'B'){
       backwards();
      }
      if(c == 'A'){
       around();
      }
      if(c == 'S'){
       stopper();
      }

      printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
      
      // Become the primary receiver (pong back)
      role = role_pong_back;
      radio.openWritingPipe(c);
      radio.openReadingPipe(1,pipes[0]);
    }
    
  }
}
// vim:cin:ai:sts=2 sw=2 ft=cpp


void forwards(){
  digitalWrite(right02, LOW);
  digitalWrite(right01, HIGH);
  digitalWrite(left02, LOW);
  digitalWrite(left01, HIGH);  
}

void backwards(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, HIGH);
  digitalWrite(left01, LOW);
  digitalWrite(left02, HIGH);
}

void around(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, HIGH);
  digitalWrite(left02, LOW);
  digitalWrite(left01, HIGH);
  
}

void stopper(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, LOW);
  digitalWrite(left02, LOW);
  digitalWrite(left01, LOW);
}
Mvh. Danni Hansen.

 

Offline gerd

  • µProcessoren
  • *
  • Indlæg: 898
  • Antal brugbare Indlæg: 95
    • Vis profil
    • Hjemmeside med nogle af mine projekter
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #2 Dato: August 24, 2014, 14:21:01 »
Hej Danni,

Kan du reducere det, så det er kun en "F", som bliver sendet?

Arduino nummer 1 som sender:
Kode:
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 
RF24 radio(9,10);

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

void setup(void)
{
  // Setup and configure the RF24 module
  radio.begin();

  // Open only pipe 0 for writing
  radio.openWritingPipe(pipes[0]);
}


void loop (void)
{
	char c = 'F';
	
	// Send the character 'F' via radio to the other arduino module (receiver)
	radio.write( &c, sizeof(char) );
	
	// delay 2 seconds
	delay(2000);	
}

Arduino nummer 2 som modtager. Åbn den serielle forbindelse (Arduino console) :
Kode:
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 
RF24 radio(9,10);

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

void setup(void)
{
  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24 communication\n\r");
  printf("Wait for the next character ...\n\r");

  // Setup and configure the RF24 module
  radio.begin();

  // Open only pipe 0 for reading
  radio.openReadingPipe(1,pipes[0]);

  // listen to the transmitter
  radio.startListening();
  
}


void loop (void)
{
	// Is there a new character available ? 
	if ( radio.available() )
	{
		char c;
		// Read it from the RF24 module
		radio.read( &c, sizeof(char) );
		// And send it via the serial port to the PC (Console in the Arduino IDE)
		printf("Received character:  %c \n\r",c);
	}	
}

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #3 Dato: August 24, 2014, 15:52:19 »
Hej Gerd.

Har lige prøvet det af, og det virker desværre ikke :/

Den modtager ikke.
Mvh. Danni Hansen.

 

Offline gerd

  • µProcessoren
  • *
  • Indlæg: 898
  • Antal brugbare Indlæg: 95
    • Vis profil
    • Hjemmeside med nogle af mine projekter
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #4 Dato: August 24, 2014, 16:35:38 »
hmmmm  :-\

Havde du en kode, hvor kun kommunikationen fungerede?

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #5 Dato: August 24, 2014, 20:43:25 »
Kun standart filen som jeg hentede her:

http://arduino-info.wikispaces.com/nRF24L01-RF24-Examples

Kode:
/*
 Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

/**
 * Example for Getting Started with nRF24L01+ radios. 
 *
 * This is an example of how to use the RF24 class.  Write this sketch to two 
 * different nodes.  Put one of the nodes into 'transmit' mode by connecting 
 * with the serial monitor and sending a 'T'.  The ping node sends the current 
 * time to the pong node, which responds by sending the value back.  The ping 
 * node can then see how long the whole cycle took.
 */

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//
// Hardware configuration
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

void setup(void)
{
  //
  // Print preamble
  //

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  //
  // Setup and configure rf radio
  //

  radio.begin();

  // optionally, increase the delay between retries & # of retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to
  // improve reliability
  //radio.setPayloadSize(8);

  //
  // Open pipes to other nodes for communication
  //

  // This simple sketch opens two pipes for these two nodes to communicate
  // back and forth.
  // Open 'our' pipe for writing
  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

  //if ( role == role_ping_out )
  {
    //radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
  }
  //else
  {
    //radio.openWritingPipe(pipes[1]);
    //radio.openReadingPipe(1,pipes[0]);
  }

  //
  // Start listening
  //

  radio.startListening();

  //
  // Dump the configuration of the rf unit for debugging
  //

  radio.printDetails();
}

void loop(void)
{
  //
  // Ping out role.  Repeatedly send the current time
  //

  if (role == role_ping_out)
  {
    // First, stop listening so we can talk.
    radio.stopListening();

    // Take the time, and send it.  This will block until complete
    unsigned long time = millis();
    printf("Now sending %lu...",time);
    bool ok = radio.write( &time, sizeof(unsigned long) );
    
    if (ok)
      printf("ok...");
    else
      printf("failed.\n\r");

    // Now, continue listening
    radio.startListening();

    // Wait here until we get a response, or timeout (250ms)
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;

    // Describe the results
    if ( timeout )
    {
      printf("Failed, response timed out.\n\r");
    }
    else
    {
      // Grab the response, compare, and send to debugging spew
      unsigned long got_time;
      radio.read( &got_time, sizeof(unsigned long) );

      // Spew it
      printf("Got response %lu, round-trip delay: %lu\n\r",got_time,millis()-got_time);
    }

    // Try again 1s later
    delay(1000);
  }

  //
  // Pong back role.  Receive each packet, dump it out, and send it back
  //

  if ( role == role_pong_back )
  {
    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      unsigned long got_time;
      bool done = false;
      while (!done)
      {
        // Fetch the payload, and see if this was the last one.
        done = radio.read( &got_time, sizeof(unsigned long) );

        // Spew it
        printf("Got payload %lu...",got_time);

	// Delay just a little bit to let the other unit
	// make the transition to receiver
	delay(20);
      }

      // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &got_time, sizeof(unsigned long) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
    }
  }

  //
  // Change roles
  //

  if ( Serial.available() )
  {
    char c = toupper(Serial.read());
    if ( c == 'T' && role == role_pong_back )
    {
      printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

      // Become the primary transmitter (ping out)
      role = role_ping_out;
      radio.openWritingPipe(pipes[0]);
      radio.openReadingPipe(1,pipes[1]);
    }
    else if ( c == 'R' && role == role_ping_out )
    {
      printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
      
      // Become the primary receiver (pong back)
      role = role_pong_back;
      radio.openWritingPipe(pipes[1]);
      radio.openReadingPipe(1,pipes[0]);
    }
  }
}
// vim:cin:ai:sts=2 sw=2 ft=cpp
Mvh. Danni Hansen.

 

Offline gerd

  • µProcessoren
  • *
  • Indlæg: 898
  • Antal brugbare Indlæg: 95
    • Vis profil
    • Hjemmeside med nogle af mine projekter
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #6 Dato: August 25, 2014, 17:14:39 »
Hej Danni,

ok. Start med denne kode. (http://maniacbug.github.io/RF24/GettingStarted_8pde-example.html)
Og ændre så lidt som muligt. Gå altid kun små skridt.

I denne kode er tiden sendt

Kode:
    // Take the time, and send it.  This will block until complete
    unsigned long time = millis();
    printf("Now sending %lu...",time);
    bool ok = radio.write( &time, sizeof(unsigned long) );

Ændre det og send nu en kommando. Det er nu ikke mere end bare et tegn "X".

Kode:
// The role of the current running sketch
role_e role = role_pong_back;

char command = 'X'; 

void setup(void)

Kode:
// Take the command, and send it.  This will block until complete
printf("Now sending %c...",command);
bool ok = radio.write( &command, sizeof(char) );

Kode:
// Grab the response, compare, and send to debugging spew
char got_command;
radio.read( &got_command, sizeof(char) );
 
// Spew it
printf("Got response %c \n\r",got_command);

Kan du modtage nu en 'X' ?

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #7 Dato: August 25, 2014, 22:10:35 »
Hej Gerd.

Den melder om fejl 'got_time' was not declared in this scope

så tænker på at 'got_time' skal have en declare? ved char command = 'X'; ?

fx
char got_time;

?
Mvh. Danni Hansen.

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #8 Dato: August 25, 2014, 22:16:13 »
Lavede ændringen:

char got_time;
efter
char command = 'X';
og prøvede også med:
char command = 'F';

Fik dog fejlen her:

Mvh. Danni Hansen.

 

Offline gerd

  • µProcessoren
  • *
  • Indlæg: 898
  • Antal brugbare Indlæg: 95
    • Vis profil
    • Hjemmeside med nogle af mine projekter
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #9 Dato: August 26, 2014, 18:38:11 »
Hej Danni,

Jeg glemte at returnere kommandoen...

Kode:
/*
 Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//
// Hardware configuration
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

char command = 'X'; 

void setup(void)
{
  //
  // Print preamble
  //

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  //
  // Setup and configure rf radio
  //

  radio.begin();

  // optionally, increase the delay between retries & # of retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to
  // improve reliability
  radio.setPayloadSize(8);

  //
  // Open pipes to other nodes for communication
  //

  // This simple sketch opens two pipes for these two nodes to communicate
  // back and forth.
  // Open 'our' pipe for writing
  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

  if ( role == role_ping_out )
  {
    radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
  }
  else
  {
    radio.openWritingPipe(pipes[1]);
    radio.openReadingPipe(1,pipes[0]);
  }

  //
  // Start listening
  //

  radio.startListening();

  //
  // Dump the configuration of the rf unit for debugging
  //

  radio.printDetails();
}

void loop(void)
{
  //
  // Ping out role.  Repeatedly send the current time
  //

  if (role == role_ping_out)
  {
    // First, stop listening so we can talk.
    radio.stopListening();

    // Take the command, and send it.  This will block until complete
    printf("Now sending %c...",command);
    bool ok = radio.write( &command, sizeof(char) );
    
    if (ok)
      printf("ok...");
    else
      printf("failed.\n\r");

    // Now, continue listening
    radio.startListening();

    // Wait here until we get a response, or timeout (250ms)
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;

    // Describe the results
    if ( timeout )
    {
      printf("Failed, response timed out.\n\r");
    }
    else
    {
      // Grab the response, compare, and send to debugging spew
      char got_command;
      radio.read( &got_command, sizeof(char) );
        
      // Spew it
      printf("Got response %c \n\r",got_command);
    }

    // Try again 1s later
    delay(1000);
  }

  //
  // Pong back role.  Receive each packet, dump it out, and send it back
  //

  if ( role == role_pong_back )
  {
    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      char got_command;
      bool done = false;
      while (!done)
      {
        // Fetch the payload, and see if this was the last one.
        done = radio.read( &got_command, sizeof(char) );

        // Spew it
        printf("Got payload %c...",got_command);

        // Delay just a little bit to let the other unit
        // make the transition to receiver
        delay(20);
      }

      // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &got_command, sizeof(char) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
    }
  }

  //
  // Change roles
  //

  if ( Serial.available() )
  {
    char c = toupper(Serial.read());
    if ( c == 'T' && role == role_pong_back )
    {
      printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

      // Become the primary transmitter (ping out)
      role = role_ping_out;
      radio.openWritingPipe(pipes[0]);
      radio.openReadingPipe(1,pipes[1]);
    }
    else if ( c == 'R' && role == role_ping_out )
    {
      printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
      
      // Become the primary receiver (pong back)
      role = role_pong_back;
      radio.openWritingPipe(pipes[1]);
      radio.openReadingPipe(1,pipes[0]);
    }
  }
}
// vim:cin:ai:sts=2 sw=2 ft=cpp

Der er et andet godt eksempel: Arduino IDE: Fil -> Eksempler -> RF24 ->led_remote

jeg er i denne uge i et hotel og har nu installeret Arduino IDE'en på firmaets notebook  ;)

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #10 Dato: August 26, 2014, 19:04:16 »
Hej Gerd.

Det undre mig det ikke rigtig virker, fornemmer jeg har lavet en fejl et sted?
Vil hvertfald lige se om jeg ikke kan få 'standart koden' til at fungere igen, og se om det er en ledning der sidder forkert.... :/
Mvh. Danni Hansen.

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #11 Dato: August 26, 2014, 19:16:02 »

Okay, jeg her er hvad jeg har prøvet som ikke virker:

Reciver:
Kode:
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
 
// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
RF24 radio(9,10);
 
// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
 
void setup(void)
{
  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24 communication\n\r");
  printf("Wait for the next character ...\n\r");
 
  // Setup and configure the RF24 module
  radio.begin();
 
  // Open only pipe 0 for reading
  radio.openReadingPipe(1,pipes[0]);
 
  // listen to the transmitter
  radio.startListening();
   
}
 
 
void loop (void)
{
    // Is there a new character available ?
    if ( radio.available() )
    {
        char c;
        // Read it from the RF24 module
        radio.read( &c, sizeof(char) );
        // And send it via the serial port to the PC (Console in the Arduino IDE)
        printf("Received character:  %c \n\r",c);
    }  
}

Transmitter:
Kode:
#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"
 
// Set up nRF24L01 radio on SPI bus plus pins 9 & 10
RF24 radio(9,10);
 
// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };
 
void setup(void)
{
  // Setup and configure the RF24 module
  radio.begin();
 
  // Open only pipe 0 for writing
  radio.openWritingPipe(pipes[0]);
}
 
 
void loop (void)
{
    char c = 'F';
     
    // Send the character 'F' via radio to the other arduino module (receiver)
    radio.write( &c, sizeof(char) );
     
    // delay 2 seconds
    delay(2000);   
}

Også den nye kode du gav

Kode:
/*
 Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//
// Hardware configuration
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

char command = 'X'; 

void setup(void)
{
  //
  // Print preamble
  //

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  //
  // Setup and configure rf radio
  //

  radio.begin();

  // optionally, increase the delay between retries & # of retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to
  // improve reliability
  radio.setPayloadSize(8);

  //
  // Open pipes to other nodes for communication
  //

  // This simple sketch opens two pipes for these two nodes to communicate
  // back and forth.
  // Open 'our' pipe for writing
  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

  if ( role == role_ping_out )
  {
    radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
  }
  else
  {
    radio.openWritingPipe(pipes[1]);
    radio.openReadingPipe(1,pipes[0]);
  }

  //
  // Start listening
  //

  radio.startListening();

  //
  // Dump the configuration of the rf unit for debugging
  //

  radio.printDetails();
}

void loop(void)
{
  //
  // Ping out role.  Repeatedly send the current time
  //

  if (role == role_ping_out)
  {
    // First, stop listening so we can talk.
    radio.stopListening();

    // Take the command, and send it.  This will block until complete
    printf("Now sending %c...",command);
    bool ok = radio.write( &command, sizeof(char) );
    
    if (ok)
      printf("ok...");
    else
      printf("failed.\n\r");

    // Now, continue listening
    radio.startListening();

    // Wait here until we get a response, or timeout (250ms)
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;

    // Describe the results
    if ( timeout )
    {
      printf("Failed, response timed out.\n\r");
    }
    else
    {
      // Grab the response, compare, and send to debugging spew
      char got_command;
      radio.read( &got_command, sizeof(char) );
        
      // Spew it
      printf("Got response %c \n\r",got_command);
    }

    // Try again 1s later
    delay(1000);
  }

  //
  // Pong back role.  Receive each packet, dump it out, and send it back
  //

  if ( role == role_pong_back )
  {
    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      char got_command;
      bool done = false;
      while (!done)
      {
        // Fetch the payload, and see if this was the last one.
        done = radio.read( &got_command, sizeof(char) );

        // Spew it
        printf("Got payload %c...",got_command);

        // Delay just a little bit to let the other unit
        // make the transition to receiver
        delay(20);
      }

      // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &got_command, sizeof(char) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
    }
  }

  //
  // Change roles
  //

  if ( Serial.available() )
  {
    char c = toupper(Serial.read());
    if ( c == 'T' && role == role_pong_back )
    {
      printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

      // Become the primary transmitter (ping out)
      role = role_ping_out;
      radio.openWritingPipe(pipes[0]);
      radio.openReadingPipe(1,pipes[1]);
    }
    else if ( c == 'R' && role == role_ping_out )
    {
      printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
      
      // Become the primary receiver (pong back)
      role = role_pong_back;
      radio.openWritingPipe(pipes[1]);
      radio.openReadingPipe(1,pipes[0]);
    }
  }
}
// vim:cin:ai:sts=2 sw=2 ft=cpp

Men den her kode virker uden Transmitter / Reciver, men direkte fra Arduino's IDE 'Serial Monitor'

Kode:
/*
 Copyright (C) 2011 J. Coliz <maniacbug@ymail.com>

 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 version 2 as published by the Free Software Foundation.
 */

/**
 * Example for Getting Started with nRF24L01+ radios. 
 *
 * This is an example of how to use the RF24 class.  Write this sketch to two 
 * different nodes.  Put one of the nodes into 'transmit' mode by connecting 
 * with the serial monitor and sending a 'T'.  The ping node sends the current 
 * time to the pong node, which responds by sending the value back.  The ping 
 * node can then see how long the whole cycle took.
 */

#include <SPI.h>
#include "nRF24L01.h"
#include "RF24.h"
#include "printf.h"

//
// Hardware configuration
//

// Set up nRF24L01 radio on SPI bus plus pins 9 & 10 

RF24 radio(9,10);

//
// Topology
//

// Radio pipe addresses for the 2 nodes to communicate.
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

//
// Role management
//
// Set up role.  This sketch uses the same software for all the nodes
// in this system.  Doing so greatly simplifies testing.  
//

// The various roles supported by this sketch
typedef enum { role_ping_out = 1, role_pong_back } role_e;

// The debug-friendly names of those roles
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};

// The role of the current running sketch
role_e role = role_pong_back;

int right01 = 4;
int right02 = 5;
int left01 = 6;
int left02 = 7;



void setup(void)
{
  pinMode(right01, OUTPUT);
  pinMode(right02, OUTPUT);
  pinMode(left01, OUTPUT);
  pinMode(left02, OUTPUT);
  //
  // Print preamble
  //

  Serial.begin(57600);
  printf_begin();
  printf("\n\rRF24/examples/GettingStarted/\n\r");
  printf("ROLE: %s\n\r",role_friendly_name[role]);
  printf("*** PRESS 'T' to begin transmitting to the other node\n\r");

  //
  // Setup and configure rf radio
  //

  radio.begin();

  // optionally, increase the delay between retries & # of retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to
  // improve reliability
  //radio.setPayloadSize(8);

  //
  // Open pipes to other nodes for communication
  //

  // This simple sketch opens two pipes for these two nodes to communicate
  // back and forth.
  // Open 'our' pipe for writing
  // Open the 'other' pipe for reading, in position #1 (we can have up to 5 pipes open for reading)

  //if ( role == role_ping_out )
  {
    //radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);
  }
  //else
  {
    //radio.openWritingPipe(pipes[1]);
    //radio.openReadingPipe(1,pipes[0]);
  }

  //
  // Start listening
  //

  radio.startListening();

  //
  // Dump the configuration of the rf unit for debugging
  //

  radio.printDetails();
}

void loop(void)
{
  //
  // Ping out role.  Repeatedly send the current time
  //

  if (role == role_ping_out)
  {
    // First, stop listening so we can talk.
    radio.stopListening();

    // Take the time, and send it.  This will block until complete
    unsigned long time = millis();
    printf("Now sending %lu...",time);
    bool ok = radio.write( &time, sizeof(unsigned long) );
    
    if (ok)
      printf("ok...");
    else
      printf("failed.\n\r");

    // Now, continue listening
    radio.startListening();

    // Wait here until we get a response, or timeout (250ms)
    unsigned long started_waiting_at = millis();
    bool timeout = false;
    while ( ! radio.available() && ! timeout )
      if (millis() - started_waiting_at > 200 )
        timeout = true;

    // Describe the results
    if ( timeout )
    {
      printf("Failed, response timed out.\n\r");
    }
    else
    {
      // Grab the response, compare, and send to debugging spew
      unsigned long got_time;
      radio.read( &got_time, sizeof(unsigned long) );

      // Spew it
      printf("Got response %lu, round-trip delay: %lu\n\r",got_time,millis()-got_time);
    }

    // Try again 1s later
    delay(1000);
  }

  //
  // Pong back role.  Receive each packet, dump it out, and send it back
  //

  if ( role == role_pong_back )
  {
    /*
    // if there is data ready
    if ( radio.available() )
    {
      // Dump the payloads until we've gotten everything
      unsigned long got_time;
      bool done = false;
      while (!done)
      {
        // Fetch the payload, and see if this was the last one.
        done = radio.read( &got_time, sizeof(unsigned long) );

        // Spew it
        printf("Got payload %lu...",got_time);

	// Delay just a little bit to let the other unit
	// make the transition to receiver
	delay(20);
      }

      // First, stop listening so we can talk
      radio.stopListening();

      // Send the final one back.
      radio.write( &got_time, sizeof(unsigned long) );
      printf("Sent response.\n\r");

      // Now, resume listening so we catch the next packets.
      radio.startListening();
    }
    */
  }

  //
  // Change roles
  //

  if ( Serial.available() )
  {
    /*
    int analoger = analogRead(1);
    int fremad = 4800/(analoger - 20);
    
    int analogen = analogRead(2);
    int tilbage = 4800/(analogen - 20);
    */
    char c = toupper(Serial.read());
    
    
    
    
    //F = fremad
    if ( c == 'F' && role == role_pong_back )
    {
       forwards();
    }

    //F = fremad
    if ( c == 'B' && role == role_pong_back )
    {
       backwards();
    }
    
    //F = fremad
    if ( c == 'A' && role == role_pong_back )
    {
       around();
    }


    //F = fremad
    if ( c == 'S' && role == role_pong_back )
    {
       stopper();
    }

    /*
    if ( c == 'T' && role == role_pong_back )
    {
      printf("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK\n\r");

      // Become the primary transmitter (ping out)
      role = role_ping_out;
      radio.openWritingPipe(pipes[0]);
      radio.openReadingPipe(1,pipes[1]);
    }
    else if ( c == 'R' && role == role_ping_out )
    {
      printf("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK\n\r");
      
      // Become the primary receiver (pong back)
      role = role_pong_back;
      radio.openWritingPipe(pipes[1]);
      radio.openReadingPipe(1,pipes[0]);
    }
    */
  }
}
// vim:cin:ai:sts=2 sw=2 ft=cpp


void forwards(){
  digitalWrite(right02, LOW);
  digitalWrite(right01, HIGH);
  digitalWrite(left02, LOW);
  digitalWrite(left01, HIGH);  
}

void backwards(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, HIGH);
  digitalWrite(left01, LOW);
  digitalWrite(left02, HIGH);
}

void around(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, HIGH);
  digitalWrite(left02, LOW);
  digitalWrite(left01, HIGH);
  
}

void stopper(){
  digitalWrite(right01, LOW);
  digitalWrite(right02, LOW);
  digitalWrite(left02, LOW);
  digitalWrite(left01, LOW);
}

Så jeg er meget forvirret. :/
Jeg har forresten også forsøgt med det led lib du snakkede om :/ Mener jeg heller ikke virkede? Kan prøve det af engang igen.
Mvh. Danni Hansen.

 

Offline gerd

  • µProcessoren
  • *
  • Indlæg: 898
  • Antal brugbare Indlæg: 95
    • Vis profil
    • Hjemmeside med nogle af mine projekter
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #12 Dato: August 26, 2014, 19:27:39 »
Citér
Vil hvertfald lige se om jeg ikke kan få 'standart koden' til at fungere igen, og se om det er en ledning der sidder forkert.... :/

Eller mangler en kondensator?
RF24 transmit problem

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #13 Dato: August 28, 2014, 08:52:25 »
Æv, det går da godt nok ned af bakken med det her projekt.

Jeg har tilføjet 4.7uF på begge nRF24l01, via et breadboard, mit setup ser rigtigt ud, og alligevel virker det ikke. Selv med standart sketchen..

Kan jeg have sat nogle pins forkert? Kan man måle det?
Mvh. Danni Hansen.

 

Offline Danni-Hansen

  • µProcessoren
  • *
  • Indlæg: 544
  • Antal brugbare Indlæg: 17
    • Vis profil
Sv: RC bil med nRF24l1 ping/pong problemer
« Svar #14 Dato: August 28, 2014, 09:17:26 »
Hej Gerd.

Nu virker det, vha flg. link:
http://elektronik-forum.dk/index.php?topic=756.msg4534#msg4534

Setup var forkert, og skulle sættes op sådan her:
http://elektronik-forum.dk/index.php?action=dlattach;topic=756.0;attach=550;image

Og jeg testede GettingStarted koden af, og jeg får både send og response.

Nu er jeg så 'bare' i tvivl om hvordan jeg skal lave koden til at sende og modtage 'køre info'
Mvh. Danni Hansen.