Lab_NHMFL
/
seekat-ad5780
Archived
1
0
Fork 0
Code Projects Releases Wiki Activity

init

This commit is contained in:
Peter McGoron 2021-05-27 21:06:29 -04:00
commit d487fdd81b
1 changed files with 385 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

385
seekat-ad5780.ino Normal file
View File

@ -0,0 +1,385 @@
//Ardunio *DUE*code for controlling EVAL-AD5780
//Created by Carlos Kometter
/////////////CHANGELOG//////////////////
//v3- 5/20/2016 If a DAC does not intilizies, normalmode() is recall until everysingle dac is initilized.
//v4- 6/15/2016 Initializes dacs durin power up
/////////////////////////////////
#include <vector>
#include "SPI.h" // necessary library for SPI communication
int ldac = 11;
int led = 30;
int data = 32;
int dac[4] = {4, 10, 12, 52};
const int Noperations = 8;
String operations[Noperations] = {"NOP", "INITIALIZE", "SET", "GET_DAC", "RAMP1", "RAMP2", "*IDN?", "RDY?"}; //NOP, *IDN?, *RDY? RAMP
int initialized = 0;
namespace std {
void __throw_bad_alloc()
{
Serial.println("Unable to allocate memory");
}
void __throw_length_error( char const*e )
{
Serial.print("Length Error :");
Serial.println(e);
}
}
void setup()
{
Serial.begin(115200);
while (! Serial);
pinMode(ldac,OUTPUT);
digitalWrite(ldac,LOW); //Load DAC pin for DAC. Make it LOW if not in use.
pinMode(led,OUTPUT);
digitalWrite(led,HIGH);
for(int i =0; i <= 3; i++)
{
pinMode(dac[i],OUTPUT);
digitalWrite(dac[i],HIGH);
}
SPI.begin();
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(84);
SPI.setDataMode(SPI_MODE1);
}
int indexOfOperation(String operation)
{
for(int index = 0; index < Noperations; index++)
{
if(operations[index] == operation)
{
return index;
}
}
return 0;
}
int threeByteToInt(byte DB1,byte DB2, byte DB3) // This gives a 16 bit integer (between +/- 2^16)
{
return ((int)(((((DB1&15)<<8)| DB2)<<8)|DB3)>>2);
}
void intToThreeBytes(int decimal, byte *DB1, byte *DB2, byte *DB3)
{
*DB1 = (byte)((decimal >> 14) | 16);
*DB2 = (byte)((decimal >> 6) & 0xFF);
*DB3 = (byte)((decimal & 0x3F) << 2);
}
float threeByteToVoltage(byte DB1, byte DB2, byte DB3)
{
int decimal;
float voltage;
decimal = threeByteToInt(DB1,DB2,DB3);
if (decimal <= 131071)
{
voltage = decimal*10.0/131071;
}
else
{
voltage = -(262144-decimal)*10.0/131072;
}
return voltage;
}
void voltageToDecimal(float voltage, byte *DB1, byte *DB2, byte *DB3)
{
int decimal;
if (voltage >= 0)
{
decimal = voltage*131071/10;
}
else
{
decimal = voltage*131072/10 + 262144;
}
intToThreeBytes(decimal, DB1, DB2, DB3);
}
float setValue(int channelDAC, float voltage)
{
byte b1;
byte b2;
byte b3;
voltageToDecimal(voltage, &b1, &b2, &b3);
digitalWrite(data, HIGH);
digitalWrite(channelDAC,LOW);
SPI.transfer(b1); // send command byte to DAC
SPI.transfer(b2); // MS data bits, DAC2
SPI.transfer(b3); //LS 8 data bits, DAC2
digitalWrite(channelDAC,HIGH);
digitalWrite(data, LOW);
return threeByteToVoltage(b1,b2,b3);
}
float writeDAC(int dacChannel, float voltage)
{
switch( dacChannel )//uses the first byte choose what to do. 0x00: set DACS with asynchronous update
{
case 0: // Write DAC;
return setValue(dac[0],voltage);
break;
case 1:
return setValue(dac[1],voltage);
break;
case 2:
return setValue(dac[2],voltage);
break;
case 3:
return setValue(dac[3],voltage);
break;
default:
break;
}
}
void autoRamp1(std::vector<String> DB)
{
float v1 = DB[2].toFloat();
float v2 = DB[3].toFloat();
int nSteps = DB[4].toInt();
int dacChannel=DB[1].toInt();
for (int j=0; j<nSteps;j++)
{
int timer = micros();
writeDAC(dacChannel, v1+(v2-v1)*j/(nSteps-1));
while(micros() <= timer + DB[5].toInt());
}
}
void autoRamp2(std::vector<String> DB)
{
float vi1 = DB[3].toFloat();
float vi2 = DB[4].toFloat();
float vf1 = DB[5].toFloat();
float vf2 = DB[6].toFloat();
int nSteps = DB[7].toInt();
byte b1;
byte b2;
int dacChannel1=DB[1].toInt();
int dacChannel2=DB[2].toInt();
for (int j=0; j<nSteps;j++)
{
int timer = micros();
writeDAC(dacChannel1, vi1+(vf1-vi1)*j/(nSteps-1));
writeDAC(dacChannel2, vi2+(vf2-vi2)*j/(nSteps-1));
while(micros() <= timer + DB[8].toInt());
}
}
void readControl(int channelDAC)
{
int o1;
int o2;
int o3;
digitalWrite(channelDAC,LOW);
SPI.transfer(160); // send command byte to DAC
SPI.transfer(0); // MS data bits, DAC2
SPI.transfer(0);//LS 8 data bits, DAC2
digitalWrite(channelDAC,HIGH);
delayMicroseconds(3);
digitalWrite(channelDAC,LOW);
o1 = SPI.transfer(0);
o2 = SPI.transfer(0);
o3 = SPI.transfer(0);
digitalWrite(channelDAC,HIGH);
Serial.write(o1);
Serial.write(o1);
Serial.write(o1);
}
void readDAC(int channelDAC)
{
int o1;
int o2;
int o3;
float voltage;
digitalWrite(channelDAC,LOW);
SPI.transfer(144); // send command byte to DAC
SPI.transfer(0); // MS data bits, DAC2
SPI.transfer(0);//LS 8 data bits, DAC2
digitalWrite(channelDAC,HIGH);
delayMicroseconds(1);
digitalWrite(channelDAC,LOW);
o1 = SPI.transfer(0);
o2 = SPI.transfer(0);
o3 = SPI.transfer(0);
digitalWrite(channelDAC,HIGH);
voltage = threeByteToVoltage(o1, o2, o3);
Serial.println(voltage,4);
}
void normalMode()
{
int attemps = 0;
for( int i = 0; i <= 3; i++)
{
int o;
setValue(dac[i],0);
digitalWrite(dac[i],LOW);
SPI.transfer(32);
SPI.transfer(0);
SPI.transfer(2);
digitalWrite(dac[i],HIGH);
digitalWrite(dac[i],LOW);
SPI.transfer(160);
SPI.transfer(0);
SPI.transfer(0);
digitalWrite(dac[i],HIGH);
delayMicroseconds(1);
digitalWrite(dac[i],LOW);
SPI.transfer(0);
SPI.transfer(0);
o = SPI.transfer(0);
digitalWrite(dac[i],HIGH);
if (attemps>=5)
{
Serial.print("ERROR INITIALIZING DAC");
Serial.println(i);
}
else if (o!=2)
{
i=i-1;
attemps++;
}
}
}
void ID()
{
Serial.println("DCBOX_QUAD_AD5780(DOGWOOD)");
}
void RDY()
{
Serial.println("READY");
}
void debug()
{
digitalWrite(led,HIGH);
delay(3000);
digitalWrite(led,LOW);
delay(3000);
}
void router(std::vector<String> DB)
{
int operation = indexOfOperation(DB[0]);
switch( operation )//uses the first byte choose what to do. 0x00: set DACS with asynchronous update
{
case 0:
Serial.println("NOP");
break;
case 1: // Write DAC;
normalMode();
Serial.println("INITIALIZATION COMPLETE");
break;
case 2:
if(DB[2].toFloat() < -10 || DB[2].toFloat() > 10)
{
Serial.println("VOLTAGE_OVERRANGE");
break;
}
float v;
v = writeDAC(DB[1].toInt(),DB[2].toFloat());
Serial.print("DAC ");
Serial.print(DB[1]);
Serial.print(" UPDATED TO ");
Serial.print(v,5);
Serial.println("V");
break;
case 3:
readDAC(dac[DB[1].toInt()]);
break;
case 4:
autoRamp1(DB);
Serial.println("RAMP_FINISHED");
break;
case 5:
autoRamp2(DB);
Serial.println("RAMP_FINISHED");
break;
case 6:
ID();
break;
case 7:
RDY();
break;
default:
break;
}
}
void loop()
{
Serial.flush();
String inByte = "";
std::vector<String> comm;
if(initialized == 0)
{
normalMode();
initialized = 1;
}
if(Serial.available())
{
char received;
while (received != '\r')
{
if(Serial.available())
{
received = Serial.read();
if (received == '\n' || received == ' ')
{}
else if (received == ',' || received == '\r')
{
comm.push_back(inByte);
inByte = "";
}
else
{
inByte += received;
}
}
}
router(comm);
}
}