# Need programming help!

**URL:** <https://community.sparkfun.com/t/need-programming-help/19210>\
**Category:** Arduino\
**Created:** [January 31, 2011, 9:53am UTC](https://community.sparkfun.com/t/need-programming-help/19210 "2011-01-31T09:53:04Z")\
**Posts on this page:** 4\
**Page:** 1

<div class="post-metadata">

**Author:** ![Si-u2](https://avatars.discourse-cdn.com/v4/letter/s/a3d4f5/32.png) [@Si-u2](https://community.sparkfun.com/u/Si-u2)\
**Post date:** [January 31, 2011, 9:53am UTC](https://community.sparkfun.com/t/need-programming-help/19210/1 "2011-01-31T09:53:04Z")

</div>

Hello guys!

I have two WiFly shields on the Ardunio Uno Board. Both operate in the AdHoc mode. On one board I placed two buttons and two LED. When a button is pressed, the corresponding LED. This is sent via UDP to the other module. The program code of the transmitter:

```auto
#include <string.h>

// SC16IS750 Register definitions
#define THR 0x00 << 3
#define RHR 0x00 << 3
#define IER 0x01 << 3
#define FCR 0x02 << 3
#define IIR 0x02 << 3
#define LCR 0x03 << 3
#define MCR 0x04 << 3
#define LSR 0x05 << 3
#define MSR 0x06 << 3
#define SPR 0x07 << 3
#define TXFIFO 0x08 << 3
#define RXFIFO 0x09 << 3
#define DLAB 0x80 << 3
#define IODIR 0x0A << 3
#define IOSTATE 0x0B << 3
#define IOINTMSK 0x0C << 3
#define IOCTRL 0x0E << 3
#define EFCR 0x0F << 3

#define DLL 0x00 << 3
#define DLM 0x01 << 3
#define EFR 0x02 << 3
#define XON1 0x04 << 3  
#define XON2 0x05 << 3
#define XOFF1 0x06 << 3
#define XOFF2 0x07 << 3

// SPI Pin definitions
#define CS 10
#define MOSI 11
#define MISO 12
#define SCK 13

#define ASSOCIATE_TIMEOUT 5000

// Global variables
char incoming_data; 
char TX_Fifo_Address = THR; 

int i = 0;
int j = 0;
int k = 0;
char clr = 0;
char polling = 0;

// SC16IS750 register values
struct SPI_UART_cfg
{
  char DivL,DivM,DataFormat,Flow;
};

struct SPI_UART_cfg SPI_Uart_config = 
{ 0x60,0x00,0x03,0x10};

// PIN Belegung
int SW1 = 2; // grüner Taster auf PIN 2 - AUF
int SW2 = 3; // roter Taster auf PIN 3 - ZU
int LED_gruen = 4; // grüne LED auf PIN 4 - AUF
int LED_rot = 5; // rote LED auf PIN 5 - ZU

// Ausgangszustand der Taste
int SW1prev = 0;
int SW2prev = 0;

// Zustand der Taster nach einer Aktion
int SW1value;
int SW2value;

void setup() 
{
 
  // Initialize SPI pins
  pinMode(MOSI, OUTPUT);
  pinMode(MISO, INPUT);
  pinMode(SCK,OUTPUT);
  pinMode(CS,OUTPUT);
  digitalWrite(CS,HIGH); //disable device 

  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(1<<SPR0);
  clr=SPSR;
  clr=SPDR;
  delay(10); 
  
  
   // LED`s als Output
  pinMode(LED_gruen, OUTPUT); 
  pinMode(LED_rot, OUTPUT);
  
  // grüner Taster als Input und auf High gesetzt
  pinMode(SW1, INPUT); 
  digitalWrite(SW1, HIGH); // SW1 = 1
  
  // roter Taster als Input und auf High gesetzt
  pinMode(SW2, INPUT);
  digitalWrite(SW2, HIGH); // SW2 = 1

      // grüne LED Test - ein mal blinken
  digitalWrite(LED_gruen, HIGH);
  delay(1000);
  digitalWrite(LED_gruen, LOW);
  
  // rote LED Test - ein mal blinken
  digitalWrite(LED_rot, HIGH);  
  delay(1000);
  digitalWrite(LED_rot, LOW);
  
  Serial.begin(9600); // Baudrate
  
  Serial.println(" WiFly 1 - UDP Uebertragung ");
  Serial.println("--------------------------------------------------");
  Serial.println();
  
  Serial.println("Baudrate: 9600");
  Serial.println();
  
  // Initalisierung und testen von SC16IS750
  if(SPI_Uart_Init()) //Methodenaufruf
  { 
    Serial.println("Bridge erfolgreich initialisiert!"); 
  }
  else
  { 
    Serial.println("Bridge konnte nicht initialisert werden, blockieren.\n\r"); 
    while(1); 
  }

  //Methodenaufruf
  autoconnect(); // AdHoc Netzaufbau
   
  SW1value = digitalRead(SW1);
  Serial.println(SW1value);
  
  //SW2value = digitalRead(SW2);
  Serial.println(digitalRead(SW2));
} // setup Ende

void loop()
{
  //SW1prev = 0
  //SW1value = 0
  
 SW1value = digitalRead(SW1);
  
 // SW1prev = SW1value;
  while(SW1prev = SW1value)
  {
    if(SW1value == 1)
    {
      select();
      spi_transfer(0x00); // Transmit command
      spi_transfer('A');
      deselect();
  // SPI_Uart_println("AAAA");
      Serial.println("A");
      digitalWrite(LED_gruen, HIGH);
      delay(2000);           
      digitalWrite(LED_gruen, LOW);
      SW1value = 0;
    }
 
  SW2value = digitalRead(SW2);
  
 // SW2prev = SW2value;
  while(SW2prev = SW2value)
  {
    if(SW2value == 1)
    {
      select();
      spi_transfer(0x00); // Transmit command
      spi_transfer('Z');
      deselect();
// SPI_Uart_println("ZZZZ");
      Serial.println("Z");
      digitalWrite(LED_rot, HIGH);
      delay(2000);           
      digitalWrite(LED_rot, LOW);
      SW2value = 0;
    }
  } 
    
  // Terminal routine
  if(SPI_Uart_ReadByte(LSR) & 0x01) // Incoming data
  { 
    polling = 1;
    i = 0;   
    while(polling)
    {     
      if((SPI_Uart_ReadByte(LSR) & 0x01))
      {
        incoming_data = SPI_Uart_ReadByte(RHR);
        Serial.print(incoming_data,BYTE);
        //Serial.print(incoming_data, HEX);
        //Serial.print(" ");
      }  
      else
      {
        polling = 0;
      }
    }
  }
  else if(Serial.available()) // Outgoing data
  {
    incoming_data = Serial.read();
    select();
    spi_transfer(0x00); // Transmit command
    spi_transfer(incoming_data);
    deselect();
  }
  
} // loop Ende

void select(void) //Methode
{
  digitalWrite(CS,LOW);
}

void deselect(void) //Methode
{
  digitalWrite(CS,HIGH);
}

char SPI_Uart_Init(void) // Initialize and test SC16IS750 //Methode
{
  char data = 0;

  SPI_Uart_WriteByte(LCR,0x80); // 0x80 to program baudrate
  SPI_Uart_WriteByte(DLL,SPI_Uart_config.DivL); //0x50 = 9600 with Xtal = 12.288MHz
  SPI_Uart_WriteByte(DLM,SPI_Uart_config.DivM); 

  SPI_Uart_WriteByte(LCR, 0xBF); // access EFR register
  SPI_Uart_WriteByte(EFR, SPI_Uart_config.Flow); // enable enhanced registers
  SPI_Uart_WriteByte(LCR, SPI_Uart_config.DataFormat); // 8 data bit, 1 stop bit, no parity
  SPI_Uart_WriteByte(FCR, 0x06); // reset TXFIFO, reset RXFIFO, non FIFO mode
  SPI_Uart_WriteByte(FCR, 0x01); // enable FIFO mode

  // Perform read/write test to check if UART is working
  SPI_Uart_WriteByte(SPR,'H');
  data = SPI_Uart_ReadByte(SPR);

  if(data == 'H')
  { 
    return 1; 
  }
  else
  { 
    return 0; 
  }

}

void SPI_Uart_WriteByte(char address, char data) //Methode
// Write <data> byte to SC16IS750 register <address>
{
  long int length;
  char senddata[2];
  senddata[0] = address;
  senddata[1] = data;

  select();
  length = SPI_Write(senddata, 2);
  deselect();
}

long int SPI_Write(char* srcptr, long int length) //Methode
// Write string to SC16IS750
{
  for(long int i = 0; i < length; i++)
  {
    spi_transfer(srcptr[i]);
  }
  return length; 
}

void SPI_Uart_WriteArray(char *data, long int NumBytes) //Methode
// Write string to SC16IS750 THR
{
  long int length;
  select();
  length = SPI_Write(&TX_Fifo_Address,1);

  while(NumBytes > 16)
  {
    length = SPI_Write(data,16);
    NumBytes -= 16;
    data += 16;
  }
  length = SPI_Write(data,NumBytes);

  deselect();
}

char SPI_Uart_ReadByte(char address) //Methode
// Read byte from SC16IS750 register at <address>
{
  char data;

  address = (address | 0x80);

  select();
  spi_transfer(address);
  data = spi_transfer(0xFF);
  deselect();
  return data;  
}

char autoconnect(void) //Methode
{
  // Exit command mode if we haven't already
  SPI_Uart_println("");  
  SPI_Uart_println("exit");
  delay(500);

  // Enter command mode 
  SPI_Uart_print("$$");
  delay(500);

  // Reboot to get device into known state
  Serial.println();
  Serial.println("Rebooting");
  SPI_Uart_println("reboot");
  delay(3000);
  
  Serial.println("ready");

}

void Flush_RX(void) //Methode
// Flush characters from SC16IS750
{
  int j = 0;
  while(j < 1000)
  {
    if((SPI_Uart_ReadByte(LSR) & 0x01))
    {
      incoming_data = SPI_Uart_ReadByte(RHR);
    }  
    else
    {
      j++;
    }
  }
}

 
char Wait_On_Response_Char(char num) //Methode
// Wait for incoming char number <num> and return it
{
  i = 1;
  while(1)
  {
    if((SPI_Uart_ReadByte(LSR) & 0x01))
    {
      incoming_data = SPI_Uart_ReadByte(RHR);
      //Serial.print(incoming_data, BYTE);
      if(i == num){ 
        return incoming_data; 
      }
      else{ 
        i++; 
      }
    }  
  }
}

void SPI_Uart_println(char *data) //Methode
// Write array to SC16IS750 followed by a carriage return
{
  SPI_Uart_WriteArray(data,strlen(data));
  SPI_Uart_WriteByte(THR, 0x0d);
}

void SPI_Uart_print(char *data) //Methode
// Routine to write array to SC16IS750 using strlen instead of hardcoded length
{
  SPI_Uart_WriteArray(data,strlen(data));
}

 
char spi_transfer(volatile char data) //Methode
{
  SPDR = data; // Start the transmission
  while (!(SPSR & (1<<SPIF))) // Wait for the end of the transmission
  {
  };
  return SPDR; // return the received byte
}

```

Sending work. I can look in the data mode, the receiver also that arrive “A” or “Z”. I would like to read this incoming data and process and thereby make the respective LED lights. The program that I wrote, it does not, unfortunately:

```auto
#include <string.h>

// SC16IS750 Register definitions
#define THR 0x00 << 3
#define RHR 0x00 << 3
#define IER 0x01 << 3
#define FCR 0x02 << 3
#define IIR 0x02 << 3
#define LCR 0x03 << 3
#define MCR 0x04 << 3
#define LSR 0x05 << 3
#define MSR 0x06 << 3
#define SPR 0x07 << 3
#define TXFIFO 0x08 << 3
#define RXFIFO 0x09 << 3
#define DLAB 0x80 << 3
#define IODIR 0x0A << 3
#define IOSTATE 0x0B << 3
#define IOINTMSK 0x0C << 3
#define IOCTRL 0x0E << 3
#define EFCR 0x0F << 3

#define DLL 0x00 << 3
#define DLM 0x01 << 3
#define EFR 0x02 << 3
#define XON1 0x04 << 3  
#define XON2 0x05 << 3
#define XOFF1 0x06 << 3
#define XOFF2 0x07 << 3

// SPI Pin definitions
#define CS 10
#define MOSI 11
#define MISO 12
#define SCK 13

#define ASSOCIATE_TIMEOUT 5000

// Global variables
char incoming_data; 
char TX_Fifo_Address = THR; 

int i = 0;
int j = 0;
int k = 0;
char clr = 0;
char polling = 0;

// SC16IS750 register values
struct SPI_UART_cfg
{
  char DivL,DivM,DataFormat,Flow;
};

struct SPI_UART_cfg SPI_Uart_config = 
{ 0x60,0x00,0x03,0x10};

// PIN Belegung
int LED_gruen = 4; // grüne LED auf PIN 4 - AUF
int LED_rot = 5; // rote LED auf PIN 5 - ZU

void setup() 
{
 
  // Initialize SPI pins
  pinMode(MOSI, OUTPUT);
  pinMode(MISO, INPUT);
  pinMode(SCK,OUTPUT);
  pinMode(CS,OUTPUT);
  digitalWrite(CS,HIGH); //disable device 

  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1)|(1<<SPR0);
  clr=SPSR;
  clr=SPDR;
  delay(10); 
  
  
   // LED`s als Output
  pinMode(LED_gruen, OUTPUT); 
  pinMode(LED_rot, OUTPUT);

  // grüne LED Test - ein mal blinken
  digitalWrite(LED_gruen, HIGH);
  delay(1000);
  digitalWrite(LED_gruen, LOW);
  
  // rote LED Test - ein mal blinken
  digitalWrite(LED_rot, HIGH);  
  delay(1000);
  digitalWrite(LED_rot, LOW);
  

  Serial.begin(9600); // Baudrate
  
  Serial.println(" WiFly 2 - UDP Uebertragung ");
  Serial.println("--------------------------------------------------");
  Serial.println();
  
  Serial.println("Baudrate: 9600");
  Serial.println();
  
  // Initalisierung und testen von SC16IS750
  if(SPI_Uart_Init()) //Methodenaufruf
  { 
    Serial.println("Bridge erfolgreich initialisiert!"); 
  }
  else
  { 
    Serial.println("Bridge konnte nicht initialisert werden, blockieren.\n\r"); 
    while(1); 
  }

  
  autoconnect(); //Methodenaufruf
 
} // setup Ende

void loop()
{
  char cmd;

   if(SPI_Uart_ReadByte(LSR) & 0x01) // Incoming data
   {
      
    cmd = SPI_Uart_ReadByte(RHR);
    Serial.println( cmd);
    Serial.println();
   
    if(cmd == 'A')
    {
       Serial.println("A");
       digitalWrite(LED_gruen, HIGH);
       delay(2000);                    
       digitalWrite(LED_gruen, LOW);
    }          
  
    if(cmd == 'Z')
    {
      Serial.println("Z");
      digitalWrite(LED_rot, HIGH);   
      delay(2000);                  
      digitalWrite(LED_rot, LOW); 
    }
    
    
    // Terminal routine
    polling = 1;
    i = 0;
    while(polling)
    {
      if((SPI_Uart_ReadByte(LSR) & 0x01))
      {
        incoming_data = SPI_Uart_ReadByte(RHR);
        Serial.print(incoming_data,BYTE);
        //Serial.print(incoming_data, HEX);
        //Serial.print(" ");
      }  
      else
      {
        polling = 0;
      }
    }

  }
  else if(Serial.available()) // Outgoing data
  {
    incoming_data = Serial.read();
    select();
    spi_transfer(0x00); // Transmit command
    spi_transfer(incoming_data);
    deselect();
  }
 
} // loop Ende

void select(void) //Methode
{
  digitalWrite(CS,LOW);
}

void deselect(void) //Methode
{
  digitalWrite(CS,HIGH);
}

char SPI_Uart_Init(void) // Initialize and test SC16IS750 //Methode
{
  char data = 0;

  SPI_Uart_WriteByte(LCR,0x80); // 0x80 to program baudrate
  SPI_Uart_WriteByte(DLL,SPI_Uart_config.DivL); //0x50 = 9600 with Xtal = 12.288MHz
  SPI_Uart_WriteByte(DLM,SPI_Uart_config.DivM); 

  SPI_Uart_WriteByte(LCR, 0xBF); // access EFR register
  SPI_Uart_WriteByte(EFR, SPI_Uart_config.Flow); // enable enhanced registers
  SPI_Uart_WriteByte(LCR, SPI_Uart_config.DataFormat); // 8 data bit, 1 stop bit, no parity
  SPI_Uart_WriteByte(FCR, 0x06); // reset TXFIFO, reset RXFIFO, non FIFO mode
  SPI_Uart_WriteByte(FCR, 0x01); // enable FIFO mode

  // Perform read/write test to check if UART is working
  SPI_Uart_WriteByte(SPR,'H');
  data = SPI_Uart_ReadByte(SPR);

  if(data == 'H')
  { 
    return 1; 
  }
  else
  { 
    return 0; 
  }

}

void SPI_Uart_WriteByte(char address, char data) //Methode
// Write <data> byte to SC16IS750 register <address>
{
  long int length;
  char senddata[2];
  senddata[0] = address;
  senddata[1] = data;

  select();
  length = SPI_Write(senddata, 2);
  deselect();
}

long int SPI_Write(char* srcptr, long int length) //Methode
// Write string to SC16IS750
{
  for(long int i = 0; i < length; i++)
  {
    spi_transfer(srcptr[i]);
  }
  return length; 
}

void SPI_Uart_WriteArray(char *data, long int NumBytes) //Methode
// Write string to SC16IS750 THR
{
  long int length;
  select();
  length = SPI_Write(&TX_Fifo_Address,1);

  while(NumBytes > 16)
  {
    length = SPI_Write(data,16);
    NumBytes -= 16;
    data += 16;
  }
  length = SPI_Write(data,NumBytes);

  deselect();
}

char SPI_Uart_ReadByte(char address) //Methode
// Read byte from SC16IS750 register at <address>
{
  char data;

  address = (address | 0x80);

  select();
  spi_transfer(address);
  data = spi_transfer(0xFF);
  deselect();
  return data;  
}

char autoconnect(void) //Methode
{
  // Exit command mode if we haven't already
  SPI_Uart_println("");  
  SPI_Uart_println("exit");
  delay(500);

  // Enter command mode 
  SPI_Uart_print("$$");
  delay(500);

  // Reboot to get device into known state
  Serial.println();
  Serial.println("Rebooting");
  SPI_Uart_println("reboot");
  delay(3000);
  
  Serial.println();
}

void Flush_RX(void) //Methode
// Flush characters from SC16IS750
{
  int j = 0;
  while(j < 1000)
  {
    if((SPI_Uart_ReadByte(LSR) & 0x01))
    {
      incoming_data = SPI_Uart_ReadByte(RHR);
    }  
    else
    {
      j++;
    }
  }
}

 
char Wait_On_Response_Char(char num) //Methode
// Wait for incoming char number <num> and return it
{
  i = 1;
  while(1)
  {
    if((SPI_Uart_ReadByte(LSR) & 0x01))
    {
      incoming_data = SPI_Uart_ReadByte(RHR);
      //Serial.print(incoming_data, BYTE);
      if(i == num){ 
        return incoming_data; 
      }
      else{ 
        i++; 
      }
    }  
  }
}

void SPI_Uart_println(char *data) //Methode
// Write array to SC16IS750 followed by a carriage return
{
  SPI_Uart_WriteArray(data,strlen(data));
  SPI_Uart_WriteByte(THR, 0x0d);
}

void SPI_Uart_print(char *data) //Methode
// Routine to write array to SC16IS750 using strlen instead of hardcoded length
{
  SPI_Uart_WriteArray(data,strlen(data));
}

 
char spi_transfer(volatile char data) //Methode
{
  SPDR = data; // Start the transmission
  while (!(SPSR & (1<<SPIF))) // Wait for the end of the transmission
  {
  };
  return SPDR; // return the received byte
}

```

I’m stumped, maybe I can have someone help you by!

Thank you!

---

<div class="post-metadata">

**Author:** ![stevech](https://avatars.discourse-cdn.com/v4/letter/s/ba8739/32.png) [@stevech](https://community.sparkfun.com/u/stevech)\
**Post date:** [February 1, 2011, 3:25am UTC](https://community.sparkfun.com/t/need-programming-help/19210/2 "2011-02-01T03:25:03Z")

</div>

what is not working correctly?

before we pore over this code.

---

<div class="post-metadata">

**Author:** ![Si-u2](https://avatars.discourse-cdn.com/v4/letter/s/a3d4f5/32.png) [@Si-u2](https://community.sparkfun.com/u/Si-u2)\
**Post date:** [February 1, 2011, 1:01pm UTC](https://community.sparkfun.com/t/need-programming-help/19210/3 "2011-02-01T13:01:21Z")

</div>

the read of the register and the data processing does not work

---

<div class="post-metadata">

**Author:** ![mckinnley.workman](https://avatars.discourse-cdn.com/v4/letter/m/45deac/32.png) [@mckinnley.workman](https://community.sparkfun.com/u/mckinnley.workman)\
**Post date:** [June 8, 2011, 7:08pm UTC](https://community.sparkfun.com/t/need-programming-help/19210/4 "2011-06-08T19:08:52Z")

</div>

I was reading over your post and am trying to get WiFly to connect over an adhoc network using UDP which is similar to your project. Did you have success communicating over an adhoc network?

~McK