Hello people,
I am sending values from a pot between two XBee's via serial communication. So far, I can not seem to send a stream of values that are sequential. The transmission becomes latent unless I reduce the number of values sent over the air thus reducing the resolution.
The problem I am having is audible stepping when printing these values to a DAC or a digital pot. I need to fill in the missing values between what has been read in real-time. I see that this is something that is common with MIDI controller readings.
What I have is
<0>
<4>
<13>
<27>
etc
and what I need to send to the digital pot/DAC is
<0>
<1>
<2>
<3>
<4>
<5>
etc.
It would like to use a 10 bit pot but 8 bit would work. I'm not sure if smoothing mitigates this. ?
Thanks in advance if you get a minute to look at this. All help appreciated!
Here is my complete code.
#include <SPI.h>
#include <DAC_MCP49x1.h>
#define SS_PIN 10 // The Arduino pin used for the slave select / chip select
// Set up the DAC.
// First argument: model (MCP4901, MCP4911, MCP4921)
// Second argument: SS pin (10 is preferred)
// (The third argument, the LDAC pin, can be left out if not used)
DAC_MCP49x1 dac(DAC_MCP49x1::MCP4911, SS_PIN);
//Constants
const int comPin = 3; //Led to Arduino pin 3 (PWM) Shows Pedal Value
const int buttonPin = 2; // the number of the pushbutton pin
const int redPin = 4; // the number of the LED pin
const int relayPin = 7; //signal out to relay
const int xbstatePin = 9; //copy of toe switch LED for XBee line passing pin state
//byte switchPin = 5; //Code Toggle - not used here
//boolean switchState;
//Variables
int ledState = LOW; // the current state of the output pin
int buttonState; // the current reading from the input pin
int lastButtonState = LOW; // the previous reading from the input pin
// the following variables are unsigned longs because the time, measured in
// milliseconds, will quickly become a bigger number than can be stored in an int.
unsigned long lastDebounceTime = 0; // the last time the output pin was toggled
unsigned long debounceDelay = 50; // the debounce time; increase if the output flickers
bool started = false; //True: Message is started
bool ended = false; //True: Message is finished
char incomingByte ; //Variable to store the incoming byte
char msg[3]; //Message - array from 0 to 2 (3 values - PWM - e.g. 240) 4 places now!!!
byte index; //Index of array
void setup() {
//Start the serial communication
Serial.begin(115200); //Baud rate must be the same as is on xBee module
pinMode(comPin, OUTPUT); // Yellow LED
pinMode(redPin, OUTPUT); // Switch LED OUTPUT
pinMode(xbstatePin, OUTPUT); //same as redPin
pinMode(relayPin, OUTPUT); // RELAY OUT
pinMode(buttonPin, INPUT);
//pinMode(switchPin, INPUT_PULLUP);
dac.output(0);
// Set the SPI frequency to 1 MHz (on 16 MHz Arduinos), to be safe.
// DIV2 = 8 MHz works for me, though, even on a breadboard.
// This is not strictly required, as there is a default setting.
//dac.setSPIDivider(SPI_CLOCK_DIV2);
// Use "port writes", see the manual page. In short, if you use pin 10 for
// SS (and pin 7 for LDAC, if used), this is much faster.
// Also not strictly required (no setup() code is needed at all).
dac.setPortWrite(true);
}
void loop(){
while (Serial.available()>0) {
//Read the incoming byte
incomingByte = Serial.read();
//Start the message when the '<' symbol is received
if (incomingByte == '<')
{
started = true;
index = 0;
msg[index] = '\0'; // Throw away any incomplete packet
}
//End the message when the '>' symbol is received
else if (incomingByte == '>')
{
ended = true;
break; // Done reading - exit from while loop!
}
//Read the message!
else
{
if (index < 4) // Make sure there is room
{
msg[index] = incomingByte; // Add char to array
index++;
msg[index] = '\0'; // Add NULL to end
}
}
}
if (started && ended)
{
int value = atoi(msg);
//int value;
analogWrite(comPin, value);
index = 0;
msg[index] = '\0';
started = false;
ended = false;
Serial.print('<');
Serial.print(value);
Serial.println('>');
Serial.flush();
dac.output(value); // Send 0-255 to DAC
}
{
// read the state of the switch into a local variable:
int reading = digitalRead(buttonPin);
// check to see if you just pressed the button
// (i.e. the input went from LOW to HIGH), and you've waited long enough
// since the last press to ignore any noise:
// If the switch changed, due to noise or pressing:
if (reading != lastButtonState) {
// reset the debouncing timer
lastDebounceTime = millis();
}
if ((millis() - lastDebounceTime) > debounceDelay) {
// whatever the reading is at, it's been there for longer than the debounce
// delay, so take it as the actual current state:
// if the button state has changed:
if (reading != buttonState) {
buttonState = reading;
// only toggle the LED if the new button state is HIGH
if (buttonState == HIGH) {
ledState = !ledState;
}
}
}
}
{
buttonState = digitalRead(buttonPin);
if (buttonState == HIGH) {
digitalWrite (relayPin, HIGH);
digitalWrite (redPin, HIGH);
digitalWrite (xbstatePin, HIGH);
}
else
{
digitalWrite (relayPin, LOW);
digitalWrite (redPin, LOW);
digitalWrite (xbstatePin, LOW);
}
}
}
