static void pnm_send_request(pnm_t *p, uint32_t bandwidth) {
uint16_t i16;
int c=PNM_HEADER_SIZE;
char fixme[]={0,1};
memcpy(p->buffer,pnm_header,PNM_HEADER_SIZE);
c+=pnm_write_chunk(PNA_CLIENT_CHALLANGE,strlen(pnm_challenge),
pnm_challenge,&p->buffer[c]);
c+=pnm_write_chunk(PNA_CLIENT_CAPS,PNM_CLIENT_CAPS_SIZE,
pnm_client_caps,&p->buffer[c]);
c+=pnm_write_chunk(0x0a,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0c,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0d,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x16,2,fixme,&p->buffer[c]);
c+=pnm_write_chunk(PNA_TIMESTAMP,strlen(pnm_timestamp),
pnm_timestamp,&p->buffer[c]);
c+=pnm_write_chunk(PNA_BANDWIDTH,4,
(const char *)&pnm_default_bandwidth,&p->buffer[c]);
c+=pnm_write_chunk(0x08,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0e,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x0f,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x11,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x10,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x15,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(0x12,0,NULL,&p->buffer[c]);
c+=pnm_write_chunk(PNA_GUID,strlen(pnm_guid),
pnm_guid,&p->buffer[c]);
c+=pnm_write_chunk(PNA_TWENTYFOUR,PNM_TWENTYFOUR_SIZE,
pnm_twentyfour,&p->buffer[c]);
/* data after chunks */
memcpy(&p->buffer[c],after_chunks,after_chunks_length);
c+=after_chunks_length;
/* client id string */
p->buffer[c]=PNA_CLIENT_STRING;
i16=be2me_16(strlen(client_string)-1); /* dont know why do we have -1 here */
memcpy(&p->buffer[c+1],&i16,2);
memcpy(&p->buffer[c+3],client_string,strlen(client_string)+1);
c=c+3+strlen(client_string)+1;
/* file path */
p->buffer[c]=0;
p->buffer[c+1]=PNA_PATH_REQUEST;
i16=be2me_16(strlen(p->path));
memcpy(&p->buffer[c+2],&i16,2);
memcpy(&p->buffer[c+4],p->path,strlen(p->path));
c=c+4+strlen(p->path);
/* some trailing bytes */
p->buffer[c]='y';
p->buffer[c+1]='B';
rm_write(p->s,p->buffer,c+2);
}
static void pnm_send_response(pnm_t *p, const char *response) {
int size=strlen(response);
p->buffer[0]=0x23;
p->buffer[1]=0;
p->buffer[2]=(unsigned char) size;
memcpy(&p->buffer[3], response, size);
rm_write (p->s, p->buffer, size+3);
}
int main(int argc, char **argv)
{
int i, fD, nRead, status;
float data;
unsigned loopCount = 0;
int antList[RM_ARRAY_SIZE];
int gotSecondAD, secondADFD;
float fData[N_TILTS+2], fSecond, boxCar;
char nodeName[80];
int debugMessagesOn;
double voltage;
struct sigaction action, oldAction;
if (argc > 1)
debugMessagesOn = 1;
else
debugMessagesOn = 0;
boxCar = 0.0;
/*********************************************************************/
/* set up to receive and wait for the SIGHUP signal from the rc file */
/*********************************************************************/
action.sa_flags = 0;
sigemptyset(&action.sa_mask);
action.sa_handler = signalHandler;
sigaction(SIGHUP, &action, &oldAction);
/*
Open all A/D channels:
Note - the way the Xycom device driver is written, each channel on the A-D
has a separate pseudofile in the /dev directory, named /dev/xVME564-n,
where n is the channel number.
*/
sprintf(nodeName, "/dev/iPOptoAD16_6000", i);
fD = open(nodeName, O_RDONLY);
if (fD < 0) {
perror("Open");
exit(-1);
}
secondADFD = open("/dev/iPOptoAD16_2", O_RDONLY);
if (secondADFD < 0)
gotSecondAD = 0;
else
gotSecondAD = 1;
/* Initialize Reflective memory driver */
status = rm_open(antList);
if (status != RM_SUCCESS) {
rm_error_message(status, "rm_open()");
exit(-1);
}
/* Loop forever read'n and write'n tilts */
while (1) {
loopCount += 1;
if (!(loopCount % 10)) {
for (i = 0; i <= (N_TILTS+1); i++) {
*((int *)&data) = i;
nRead = read(fD, (char *)(&data), 4);
if (nRead != 4)
fprintf(stderr, "logTilts: Got %d bytes on channel %d instead of 4\n",
nRead, i);
fData[i] = -data;
}
}
if (gotSecondAD) {
*((int *)&fSecond) = 0; /* Martina, set channel 0 or 1 */
nRead = read(secondADFD, (char *)(&fSecond), 4);
if (nRead != 4) {
fprintf(stderr, "logTilts: Got %d bytes on channel %d instead of 2\n",
nRead, i);
gotSecondAD = 0;
fSecond = 0.0;
}
} else
fSecond = 0.0;
boxCar = (boxCar + fSecond) / 1.010101010101010101;
if (!(loopCount % 10)) {
if (debugMessagesOn)
printf(
"Writing tilts: %f %f %f %f TP 1: %f TP 2: %f TP 3: %f (%f)\n",
fData[0], fData[1], fData[2], fData[3], fData[4], fData[5],
fSecond, boxCar/99.0);
status = rm_write(RM_ANT_0, "RM_TILT_VOLTS_V4_F", fData);
if (status != RM_SUCCESS) {
rm_error_message(status, "rm_write()");
exit(-1);
}
voltage = (double)fData[4];
status = rm_write(RM_ANT_0, "RM_TOTAL_POWER_VOLTS_D", &voltage);
if (status != RM_SUCCESS) {
rm_error_message(status, "rm_write()");
exit(-1);
}
voltage *= -1.0;
status = rm_write(RM_ANT_0, "RM_SYNCDET_VOLTS_D", &voltage);
if (status != RM_SUCCESS) {
rm_error_message(status, "rm_write()");
exit(-1);
}
voltage = (double)fData[5];
status = rm_write(RM_ANT_0, "RM_TOTAL_POWER_VOLTS2_D", &voltage);
if (status != RM_SUCCESS) {
rm_error_message(status, "rm_write()");
exit(-1);
}
voltage = (double)(boxCar/99.0);
status = rm_write(RM_ANT_0, "RM_IF_LO_TOTAL_POWER_D", &voltage);
if (status != RM_SUCCESS) {
rm_error_message(status, "rm_write()");
exit(-1);
}
}
usleep(10000);
}
/* Should never get here; why do I bother? */
/* Close A/D files */
close(fD);
/* Shut down RM */
status = rm_close();
if (status != RM_SUCCESS) {
rm_error_message(status, "rm_close()");
exit(-1);
}
exit(0);
}
void main(int argc, char *argv[])
{
char c,*degrees,messg[100],command_n[30];
short pmac_command_flag=0;
short error_flag=RUNNING;
int gotaz=0,rm_status,antlist[RM_ARRAY_SIZE];
float az,actual_az,actual_el;
smapoptContext optCon;
int i,antenna;
int gotantenna=0,antennaArray[]={0,0,0,0,0,0,0,0,0};
int trackStatus=0,iant;
int tracktimestamp,timestamp;
short antennaStatus = 0;
/* initializing ref. mem. */
rm_status=rm_open(antlist);
if(rm_status != RM_SUCCESS) {
rm_error_message(rm_status,"rm_open()");
exit(1);
}
antenna = 0;
/* check if track is running on this antenna */
rm_status=rm_read(antenna,"RM_UNIX_TIME_L",×tamp);
rm_status=rm_read(antenna,"RM_TRACK_TIMESTAMP_L",&tracktimestamp);
if(abs(tracktimestamp-timestamp)>3L) {
trackStatus=0;
printf("Track is not running on this antenna.\n");
exit(1);
}
command_n[0]='T'; /* send 'T' command */
az = 10;
el = 45;
rm_status=rm_read(antenna, "RM_ACTUAL_AZ_DEG_F",&actual_az);
rm_status|=rm_read(antenna,"RM_ACTUAL_EL_DEG_F",&actual_el);
if(rm_status != RM_SUCCESS) {
rm_error_message(rm_status,"rm_read()");
exit(1);
}
rm_status=rm_write(antenna, "RM_SMARTS_AZ_DEG_F",&az);
rm_status|=rm_write(antenna, "RM_SMARTS_EL_DEG_F",&actual_el);
if(rm_status != RM_SUCCESS) {
rm_error_message(rm_status,"rm_write()");
exit(1);
}
rm_status=rm_write(antenna,"RM_SMASH_TRACK_COMMAND_C30",
&command_n);
if(rm_status != RM_SUCCESS) {
rm_error_message(rm_status,"rm_write()");
exit(1);
}
pmac_command_flag=0;
rm_status=rm_write_notify(antenna,"RM_SMARTS_PMAC_COMMAND_FLAG_S",
&pmac_command_flag);
if(rm_status != RM_SUCCESS) {
rm_error_message(rm_status,"rm_write_notify()");
exit(1);
}
error_flag=RUNNING;
sleep(3);
rm_status=rm_read(antenna,
"RM_SMARTS_COMMAND_STATUS_S",&error_flag);
if(rm_status != RM_SUCCESS) {
rm_error_message(rm_status,"rm_read()");
exit(1);
}
if(error_flag==ERROR)
{
printf("Error from track:\n");
rm_status=rm_read(antenna,
"RM_TRACK_MESSAGE_C100",messg);
if(rm_status != RM_SUCCESS) {
rm_error_message(rm_status,"rm_read()");
exit(1);
}
printf("%s\n",messg);
}
/*
if(error_flag==OK) printf("antenna has reached the source.\n");
*/
}
static int pnm_get_stream_chunk(pnm_t *p) {
int n;
char keepalive='!';
unsigned int fof1, fof2, stream;
/* send a keepalive */
/* realplayer seems to do that every 43th package */
if ((p->packet%43) == 42)
{
rm_write(p->s,&keepalive,1);
}
/* data chunks begin with: 'Z' <o> <o> <i1> 'Z' <i2>
* where <o> is the offset to next stream chunk,
* <i1> is a 16 bit index (big endian)
* <i2> is a 8 bit index which counts from 0x10 to somewhere
*/
n = rm_read (p, p->buffer, 8);
if (n<8) return 0;
/* skip 8 bytes if 0x62 is read */
if (p->buffer[0] == 0x62)
{
n = rm_read (p, p->buffer, 8);
if (n<8) return 0;
#ifdef LOG
printf("input_pnm: had to seek 8 bytes on 0x62\n");
#endif
}
/* a server message */
if (p->buffer[0] == 'X')
{
int size=be2me_16(*(uint16_t*)(&p->buffer[1]));
rm_read (p, &p->buffer[8], size-5);
p->buffer[size+3]=0;
printf("input_pnm: got message from server while reading stream:\n%s\n", &p->buffer[3]);
return 0;
}
if (p->buffer[0] == 'F')
{
printf("input_pnm: server error.\n");
return 0;
}
/* skip bytewise to next chunk.
* seems, that we dont need that, if we send enough
* keepalives
*/
n=0;
while (p->buffer[0] != 0x5a) {
int i;
for (i=1; i<8; i++) {
p->buffer[i-1]=p->buffer[i];
}
rm_read (p, &p->buffer[7], 1);
n++;
}
#ifdef LOG
if (n) printf("input_pnm: had to seek %i bytes to next chunk\n", n);
#endif
/* check for 'Z's */
if ((p->buffer[0] != 0x5a)||(p->buffer[7] != 0x5a))
{
printf("input_pnm: bad boundaries\n");
hexdump(p->buffer, 8);
return 0;
}
/* check offsets */
fof1=be2me_16(*(uint16_t*)(&p->buffer[1]));
fof2=be2me_16(*(uint16_t*)(&p->buffer[3]));
if (fof1 != fof2)
{
printf("input_pnm: frame offsets are different: 0x%04x 0x%04x\n",fof1,fof2);
return 0;
}
/* get first index */
p->seq_current[0]=be2me_16(*(uint16_t*)(&p->buffer[5]));
/* now read the rest of stream chunk */
n = rm_read (p, &p->recv[5], fof1-5);
if (n<(fof1-5)) return 0;
/* get second index */
p->seq_current[1]=p->recv[5];
/* get timestamp */
p->ts_current=be2me_32(*(uint32_t*)(&p->recv[6]));
/* get stream number */
stream=pnm_calc_stream(p);
/* saving timestamp */
p->ts_last[stream]=p->ts_current;
/* constructing a data packet header */
p->recv[0]=0; /* object version */
p->recv[1]=0;
fof2=be2me_16(fof2);
memcpy(&p->recv[2], &fof2, 2);
/*p->recv[2]=(fof2>>8)%0xff;*/ /* length */
/*p->recv[3]=(fof2)%0xff;*/
p->recv[4]=0; /* stream number */
p->recv[5]=stream;
p->recv[10]=p->recv[10] & 0xfe; /* streambox seems to do that... */
p->packet++;
p->recv_size=fof1;
return fof1;
}
