void configAdvancedAsyncTreshhold(uint8_t pin,float time,int32_t threshholdValue, uint8_t edgeType){
getBcsIoDataTable(pin)->asyncDataTimer.MsTime=getMs();
getBcsIoDataTable(pin)->asyncDataTimer.setPoint=time;
getBcsIoDataTable(pin)->PIN.asyncDataType = THRESHHOLD;
getBcsIoDataTable(pin)->PIN.asyncDatathreshholdval=threshholdValue;
getBcsIoDataTable(pin)->PIN.asyncDatathreshholdedge=edgeType;
}
void printAsync(){
int i;
println_I("Async Data ");p_fl_I(getMs());
for(i=0;i<GetNumberOfIOChannels();i++){
println_I("\t# ");p_int_I(i);
print_I("\tCurrent ");p_int_I(getBcsIoDataTable()[i].PIN.asyncDataCurrentVal);
print_I("\tPrevious ");p_int_I(getBcsIoDataTable()[i].PIN.asyncDataPreviousVal);
print_I("\tMode ");printAsyncType(getBcsIoDataTable()[i].PIN.asyncDataType);
print_I("\tIteration ");p_fl_I(getBcsIoDataTable()[i].PIN.asyncDataTime.setPoint);
print_I("\tLast ");p_fl_I(getBcsIoDataTable()[i].PIN.asyncDataTime.MsTime);
}
}
boolean GetAllChanelValueFromPacket(BowlerPacket * Packet) {
int32_t * data = (int32_t *) (&Packet->use.data[1]);
if (getAllChanelValueHWPtr != NULL) {
int i;
int32_t tmp;
getAllChanelValueHWPtr(data);
for (i = 0; i < GetNumberOfIOChannels(); i++) {
tmp = data[i];
if(isOutputMode(GetChannelMode(i))==false){
setDataTableCurrentValue(i,tmp);
}else{
if(GetChannelMode(i) == IS_SERVO){
tmp = GetServoPos(i);
}else if(GetChannelMode(i)== IS_UART_RX){
setDataTableCurrentValue(i,tmp);
}else{
tmp = getBcsIoDataTable(i)->PIN.currentValue;
}
}
set32bit(Packet, tmp, (i*4)+1);
}
Packet->use.data[0]=(GetNumberOfIOChannels());
Packet->use.head.RPC=GetRPCValue("gacv");
Packet->use.head.DataLegnth = 4+1+(GetNumberOfIOChannels()*4);
} else
return false;
FixPacket(Packet);
return true;
}
void configPinMode(BYTE pin,BYTE mode,BYTE tris,BYTE io){
ClearPinState(pin);
SetPinTris(pin,tris);
SetDIO(pin,io);
getBcsIoDataTable()[pin].PIN.currentChannelMode = mode;
EEWriteMode(pin,mode);
}
BOOL ConfigureChannelFromPacket(BowlerPacket * Packet){
BYTE pin = Packet->use.data[0];
BYTE mode = GetChannelMode(pin);
INT32 * data = (INT32 *)(Packet->use.data+1);
INT32 tmp;
int i;
if(configChannelHWPtr!=NULL){
if(Packet->use.head.DataLegnth>5 && mode != IS_SERVO){
int numVals = (Packet->use.head.DataLegnth-(4+1))/4;
for(i=0;i<numVals;i++){
tmp = get32bit(Packet, (i*4)+1);
getBcsIoDataTable()[i].PIN.currentValue = tmp;
data[i]=tmp;
}
configChannelHWPtr(pin,numVals,(INT32 * )(Packet->use.data+1));
}else{
// Single Byte Servo, legacy HACK
INT32 value = Packet->use.data[1];
configChannelHWPtr(pin,1,&value);
}
}else{
return FALSE;
}
FixPacket(Packet);
return TRUE;
}
boolean GetChanelValueFromPacket(BowlerPacket * Packet) {
uint8_t pin = Packet->use.data[0];
uint8_t mode = GetChannelMode(pin);
uint8_t numValues = 1;
int32_t data;
if (getChanelValueHWPtr != NULL) {
getChanelValueHWPtr(pin,
&numValues,
&data);
} else {
return false;
}
if(isOutputMode(GetChannelMode(pin))==false ){
setDataTableCurrentValue(pin,data);
}else{
if(mode== IS_UART_RX){
setDataTableCurrentValue(pin,data);
}else{
data = getBcsIoDataTable(pin)->PIN.currentValue;
}
}
set32bit(Packet, data, 1);
numValues = 4;
Packet->use.head.DataLegnth = 4 + 1 + numValues;
FixPacket(Packet);
return true;
}
void printValues(){
int i;
println_I("Values");
for(i=0;i<GetNumberOfIOChannels();i++){
println_I("\t# ");p_int_I(i);
print_I("\tCurrent ");p_int_I(getBcsIoDataTable()[i].PIN.currentValue);
//print_I("\tPrevious ");p_int_I(getBcsIoDataTable()[i].PIN.previousValue);
}
}
void startAdvancedAsyncDefault(uint8_t pin){
//println_W("Starting advanced async on channel: ");p_int_W(pin);
//int mode =GetChannelMode(pin);
//getBcsIoDataTable(pin)->PIN.asyncDataPreviousVal=0xffffffff;;
int32_t mode =GetChannelMode(pin);
if(mode == IS_ANALOG_IN){
float val = GetChanVal( pin) ;
configAdvancedAsyncDeadBand(pin,val*1.1,val*0.9);
}else{
getBcsIoDataTable(pin)->asyncDataTimer.MsTime=getMs();
getBcsIoDataTable(pin)->asyncDataTimer.setPoint=10;
getBcsIoDataTable(pin)->PIN.asyncDataType = NOTEQUAL;
}
RunEvery(getPinsScheduler( pin));
}
void printModes(){
int i;
println_I("Modes");
for(i=0;i<GetNumberOfIOChannels();i++){
println_I("\t# ");p_int_I(i);
print_I("\tCurrent ");printMode(getBcsIoDataTable()[i].PIN.currentChannelMode,INFO_PRINT);
//print_I("\tPrevious ");printMode(getBcsIoDataTable()[i].PIN.previousChannelMode,INFO_PRINT);
}
}
/**
* Sets the datable value and returns true if the value is new, false if it is the same as it was
*/
boolean _setDataTableCurrentValue(uint8_t pin, int32_t value){
if(pin>=GetNumberOfIOChannels()){
//println_E("Pin out of index! : "); p_int_E(pin);
}
if(value !=getBcsIoDataTable(pin)->PIN.currentValue ){
//Print_Level l = INFO_PRINT;
// Print_Level l = isOutputMode(GetChannelMode(pin))?ERROR_PRINT:INFO_PRINT;
// println(" Value was ",l);p_int(getBcsIoDataTable(pin)->PIN.currentValue,l);
// print_nnl(" set to ",l);p_int(value,l);
// print_nnl(" on pin ",l);p_int(pin,l);
// print_nnl(" mode ",l);printMode(GetChannelMode(pin),l);
// THis is the only place this variable should be set
getBcsIoDataTable(pin)->PIN.currentValue =value;
// print_nnl(" lastPushed ",l);p_int( getBcsIoDataTable(pin)->PIN.asyncDataPreviousVal,l);
return true;
}
return false;
}
uint8_t SetAllCoProcValues() {
int i = 0;
boolean send = true;
int32_t tmp;
if (send) {
LoadCorePacket(&downstreamPacketTemp);
downstreamPacketTemp.use.head.Method = BOWLER_POST;
downstreamPacketTemp.use.head.RPC = GetRPCValue("sacv");
set32bit(&downstreamPacketTemp, 0, 0); // setting the translation time
downstreamPacketTemp.use.data[4] = GetNumberOfIOChannels();
for (i = 0; i < GetNumberOfIOChannels(); i++) {
tmp = getBcsIoDataTable(i)->PIN.currentValue;
down[i].changeValue = false;
set32bit(&downstreamPacketTemp, tmp, (i * 4) + 5);
}
downstreamPacketTemp.use.head.DataLegnth = 4 + 4 + 1
+ (4 * GetNumberOfIOChannels());
SendPacketToCoProc(&downstreamPacketTemp);
}
for (i = 0; i < GetNumberOfIOChannels(); i++) {
int index = (i * 4) + 1;
if (isOutputMode(GetChannelMode(i)) == false) {
tmp= get32bit(&downstreamPacketTemp, index);
boolean back = (tmp != getBcsIoDataTable(i)->PIN.currentValue);
setDataTableCurrentValue(i,tmp);
if (back) {
getBcsIoDataTable(i)->PIN.asyncDataenabled = true;
}
}
if (GetChannelMode(i) == IS_SERVO) {
SetServoPos(i, get32bit(&downstreamPacketTemp, index) & 0x000000ff);
}
if (GetChannelMode(i) == IS_UART_RX) {
}
}
return true;
}
void RunPPMCheck(void){
if(GetChannelMode(23) != IS_PPM_IN){
//setMode(23,IS_PPM_IN);
return;
}
if(startedLinks==false){
startedLinks=true;
readPPMLink(ppmLink);
}
if(writeLinks==true){
writeLinks=false;
writePPMLink(ppmLink);
}
int i;
boolean up = false;
for(i=0;i<NUM_PPM_CHAN;i++){
float fTime =MyTickConvertToMilliseconds(((float)ppmDataTmp[i])+(((float)TickGetUpper())*((float) 4294967295ul )));
if(fTime>.9 && fTime<2.2){
float fVal = (fTime-.99)*255;
if(fVal>254)
fVal=254;
if(fVal<0)
fVal=0;
uint8_t time =((BYTE) fVal);
if((time>(ppmData[i]+3)) || (time<(ppmData[i]-3))){
ppmData[i]=time;
//setHeartBeatState( FALSE, 0);
up=true;
}
}
}
if(up){
//push upstream
pushPPMPacket();
//print_I("\nUpdating ppm chan ");printStream(ppmData,NUM_PPM_CHAN);
//print_I(" PPM cross link ");printStream(ppmLink,NUM_PPM_CHAN);
for(i=0;i<NUM_PPM_CHAN;i++){
if(ppmLink[i] != INVALID_PPM_LINK){
if(ppmLastSent[i] != ppmData[i]){
ppmLastSent[i] = ppmData[i];
Print_Level l = getPrintLevel();
setPrintLevelInfoPrint();
//println_I("PPM setting output");
//SetChannelValueCoProc(ppmLink[i],ppmData[i]);
getBcsIoDataTable(ppmLink[i])->PIN.currentValue=ppmData[i];
//SetValFromAsync(ppmLink[i],ppmData[i]);
setPrintLevel(l);
}
}
}
}
}
BYTE GetChannelMode(BYTE chan){
if(chan<0 || chan>GetNumberOfIOChannels()){
setPrintLevelErrorPrint();
#if !defined(__AVR_ATmega644P__) && !defined(__AVR_ATmega644PA__) && !defined(__AVR_ATmega324P__)
println_E("Failed IO sanity check: channel number out of bounds # ");p_int_E(chan);
#endif
//FAIL sanity check
while(1);
}
//Strip off the internally stored High Bit
return getBcsIoDataTable()[chan].PIN.currentChannelMode ;
}
void printAsyncType(uint8_t t, Print_Level l){
switch(getBcsIoDataTable(t)->PIN.asyncDataType){
case AUTOSAMP:
print_nnl("AUTOSAMP",l);return;
case NOTEQUAL:
print_nnl("NOTEQUAL",l);return;
case DEADBAND:
print_nnl("DEADBAND",l);return;
case THRESHHOLD:
print_nnl("THRESHHOLD",l);return;
default:
print_nnl("UNKNOWN: ",l); p_int(t,l);return;
}
}
boolean IsAsync(uint8_t channel){
if (getBcsIoDataTable(channel)->PIN.asyncDataenabled){
return true;
}
uint8_t mode=GetChannelMode(channel);
switch(mode){
case IS_COUNTER_INPUT_HOME:
case IS_COUNTER_OUTPUT_HOME:
case IS_COUNTER_OUTPUT_INT:
case IS_COUNTER_INPUT_INT:
case IS_SERVO:
return true;
default:
return false;
}
}
BOOL SetChanelValueFromPacket(BowlerPacket * Packet){
BYTE pin = Packet->use.data[0];
BYTE mode = GetChannelMode(pin);
if(isStremChannelMode(mode)){
if(setChanelValueHWPtr!=NULL)
// Load the data directly into the packet as the buffer
//Data pointer is offset by one to start after the pin index
setChanelValueHWPtr(pin,
Packet->use.head.DataLegnth-(4+1),
(INT32 *)(Packet->use.data+1),
(float)0);
READY(Packet,1,3);
}else{
INT32 data = 0;
INT32 time = 0;
if(isSingleByteMode(mode)){
data = Packet->use.data[1];
if (Packet->use.head.DataLegnth>(4+2)){
time = get16bit(Packet,2);
}else{
time=0;
}
}else if(isTwoByteMode(mode)){
data=get16bit(Packet,1);
if (Packet->use.head.DataLegnth>(4+3)){
time= get32bit(Packet,3);
}else{
time=0;
}
}else{
data=get32bit(Packet,1);
if (Packet->use.head.DataLegnth>(4+5)){
time= get32bit(Packet,5);
}else{
time=0;
}
}
getBcsIoDataTable()[pin].PIN.currentValue = data;
if(setChanelValueHWPtr!=NULL)
setChanelValueHWPtr(pin,1,&data,(float)time);
READY(Packet,2,3);
}
return TRUE;
}
BOOL GetAllChanelValueFromPacket(BowlerPacket * Packet){
INT32 * data = (INT32 *)(Packet->use.data);
if(getAllChanelValueHWPtr!=NULL){
int i;
INT32 tmp;
getAllChanelValueHWPtr((INT32 * )Packet->use.data);
for(i=0;i<GetNumberOfIOChannels();i++){
tmp = data[i];
getBcsIoDataTable()[i].PIN.currentValue = tmp;
set32bit(Packet,tmp,i*4);
}
Packet->use.head.DataLegnth = 4+GetNumberOfIOChannels()*4;
}else
return FALSE;
FixPacket(Packet);
return TRUE;
}
boolean configAdvancedAsync(BowlerPacket * Packet){
INT32_UNION val;
INT32_UNION time;
uint8_t pin = Packet->use.data[0];
uint8_t type = Packet->use.data[1];
time.byte.FB= Packet->use.data[2];
time.byte.TB= Packet->use.data[3];
time.byte.SB= Packet->use.data[4];
time.byte.LB= Packet->use.data[5];
// this sets default async mode and clears and setting of async mode
setAsyncLocal(Packet->use.data[0],true) ;
//printPacket(Packet,ERROR_PRINT);
switch(type){
case AUTOSAMP:
configAdvancedAsyncAutoSample(pin,time.Val);
break;
case NOTEQUAL:
configAdvancedAsyncNotEqual(pin,time.Val);
break;
case DEADBAND:
val.byte.FB= Packet->use.data[6];
val.byte.TB= Packet->use.data[7];
val.byte.SB= Packet->use.data[8];
val.byte.LB= Packet->use.data[9];
configAdvancedAsyncDeadBand(pin,time.Val,val.Val);
break;
case THRESHHOLD:
val.byte.FB= Packet->use.data[6];
val.byte.TB= Packet->use.data[7];
val.byte.SB= Packet->use.data[8];
val.byte.LB= Packet->use.data[9];
configAdvancedAsyncTreshhold(pin,time.Val,val.Val,Packet->use.data[10]);
break;
default:
ERR(Packet,45,0);
break;
}
getBcsIoDataTable(pin)->PIN.asyncDataPreviousVal=0xffffffff;// invalid previous, forces a value update
READY(Packet,45,0);
return true;
}
boolean SetAllChannelValueFromPacket(BowlerPacket * Packet) {
int32_t * data = (int32_t *) (&Packet->use.data[5] );
int32_t tmp;
if (setAllChanelValueHWPtr != NULL) {
uint32_t time;
uint8_t i;
time=get32bit(Packet, 0);
for (i = 0; i < GetNumberOfIOChannels(); i++) {
if(isOutputMode(GetChannelMode(i))==true){
tmp = get32bit(Packet, (i*4) +5);
// if(GetChannelMode(i) == IS_SERVO)
// data[i] = (tmp & 0x000000ff) | (time<<16);
// else
data[i] = tmp;
}else{
data[i] = getBcsIoDataTable(i)->PIN.currentValue;
}
}
setAllChanelValueHWPtr(data, time);
for (i = 0; i < GetNumberOfIOChannels(); i++) {
if(isOutputMode(GetChannelMode(i))==true){
//println_E(__FILE__);println_E("SetAllChannelValueFromPacket");
if(GetChannelMode(i)!=IS_SERVO)
setDataTableCurrentValue(i,data[i]);
}
}
//READY(Packet, 3, 3);
GetAllChanelValueFromPacket(Packet);
} else {
return false;
}
return true;
}
void InitPinModes(void){
BYTE i;
BYTE mode=0;
for (i=0;i<24;i++){
//ClearPinState(i);
SetPinTris(i,INPUT);
SetDIO(i,0);
SetPWM(i,EEReadValue(i));
SetServoPos(i,EEReadValue(i),0);
//getBcsIoDataTable()[i].PIN.previousChannelMode=NO_CHANGE;
mode=EEReadMode(i);
if((mode < 2)||(mode >=IO_MODE_MAX)){
EEWriteMode(i,IS_DI);
mode = EEReadMode(i);
}
getBcsIoDataTable()[i].PIN.currentChannelMode = mode;
setMode(i,EEReadMode(i));
}
startup = FALSE;
//printModes();
}
/**
* Set Channel Values
* This function takes a pin index, a number of values to be delt with, and an array of data values
* Data is stored into numValues and data
*/
BOOL GetChanelValueHW(BYTE pin,BYTE * numValues,INT32 * data){
BYTE mode = GetChannelMode(pin);
if(isStremChannelMode(mode)){
//BYTE * bData = (BYTE *)data;
switch(mode){
// case IS_SPI_MOSI:
// case IS_SPI_MISO:
// case IS_SPI_SCK:
// SendPacketToSPIFromArray(numValues[0],bData);
// return TRUE;
// case IS_UART_TX:
// case IS_UART_RX:
// numValues[0] = GetSerialRxData( bData);
// return TRUE;
// case IS_PPM_IN:
// numValues[0] = GetPPMDataToArray(bData);
// return TRUE;
}
}else{
numValues[0]=1;
switch(mode){
// case IS_COUNTER_INPUT_INT:
// case IS_COUNTER_INPUT_DIR:
// data[0] = GetCounterByChannel(pin);
// return TRUE;
// case IS_COUNTER_OUTPUT_INT:
// case IS_COUNTER_OUTPUT_DIR:
// data[0] = GetCounterOutput(pin);
// return TRUE;
}
if(isSingleByteMode(mode)){
//mask the time into the data byte
data[0] = getBcsIoDataTable()[pin].PIN.asyncDataCurrentVal & 0x000000ff;
}
return TRUE;
}
return TRUE;
}
/**
* Set Channel Values
* This function takes a
* @param pin pin index
* @param numValues a number of values to be delt with
* @param data an array of data values
* @param ms the time for the transition to take
*
*/
BOOL SetChanelValueHW(BYTE pin,BYTE numValues,INT32 * data, float ms){
BYTE mode = GetChannelMode(pin);
if(isStremChannelMode(mode)){
//BYTE * bData = (BYTE *)data;
switch(mode){
// case IS_SPI_MOSI:
// case IS_SPI_MISO:
// case IS_SPI_SCK:
// SendPacketToSPIFromArray(numValues,bData);
// return TRUE;
// case IS_UART_TX:
// case IS_UART_RX:
// LoadSerialTxData( numValues,bData);
// return TRUE;
// case IS_PPM_IN:
// ConfigPPMFromArray(bData);
// return TRUE;
}
}else{
switch(mode){
// case IS_COUNTER_INPUT_INT:
// case IS_COUNTER_INPUT_DIR:
// case IS_COUNTER_OUTPUT_INT:
// case IS_COUNTER_OUTPUT_DIR:
// SetChanVal(pin,data[0],ms);
// return TRUE;
}
if(isSingleByteMode(mode)){
INT32 time = (INT32)ms;
//mask the time into the data byte
getBcsIoDataTable()[pin].PIN.currentValue = (time<<16)|(data[0]&0x000000ff);
}
return TRUE;
}
return TRUE;
}
BOOL SetAllChannelValueFromPacket(BowlerPacket * Packet){
INT32 * data = (INT32 *)(Packet->use.data+4);
UINT32 tmp;
if(setAllChanelValueHWPtr!=NULL){
UINT32_UNION time;
BYTE i;
time.byte.FB=Packet->use.data[0];
time.byte.TB=Packet->use.data[1];
time.byte.SB=Packet->use.data[2];
time.byte.LB=Packet->use.data[3];
for(i=0;i<GetNumberOfIOChannels();i++){
tmp = get32bit(Packet, i*4);
getBcsIoDataTable()[i].PIN.currentValue = tmp;
data[i]=tmp;
}
setAllChanelValueHWPtr(data,time.Val);
READY(Packet,3,3);
FixPacket(Packet);
}else{
return FALSE;
}
return TRUE;
}
boolean pinHasFunction(uint8_t pin, uint8_t function) {
switch (function) {
case IS_DI:
return _IS_PIN_DIGITAL(pin);
case IS_DO:
return _IS_PIN_DIGITAL(pin);
case IS_ANALOG_IN:
return getBcsIoDataTable(pin)->FUNCTION.HAS_ANALOG_IN;
case IS_ANALOG_OUT:
return false;
//return getBcsIoDataTable(pin)->FUNCTION.HAS_ANALOG_OUT;
case IS_PWM:
return getBcsIoDataTable(pin)->FUNCTION.HAS_PWM;
case IS_SERVO:
return _IS_PIN_SERVO(pin);
case IS_UART_TX:
return getBcsIoDataTable(pin)->FUNCTION.HAS_UART_T;
case IS_UART_RX:
return getBcsIoDataTable(pin)->FUNCTION.HAS_UART_R;
case IS_SPI_MOSI:
return getBcsIoDataTable(pin)->FUNCTION.HAS_SPI_O;
case IS_SPI_MISO:
return getBcsIoDataTable(pin)->FUNCTION.HAS_SPI_I;
case IS_SPI_SCK:
return getBcsIoDataTable(pin)->FUNCTION.HAS_SPI_C;
case IS_COUNTER_INPUT_INT:
return getBcsIoDataTable(pin)->FUNCTION.HAS_COUNTER_INPUT_I;
case IS_COUNTER_INPUT_DIR:
return getBcsIoDataTable(pin)->FUNCTION.HAS_COUNTER_INPUT_D;
case IS_COUNTER_INPUT_HOME:
return getBcsIoDataTable(pin)->FUNCTION.HAS_COUNTER_INPUT_H;
case IS_COUNTER_OUTPUT_INT:
return getBcsIoDataTable(pin)->FUNCTION.HAS_COUNTER_OUTPUT_I;
case IS_COUNTER_OUTPUT_DIR:
return getBcsIoDataTable(pin)->FUNCTION.HAS_COUNTER_OUTPUT_D;
case IS_COUNTER_OUTPUT_HOME:
return getBcsIoDataTable(pin)->FUNCTION.HAS_COUNTER_OUTPUT_H;
case IS_DC_MOTOR_VEL:
return getBcsIoDataTable(pin)->FUNCTION.HAS_PWM;
case IS_DC_MOTOR_DIR:
return getBcsIoDataTable(pin)->FUNCTION.HAS_DC_MOTOR;
case IS_PPM_IN:
return getBcsIoDataTable(pin)->FUNCTION.HAS_PPM;
case IS_DEBUG_RX:
case IS_DEBUG_TX:
return true;
default:
return false;
}
}
void setAsyncLocal(uint8_t channel,boolean async){
getBcsIoDataTable(channel)->PIN.asyncDataenabled=async;
}
BOOL pinHasFunction(BYTE pin, BYTE function){
switch(function){
case IS_DI:
return TRUE;
case IS_DO:
return TRUE;
case IS_ANALOG_IN:
return getBcsIoDataTable()[pin].FUNCTION.HAS_ANALOG_IN;
case IS_ANALOG_OUT:
return FALSE;
//return getBcsIoDataTable()[pin].FUNCTION.HAS_ANALOG_OUT;
case IS_PWM:
return getBcsIoDataTable()[pin].FUNCTION.HAS_PWM;
case IS_SERVO:
return TRUE;
case IS_UART_TX:
return getBcsIoDataTable()[pin].FUNCTION.HAS_UART_T;
case IS_UART_RX:
return getBcsIoDataTable()[pin].FUNCTION.HAS_UART_R;
case IS_SPI_MOSI:
return getBcsIoDataTable()[pin].FUNCTION.HAS_SPI_O;
case IS_SPI_MISO:
return getBcsIoDataTable()[pin].FUNCTION.HAS_SPI_I;
case IS_SPI_SCK :
return getBcsIoDataTable()[pin].FUNCTION.HAS_SPI_C;
case IS_COUNTER_INPUT_INT:
return getBcsIoDataTable()[pin].FUNCTION.HAS_COUNTER_INPUT_I;
case IS_COUNTER_INPUT_DIR:
return getBcsIoDataTable()[pin].FUNCTION.HAS_COUNTER_INPUT_D;
case IS_COUNTER_INPUT_HOME:
return getBcsIoDataTable()[pin].FUNCTION.HAS_COUNTER_INPUT_H;
case IS_COUNTER_OUTPUT_INT:
return getBcsIoDataTable()[pin].FUNCTION.HAS_COUNTER_OUTPUT_I;
case IS_COUNTER_OUTPUT_DIR:
return getBcsIoDataTable()[pin].FUNCTION.HAS_COUNTER_OUTPUT_D;
case IS_COUNTER_OUTPUT_HOME:
return getBcsIoDataTable()[pin].FUNCTION.HAS_COUNTER_OUTPUT_H;
case IS_DC_MOTOR_VEL:
return getBcsIoDataTable()[pin].FUNCTION.HAS_PWM;
case IS_DC_MOTOR_DIR:
return getBcsIoDataTable()[pin].FUNCTION.HAS_DC_MOTOR;
case IS_PPM_IN:
return getBcsIoDataTable()[pin].FUNCTION.HAS_PPM;
default:
return FALSE;
}
}
void configAdvancedAsyncAutoSample(uint8_t pin,float time){
getBcsIoDataTable(pin)->asyncDataTimer.MsTime=getMs();
getBcsIoDataTable(pin)->asyncDataTimer.setPoint=time;
getBcsIoDataTable(pin)->PIN.asyncDataType = AUTOSAMP;
}
void configAdvancedAsyncDeadBand(uint8_t pin,float time,int32_t deadbandSize){
getBcsIoDataTable(pin)->asyncDataTimer.MsTime=getMs();
getBcsIoDataTable(pin)->asyncDataTimer.setPoint=time;
getBcsIoDataTable(pin)->PIN.asyncDataType = DEADBAND;
getBcsIoDataTable(pin)->PIN.asyncDatadeadBandval=deadbandSize;
}
void configAdvancedAsyncNotEqual(uint8_t pin,float time){
getBcsIoDataTable(pin)->asyncDataTimer.MsTime=getMs();
getBcsIoDataTable(pin)->asyncDataTimer.setPoint=time;
getBcsIoDataTable(pin)->PIN.asyncDataType = NOTEQUAL;
}
void ProcessAsyncData(BowlerPacket * Packet){
//println_I("**Got Async Packet**");
//printPacket(Packet,INFO_PRINT);
Print_Level l = getPrintLevel();
setPrintLevelInfoPrint();
if (Packet->use.head.RPC==GCHV){
BYTE pin = Packet->use.data[0];
BYTE mode = GetChannelMode(pin);
if(mode == IS_ANALOG_IN ){
UINT16_UNION ana;
ana.byte.SB = Packet->use.data[1];
ana.byte.LB = Packet->use.data[2];
//ADC_val[pin-8]=ana.Val;
if(ana.Val>=0 && ana.Val<1024)
SetValFromAsync(pin,ana.Val);//asyncData[pin].currentVal=ana.Val;
println_I("***Setting analog value: ");p_int_I(pin);print_I(", ");p_int_I(ana.Val);
}
else if((mode == IS_DI) || (mode == IS_COUNTER_INPUT_HOME)|| (mode == IS_COUNTER_OUTPUT_HOME) || mode == IS_SERVO){
//DIG_val[pin]=Packet->use.data[1];
SetValFromAsync(pin,Packet->use.data[1]);//asyncData[pin].currentVal=Packet->use.data[1];
println_I("***Setting digital value: ");p_int_I(pin);print_I(", ");p_int_I(Packet->use.data[1]);//printStream(DIG_val,NUM_PINS);
}else {
if(IsAsync(pin)){
println_I("Sending async packet, not digital or analog");
PutBowlerPacket(Packet);
}
}
}else if (Packet->use.head.RPC==AASN){
int i;
for(i=0;i<8;i++){
BYTE pin = i+8;
BYTE mode = GetChannelMode(pin);
if(mode == IS_ANALOG_IN ){
UINT16_UNION ana;
ana.byte.SB = Packet->use.data[i*2];
ana.byte.LB = Packet->use.data[(i*2)+1];
//ADC_val[pin-8]=ana.Val
if(ana.Val>=0 && ana.Val<1024);
SetValFromAsync(pin,ana.Val);//asyncData[pin].currentVal=ana.Val;
}
}
}else if (Packet->use.head.RPC==DASN){
int i;
for(i=0;i<GetNumberOfIOChannels();i++){
BYTE mode = GetChannelMode(i);
if((mode == IS_DI) || (mode == IS_COUNTER_INPUT_HOME)|| (mode == IS_COUNTER_OUTPUT_HOME)|| (mode == IS_SERVO)){
SetValFromAsync(i,Packet->use.data[i]);//asyncData[i].currentVal=Packet->use.data[i];
}
}
//println_I("***Setting All Digital value: ");
}if (Packet->use.head.RPC==GetRPCValue("gacv")){
int i;
int val;
for(i=0;i<GetNumberOfIOChannels();i++){
val = get32bit(Packet, i*4);
if(getBcsIoDataTable()[i].PIN.asyncDataCurrentVal!=val){
println_I("Data on Pin ");p_int_I(i);print_I(" to val ");p_int_I(val);
SetValFromAsync(i,val);//
}
}
}else{
println_W("***Async packet not UNKNOWN***");
printPacket(Packet,WARN_PRINT);
}
// println_I("***Setting All value: [");
// int i;
// for(i=0;i<NUM_PINS;i++){
// p_int_I(asyncData[i].currentVal);print_I(" ");
// }
// print_I("]");
setPrintLevel(l);
}
