boolean processPIDCrit(BowlerPacket * Packet){
uint8_t i=0;
switch (Packet->use.head.RPC){
case KPID:
for(i=0;i<getNumberOfPidChannels();i++){
getPidGroupDataTable(i)->config.Enabled = true;
setOutput(i,0.0);
getPidGroupDataTable(i)->config.Enabled = false;
getPidVelocityDataTable(i)->enabled=false;
getPidGroupDataTable(i)->Output=0.0;
}
READY(Packet,zone,0);
break;
case CPID:
if(ConfigPID(Packet)){
READY(Packet,zone,1);
}else
ERR(Packet,zone,1);
break;
case CPDV:
if(ConfigPDVelovity(Packet)){
READY(Packet,zone,1);
}else
ERR(Packet,zone,1);
break;
default:
return false;
}
return true;
}
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;
}
boolean processRunAutoCal(BowlerPacket * Packet) {
int group = Packet->use.data[0];
runPidHysterisisCalibration(group);
READY(Packet, 0, 0);
return true;
}
boolean processPIDPost(BowlerPacket * Packet){
int chan, val;
float time;
switch (Packet->use.head.RPC){
case APID:
time = (float)get32bit(Packet,0);
uint8_t i=0;
for(i=0;i<Packet->use.data[4];i++){
SetPIDTimed(i,get32bit(Packet,5+(i*4)),time);
}
READY(Packet,zone,3);
break;
case _VPD:
chan = Packet->use.data[0];
val = get32bit(Packet,1);
time=get32bit(Packet,5);
StartPDVel(chan,val,time);
READY(Packet,zone,4);
break;
case _PID:
chan = Packet->use.data[0];
val = get32bit(Packet,1);
time=get32bit(Packet,5);
SetPIDTimed(chan,val,time);
READY(Packet,zone,5);
break;
case RPID:
chan = Packet->use.data[0];
b_println("Resetting PID channel from packet:",ERROR_PRINT);printBowlerPacketDEBUG(Packet,ERROR_PRINT);
pidReset(chan, get32bit(Packet,1));
READY(Packet,zone,6);
break;
default:
return false;
}
return true;
}
void ConfigPPM(BowlerPacket * Packet){
int i;
for(i=0;i<NUM_PPM_CHAN;i++){
ppmLink[i]=Packet->use.data[i+1];
if(ppmLink[i]>= GetNumberOfIOChannels()){
ppmLink[i]=INVALID_PPM_LINK;
}else{
unlockServos();
}
}
writeLinks=true;
READY(Packet,66,0);
}
void plu(int nbi, int nbj)
{
int i, j;
for (i = 0; i < nbi; ++i) {
for (j = 0; j < nbj; ++j) {
args[i][j].bi = i;
args[i][j].bj = j;
args[i][j].nbi = nbi;
args[i][j].nbj = nbj;
}
}
#define USE_FORK 1
#define RBOUNDS(__x) (0 <= (__x) && (__x) < nbi)
#define CBOUNDS(__x) (0 <= (__x) && (__x) < nbj)
#define READY(_x, _y) ( \
(!RBOUNDS((_x)-1) || DONE == status[(_x)-1][(_y)]) && \
(!CBOUNDS((_y)-1) || DONE == status[(_x)][(_y)-1]))
memset(status, 0, sizeof(status));
while (!alldone(nbi, nbj)) {
for (i = 0; i < nbi; ++i) {
for (j = 0; j < nbj; ++j) {
if (!READY(i, j) || DONE == status[i][j])
continue;
status[i][j] = RUNNING;
#if USE_FORK
pthread_create(&threads[nbj * i + j], NULL, lu, &args[i][j]);
#endif
}
}
for (i = 0; i < nbi; ++i) {
for (j = 0; j < nbj; ++j) {
if (RUNNING != status[i][j])
continue;
#if USE_FORK
pthread_join(threads[nbj * i + j], NULL);
#endif
status[i][j] = DONE;
}
}
}
/* Clear bottom of A (which is now U) and make L's diagonals 1s. */
for (i = 0; i < n; ++i) {
for (j = 0; j < n; ++j) {
if (i > j)
VAL(A,i,j) = 0;
if(i == j)
VAL(L,i,i) = 1;
}
}
}
int main()
{
int T=0;
scanf("%d",&T);
for(int i=1;i<=T;i++)
{
read();
READY();
DP();
solve();
printf("%s\n",ans.letter);
}
return 0;
}
BOOL bcsSafeProcessor_p(BowlerPacket * Packet){
//BYTE temp0;
UINT16_UNION timeUnion;
BYTE zone =5;
switch (Packet->use.head.RPC){
case SAFE:
timeUnion.byte.SB=Packet->use.data[1];
timeUnion.byte.LB=Packet->use.data[2];
setHeartBeatState(Packet->use.data[0],timeUnion.Val);
READY(Packet,zone,7);
break;
default:
return FALSE;
}
return TRUE;
}
boolean SetChanelStreamFromPacket(BowlerPacket * Packet) {
uint8_t pin = Packet->use.data[0];
uint8_t mode = GetChannelMode(pin);
if (_isStremChannelMode(mode)) {
if (setStreamHWPtr != NULL)
// Load the data directly into the packet as the buffer
//Data pointer is offset by one to start after the pin index
setStreamHWPtr( pin,
Packet->use.data[1],
&Packet->use.data[2]);
} else {
ERR(Packet, 2, 3);
}
READY(Packet, 2, 3);
return true;
}
BOOL onCartesianPost(BowlerPacket *Packet){
Print_Level l = getPrintLevel();
switch(Packet->use.head.RPC){
case _SLI:
if(FifoGetPacketSpaceAvailible(&packetFifo)>0){
if(Packet->use.data[0]==1){
processLinearInterpPacket(Packet);
}else{
println_I("Cached linear Packet ");p_int_I(FifoGetPacketSpaceAvailible(&packetFifo));
FifoAddPacket(&packetFifo,Packet);
}
Packet->use.head.Method = BOWLER_STATUS;
INT32_UNION tmp;
tmp.Val=FifoGetPacketSpaceAvailible(&packetFifo);
Packet->use.data[0]=tmp.byte.FB;
Packet->use.data[1]=tmp.byte.TB;
Packet->use.data[2]=tmp.byte.SB;
Packet->use.data[3]=tmp.byte.LB;
tmp.Val=SIZE_OF_PACKET_BUFFER;
Packet->use.data[4]=tmp.byte.FB;
Packet->use.data[5]=tmp.byte.TB;
Packet->use.data[6]=tmp.byte.SB;
Packet->use.data[7]=tmp.byte.LB;
Packet->use.head.DataLegnth=4+4+4;
if(tmp.Val == 0){
full=TRUE;
}
setPrintLevel(l);
}else{
println_I("###ERROR BUFFER FULL!!");p_int_I(FifoGetPacketSpaceAvailible(&packetFifo));
setPrintLevel(l);
ERR(Packet,33,33);
}
return TRUE;
case PRCL:
cancelPrint();
READY(Packet,35,35);
return TRUE;
}
return FALSE;
}
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;
}
BOOL SetChannelValue(BowlerPacket * Packet){
BOOL ret=FALSE;
BYTE pin = Packet->use.data[0];
BYTE mode = GetChannelMode(pin);
BYTE bval;
UINT16_UNION wval;
BYTE zone=128;
//println_I("Setting Value of mode: ");printMode(mode);print_I(" on pin:");p_int_I(pin);
if (isASetableMode(mode)){
bval = Packet->use.data[1];
if (Packet->use.head.DataLegnth>6){
wval.byte.SB = Packet->use.data[2];
wval.byte.LB = Packet->use.data[3];
}else{
//println_I("Packet was 6 or less data bytes");
wval.Val=0;
}
SetChanVal(pin,bval,(float)wval.Val);
ret = TRUE;
READY(Packet,zone,0);
}else if ( (mode == IS_ANALOG_OUT)){
wval.byte.SB=Packet->use.data[1];
wval.byte.LB=Packet->use.data[2];
switch (mode){
default:
return FALSE;
}
ret = TRUE;
}else if ((mode == IS_UART_TX) || (mode == IS_UART_RX)){
//Number of bytes in the stream to be sent
BYTE i;
bval = Packet->use.head.DataLegnth-5;
for (i=0;i<bval;i++){
WriteAVRUART1(Packet->use.data[i+1]);
}
return TRUE;
}
return ret;
}
boolean SetChanelValueFromPacket(BowlerPacket * Packet) {
uint8_t pin = Packet->use.data[0];
uint8_t mode = GetChannelMode(pin);
int32_t data = 0;
int32_t time = 0;
data = get32bit(Packet, 1);
time = get32bit(Packet, 5);
//println_W("Setting on pin=");p_int_W(pin); print_W(" value= ");p_int_W(data); print_W(" time= ");p_fl_W(time);
if(mode == IS_SERVO)
data = (data&0x000000ff) | (time<<16);
if (setChanelValueHWPtr != NULL)
setChanelValueHWPtr(pin, 1, &data, (float)time);
//println_E(__FILE__);println_E("SetChanelValueFromPacket");
setDataTableCurrentValue(pin,data);
READY(Packet, 1, 3);
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;
}
int listen_for_code(void){
int sockfd, new_sockfd, port=PORT, yes=1, recvlength=1;
socklen_t sin_size;
char buffer[TRANSMISSION_SIZE];
struct sockaddr_in srv_addr, cli_addr;
if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)
fatal("in socket");
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1)
fatal("setting socket option SO_REUSEADDR");
srv_addr.sin_family = AF_INET; // host byte order
srv_addr.sin_port = htons(port); // short, network byte order
srv_addr.sin_addr.s_addr = 0; // automatically fill with my ip address
memset(&(srv_addr.sin_zero), '\0', 8); // zero out the rest of the struct
if (bind(sockfd, (struct sockaddr *)&srv_addr, sizeof(struct sockaddr)) == -1)
fatal("binding to socket");
if (listen(sockfd, 5) == -1)
fatal("listening on socket");
/**
* Main loop
**/
unsigned char *codebuffer;
unsigned char *result;
char *sexp;
int codelength, actual_sexp_length;
codebuffer = malloc(MAX_CODE_SIZE);
result = malloc(SYSREG_BYTES);
sexp = malloc(SEXP_LENGTH);
while (1) {
sin_size = sizeof(struct sockaddr_in);
if ((new_sockfd =
accept(sockfd, (struct sockaddr *) &cli_addr, &sin_size)) == -1)
fatal("accepting connection");
printf("SERVER: ACCEPTED CONNECTION FROM %s PORT %d\n",
inet_ntoa(cli_addr.sin_addr), ntohs(cli_addr.sin_port));
//send(new_sockfd, "Hello, world!\n\r", 13, 0); // just for testing
recvlength = recv(new_sockfd, &buffer, TRANSMISSION_SIZE, 0);
/**
* Clean the buffers
**/
memset(codebuffer, 0, MAX_CODE_SIZE);
memset(result, 0, SYSREG_BYTES);
memset(sexp, 0, SEXP_LENGTH);
codelength = 0;
while (recvlength > 0) {
printf("RECV: %d bytes\n", recvlength);
if (DUMP) fdump(stdout, buffer, recvlength);
// memcpy(codebuffer+codelength, buffer, recvlength);
codelength = codecopy(codebuffer, buffer,
codelength, recvlength);
// codelength += recvlength;
printf("code length = %d\n", codelength);
if (READY(codelength)){
hatch_code(codebuffer, NULL, result);
actual_sexp_length = lisp_encode(result, sexp);
send(new_sockfd, sexp, actual_sexp_length, 0);
break;
} else {
recvlength = recv(new_sockfd, &buffer, TRANSMISSION_SIZE, 0);
}
}
close(new_sockfd);
}
free(codebuffer);
free(result);
free(sexp);
}
