bool AD5933_Class::isValueReady()
{
if ( (getStatusReg() & 0x02) == 0x02 )
return true;
else
return false;
}
bool AD5933_Class::compFreqRawSweep(int *arrReal, int *arrImag)
{
int ctrReg = getByte(0x80); // Get the content of Control Register and put it into ctrReg
if (setCtrMode(STAND_BY, ctrReg) == false)
{
return false;
}
if (setCtrMode(INIT_START_FREQ, ctrReg) == false)
{
return false;
}
if (setCtrMode(START_FREQ_SWEEP, ctrReg) == false)
{
return false;
}
int t1 = 0;
while ( (getStatusReg() & 0x04) != 0x04) // Loop while if the entire sweep in not complete
{
getComplexRawOnce(arrReal[t1], arrImag[t1]); // Only for real and Imag components.
if (setCtrMode(INCR_FREQ, ctrReg) == false)
{
return false;
}
t1++;
}
if (setCtrMode(POWER_DOWN, ctrReg) == false)
{
return false;
}
return true; // Succeed!
}
bool AD5933_Class::compFreqSweep(double *arrGainFactor, double *arrPShift, double *arrReal, double *arrImag)
{
int ctrReg = getByte(0x80);
setCtrMode(STAND_BY, ctrReg);
setCtrMode(INIT_START_FREQ, ctrReg);
setCtrMode(START_FREQ_SWEEP, ctrReg);
int t1 = 0;
//int cReal, cImag;
double Z_Val, phase;
while ( (getStatusReg() & 0x04) != 0x04) // Loop while if the entire sweep in not complete
{
/*
getComplexRawOnce(cReal, cImag); // Only for real and Imag components.
double magImp = arrGainFactor[t1]/getMag(cReal, cImag);
double phase = atan2(cImag, cReal) - arrPShift[t1];
arrReal[t1] = magImp * cos(phase);
arrImag[t1] = magImp * sin(phase);
*/
getComplexOnce(arrGainFactor[t1], arrPShift[t1], arrReal[t1], arrImag[t1], Z_Val, phase);
if (setCtrMode(INCR_FREQ, ctrReg) == false)
{
return false;
}
t1++;
}
setCtrMode(POWER_DOWN, ctrReg);
return true;
}
//
// Check for controller errors
//
bool
self::checkControllerErrors(void)
{
UInt32 status_reg;
status_reg = getStatusReg();
if (TWE_STATUS_ERRORS(status_reg) || !warnControllerStatus(status_reg))
return(false);
return(true);
}
////////////////////////////////////////////////////////////////////////////////
// Handle a controller interrupt.
//
// We are on the workloop.
//
void
self::handleInterrupt(void)
{
EscaladeCommand *ec;
UInt32 status_reg;
UInt8 tag;
status_reg = getStatusReg();
// Host interrupt - not used
if (status_reg & TWE_STATUS_HOST_INTERRUPT) {
debug(4, "host interrupt");
setControlReg(TWE_CONTROL_CLEAR_HOST_INTERRUPT);
}
// Command interrupt - not currently used
if (status_reg & TWE_STATUS_COMMAND_INTERRUPT) {
debug(4, "command interrupt");
setControlReg(TWE_CONTROL_MASK_COMMAND_INTERRUPT);
}
// Attention interrupt - one or more AENs to be fetched
if (status_reg & TWE_STATUS_ATTENTION_INTERRUPT) {
setControlReg(TWE_CONTROL_CLEAR_ATTENTION_INTERRUPT);
supportThreadAddWork(ST_DO_AEN);
}
// Completion interrupt - work done
if (status_reg & TWE_STATUS_RESPONSE_INTERRUPT) {
while (!(getStatusReg() & TWE_STATUS_RESPONSE_QUEUE_EMPTY)) {
tag = getResponseReg();
ec = findCommand(tag);
if (ec == NULL) { // bogus completion
error("completed invalid tag %d", tag);
continue;
}
// Perform command completion
// Note that once this is called, the command
// must not be touched here as it may have been
// invalidated.
ec->complete();
}
}
}
bool AD5933_Class::getImpedance(double gainFactor, double &impVal) {
while ( (getStatusReg() & 0x02) != 0x02 ); // Wait until measurement is complete.
int rComp, iComp;
byte impData[4];
blockRead(0x94, 4, impData);
rComp = impData[0] * 16 * 16 + impData[1];
iComp = impData[2] * 16 * 16 + impData[3];
double magSq = getMag(rComp, iComp);
impVal = gainFactor / magSq;
return true;
}
bool AD5933_Class::getGainFactorS_Set(double cResistance, int avgNum, double *gainFactorArr, double *pShiftArr)
{
int ctrReg = getByte(0x80);
if (setCtrMode(STAND_BY, ctrReg) == false)
{
return false;
}
if (setCtrMode(INIT_START_FREQ, ctrReg) == false)
{
return false;
}
if (setCtrMode(START_FREQ_SWEEP, ctrReg) == false)
{
return false;
}
int t1 = 0;
int rImag, rReal;
double mag;
while ( (getStatusReg() & 0x04) != 0x04) // Loop while if the entire sweep in not complete
{
double tSumMag = 0, tSumPhase = 0;
for (int t2 = 0; t2 < avgNum; t2++)
{
getComplexRawOnce(rReal, rImag); // Only for real and Imag components.
tSumMag += getMag(rReal, rImag);
tSumPhase += atan2(rImag, rReal);
if (setCtrMode(REPEAT_FREQ, ctrReg) == false)
{
return false;
}
}
//Serial.println(t1);
gainFactorArr[t1] = (tSumMag / avgNum) * cResistance;
pShiftArr[t1] = tSumPhase / avgNum;
if (setCtrMode(INCR_FREQ, ctrReg) == false)
{
return false;
}
t1++;
}
if (setCtrMode(POWER_DOWN, ctrReg) == false)
{
return false;
}
return true; // Succeed!
}
//
// Wait up to waittime seconds for the status bits to be set.
//
// Note that this spins, and should be avoided when possible.
//
bool
self::waitStatusBits(UInt32 bits, int waittime)
{
UInt32 status_reg = 0;
int i;
for (i = 0; i < (waittime * 100); i++) {
status_reg = getStatusReg();
if ((status_reg & bits) == bits)
return(true);
IODelay(10000);
}
debug(2, "timed out waiting for status bits 0x%08x, have status 0x%08x",
(uint)bits, (uint)status_reg);
return(false);
}
//
// Post a request, returns false if the controller is busy.
//
bool
self::postCommand(EscaladeCommand *ec)
{
UInt32 status_reg;
// check that the command queue is not full
status_reg = getStatusReg();
if (status_reg & TWE_STATUS_COMMAND_QUEUE_FULL)
return(false);
// and post the command
pciNub->ioWrite32(8, (UInt32)ec->commandPhys, registerMap);
// mark as posted
ec->wasPosted();
return(true);
}
bool AD5933_Class::tempUpdate() {
if (setCtrMode(TEMP_MEASURE) == false)
{
#if LOGGING1
printer->println("tempUpdate - Failed to set the control bit");
#endif
return false;
}
while ( (getStatusReg() & 0x01) != 0x01)
{
; // Wait Until Get Vaild Temp. Measurement.
}
return true;
}
bool AD5933_Class::tempUpdate()
// Function to update temperature information without reading.
{
if (setCtrMode(TEMP_MEASURE) == false)
{
#if LOGGING1
printer->println("getTemperature - Failed to set the control bit");
#endif
return false;
}
while ( getStatusReg() & 0x01 != 0x01)
{
; // Wait Until Get Vaild Temp. Measurement.
}
return true;
}
bool AD5933_Class::getComplexOnce(double gainFactor, double pShift, double &vReal, double &vComp, double &impVal, double &phase)
{
while ( (getStatusReg() & 0x02) != 0x02 ); // Wait until measurement is complete.
int rComp, iComp;
byte impData[4];
blockRead(0x94, 4, impData);
rComp = impData[0] * 16 * 16 + impData[1];
iComp = impData[2] * 16 * 16 + impData[3];
double magSq = getMag(rComp, iComp);
impVal = gainFactor / magSq;
phase = atan2(iComp, rComp) - pShift;
vReal = impVal * cos(phase);
vComp = impVal * sin(phase);
return true;
}
bool AD5933_Class::getComplexRawOnce(int &realComp, int &imagComp)
{
while ( (getStatusReg() & 0x02) != 0x02 ); // Wait until measurement is complete.
int rComp, iComp;
byte impData[4];
blockRead(0x94, 4, impData);
rComp = impData[0] * 16 * 16 + impData[1];
iComp = impData[2] * 16 * 16 + impData[3];
//double magSq = square((double)rComp) + square((double)iComp);
//double td1=gainFactor/magSq;
//realComp = abs(rComp)*td1;
//imagComp = abs(iComp)*td1;
realComp = rComp;
imagComp = iComp;
return true;
}
//
// Drain the response queue, discard all the responses
//
bool
self::drainResponseQueue(void)
{
UInt32 status_reg;
//UInt8 tag;
// spin pulling responses until none left
for (;;) {
// check controller status
status_reg = getStatusReg();
if (!warnControllerStatus(status_reg)) {
error("unexpected controller status 0x%08x", (uint)status_reg);
return(false);
}
// check for more status
if (status_reg & TWE_STATUS_RESPONSE_QUEUE_EMPTY)
break;
//tag = getResponseReg();
}
return(true);
}
bool AD5933_Class::performFreqSweep(double gainFactor, double *arrSave)
// Function to perform frequency Sweep, Just call it once to do it. It automatically do all the step.
// double gainFactor - You need to call getGainFactor(double,int)
//
// double *arrSave - Just put the name of the array to save it. It should have right number of entries to save it.
// If not, hidden error will be occur.
{
int ctrReg = getByte(0x80); // Get the content of Control Register and put it into ctrReg
if (setCtrMode(STAND_BY, ctrReg) == false)
{
#if LOGGING1
printer->println("performFreqSweep - Failed to setting Stand By Status!");
#endif
return false;
}
if (setCtrMode(INIT_START_FREQ, ctrReg) == false)
{
#if LOGGING1
printer->println("performFreqSweep - Failed to setting initialization with starting frequency!");
#endif
return false;
}
//delay(delayTimeInit);
if (setCtrMode(START_FREQ_SWEEP, ctrReg) == false)
{
#if LOGGING1
printer->println("performFreqSweep - Failed to set to start frequency sweeping!");
#endif
return false;
}
int t1 = 0;
while ( (getStatusReg() & 0x04) != 0x04 ) // Loop while if the entire sweep in not complete
{
//delay(delayTimeInit);
arrSave[t1] = gainFactor / getMagOnce(); // Calculated with Gain Factor
#if LOGGING1
printer->print("performFreqSweep - arrSave[");
printer->print(t1);
printer->print("] = ");
printer->println(arrSave[t1]);
#endif
if (setCtrMode(INCR_FREQ, ctrReg) == false)
{
#if LOGGING1
printer->println("performFreqSweep - Failed to set for increasing frequency!");
#endif
return false;
}
t1++;
//getByte(0x80);
}
if (setCtrMode(POWER_DOWN, ctrReg) == false)
{
#if LOGGING1
printer->println("performFreqSweep - Completed sweep, but failed to power down");
#endif
return false;
}
return true; // Succeed!
}
bool AD5933_Class::getGainFactorsTetraSweep(double cResistance, int avgNum, double *gainFactorArr, double *vShiftArr, double *cShiftArr){
int ctrReg = getByte(0x80);
if (setCtrMode(STAND_BY, ctrReg) == false)
{
return false;
}
if (setCtrMode(INIT_START_FREQ, ctrReg) == false)
{
return false;
}
if (setCtrMode(START_FREQ_SWEEP, ctrReg) == false)
{
return false;
}
int arrayIndex = 0;
while ( (getStatusReg() & 0x04) != 0x04) { // While the fequency sweep isn't complete
//////
int averageIndex = 0, iVoltage = 0, rVoltage = 0, iCurrent = 0, rCurrent = 0;
double voltageSum = 0, currentSum = 0, voltagePhaseSum = 0, currentPhaseSum = 0;
digitalWrite(IV_MUX, LOW); //Toggle current / voltage multiplexer to voltage
delay(10);
if (setCtrMode(REPEAT_FREQ, ctrReg) == false) {
return false;
}
// Until reached pre-defined number for averaging.
while (averageIndex < avgNum) {
getComplexRawOnce(rVoltage, iVoltage);
voltageSum += getMag(rVoltage, iVoltage);
voltagePhaseSum += atan2(iVoltage, rVoltage);
if (setCtrMode(REPEAT_FREQ, ctrReg) == false) {
return false;
}
averageIndex++;
}
digitalWrite(IV_MUX, HIGH); // Toggle current / voltage multiplexer to current
delay(10); // delay for mux to settle
averageIndex = 0; // Reset index for current
if (setCtrMode(REPEAT_FREQ, ctrReg) == false) {
return false;
}
while (averageIndex < avgNum) {
getComplexRawOnce(rCurrent, iCurrent);
currentSum += getMag(rCurrent, iCurrent);
currentPhaseSum += atan2(iCurrent, rCurrent);
if (setCtrMode(REPEAT_FREQ, ctrReg) == false) {
return false;
}
averageIndex++;
}
double voltageMag = voltageSum / ((double) avgNum);
double currentMag = currentSum / ((double) avgNum);
gainFactorArr[arrayIndex] = cResistance * (currentMag / voltageMag);
vShiftArr[arrayIndex] = voltagePhaseSum / ((double) avgNum);
cShiftArr[arrayIndex] = currentPhaseSum / ((double) avgNum);
//////
if (setCtrMode(INCR_FREQ, ctrReg) == false){
return false;
}
arrayIndex++;
}
if (setCtrMode(POWER_DOWN, ctrReg) == false){
return false;
}
return true; // Succeed!
}
