void nRF24L01::broadcastPacket(uint8_t *packet) {
uint8_t stat = 0;
regRead(REG_FIFO_STATUS, &stat, 1);
uint32_t timeout = millis();
while (_mode == 1 && millis() - timeout < 1000); // Wait for it to not be transmitting
if (_mode == 1) {
selectRX();
}
regWrite(REG_TX_ADDR, _bc, 5);
enablePipe(0, _addr, false);
enablePipe(1, _addr, false);
uint8_t zero = 0x00;
regWrite(REG_EN_AA, &zero, 1);
selectTX();
uint32_t s = disableInterrupts();
digitalWrite(_csn, LOW);
_status = _spi->transfer(CMD_TX);
for (int i = 0; i < _pipeWidth; i++) {
_spi->transfer(packet[i]);
}
digitalWrite(_csn, HIGH);
restoreInterrupts(s);
digitalWrite(_ce, HIGH);
delayMicroseconds(20);
digitalWrite(_ce, LOW);
}
void nRF24L01::enablePipe(int pipe, uint8_t *addr, boolean aa) {
uint8_t pw = 0x03;
regSet(REG_EN_RXADDR, pipe);
regWrite(REG_SETUP_AW, &pw, 1);
regWrite(REG_RX_ADDR_P0 + pipe, addr, 5);
regWrite(REG_RX_PW_P0 + pipe, &_pipeWidth, 1);
if (aa) {
regSet(REG_EN_AA, pipe);
} else {
regClr(REG_EN_AA, pipe);
}
}
void nRF24L01::isrHandler() {
uint8_t isrstat = 0;
uint8_t fifostat = 0;
regRead(REG_STATUS, &isrstat, 1);
regRead(REG_FIFO_STATUS, &fifostat, 1);
// TX done
if (isrstat & (1<<5)) {
selectRX();
enablePipe(0, _bc, false);
enablePipe(1, _addr, true);
}
// Did we receive data?
if (isrstat & (1<<6)) {
// We're not actually going to do anything here.
}
if (isrstat & (1<<4)) {
// Too many retries
selectRX();
enablePipe(0, _bc, false);
enablePipe(1, _addr, true);
uint32_t s = disableInterrupts();
digitalWrite(_csn, LOW);
_status = _spi->transfer(CMD_TX_FLUSH);
digitalWrite(_csn, HIGH);
restoreInterrupts(s);
}
// Clear interrupts
isrstat = 0x70;
regWrite(REG_STATUS, &isrstat, 1);
}
/*
* Put MMA8453Q into active mode
* */
void activeMode()
{
byte reg;
byte activeMask = 0x01;
//regRead(REG_CTRL_REG1, ®);
regWrite(REG_CTRL_REG1, reg | activeMask);
}
/*
* Put MMA8453Q into standby mode
* */
void standbyMode()
{
byte reg;
byte activeMask = 0x01;
//regRead(REG_CTRL_REG1, ®);
regWrite(REG_CTRL_REG1, reg & ~activeMask);
}
/*
* Use default mode (high resolution mode)
* The acceleration readings will be
* 10 bits in this mode.
* */
void hiResMode()
{
byte reg;
byte fastModeMask = 0x02;
//regRead(REG_CTRL_REG1, ®);
regWrite(REG_CTRL_REG1, reg & ~fastModeMask);
}
/*********************************************************************
; F U N C T I O N D E S C R I P T I O N
;---------------------------------------------------------------------
; NAME:
; DESCRIPTION:
; Input:
; Output:
; Used global variables:
; REMARKS when using this function:
;*********************************************************************/
void SetYX(uint8_t y, uint8_t x)
{
uint8_t th1, th2;
uint8_t msg[2];
Err_t err;
uint8_t errp, param, parcount;
th2 = (uint8_t)(acos(
(pow(x, 2) + pow(y, 2) - pow(AXLE_LEN, 2) - pow(AXLE_LEN, 2)) / (2 * AXLE_LEN * AXLE_LEN)) * 180.0
/ PI);
th1 = (uint8_t)(asin(
(y * (AXLE_LEN - AXLE_LEN * cos(th2)) - x * AXLE_LEN * sin(th2)) / (pow(x, 2) + pow(y, 2))) * 180.0
/ PI);
msg[0] = (uint8_t)AngleLookupTable[th1];
msg[1] = (uint8_t)(AngleLookupTable[th1] >> 8);
regWrite(servoTable[2], GOALPOSITION_L, 2, msg);
while (!(UCSR0A & (1 << TXC0)))
;
msg[0] = (uint8_t)AngleLookupTable[th2];
msg[1] = (uint8_t)(AngleLookupTable[th2] >> 8);
regWrite(servoTable[3], GOALPOSITION_L, 2, msg);
while (!(UCSR0A & (1 << TXC0)))
;
action();
//printf("TH0: %d; TH1: %d\n", th[0], th[1]);
//turnMotor(servoTable[1], th[0]);
//turnMotor(servoTable[2], th[1]);
// msg[0] = (uint8_t)AngleLookupTable[th1];
// msg[1] = (uint8_t)(AngleLookupTable[th1] >> 8);
// regWrite(servoTable[1], GOALPOSITION_L, 2, msg);
//
// msg[0] = (uint8_t)AngleLookupTable[th2];
// msg[1] = (uint8_t)(AngleLookupTable[th2] >> 8);
// regWrite(servoTable[2], GOALPOSITION_L, 2, msg);
//
// action();
//printf("TH0: %d; TH1: %d\n", th[0], th[1]);
//turnMotor(servoTable[1], th[0]);
//turnMotor(servoTable[2], th[1]);
}
int main (int argc, char* argv[]) {
DWORD SIS3320_BASE = 0x30000000;
MVME_INTERFACE *myvme;
uint32_t data, armed;
int status, i;
if (argc>1) {
sscanf(argv[1],"%lx",&SIS3320_BASE);
}
// Test under vmic
status = mvme_open(&myvme, 0);
sis3320_Setup(myvme, SIS3320_BASE, 1);
// regWrite(myvme, SIS3320_BASE, SIS3320_START_DELAY, 0x20); // PreTrigger
regWrite(myvme, SIS3320_BASE, SIS3320_STOP_DELAY, 0x80); // PostTrigger
regWrite(myvme, SIS3320_BASE, SIS3320_KEY_ARM, 0x0); // Arm Sampling
armed = regRead(myvme, SIS3320_BASE, SIS3320_ACQUISTION_CONTROL);
armed &= 0x10000;
printf("Armed:%x\n", armed);
while (armed) {
armed = regRead(myvme, SIS3320_BASE, SIS3320_ACQUISTION_CONTROL);
armed &= 0x10000;
// printf("Armed:%x\n", armed);
};
for (i=0;i<256;i++) {
data = regRead(myvme, SIS3320_BASE, SIS3320_ADC1_OFFSET + (i<<2));
printf("Data[0x%8.8x]=0x%x\n", SIS3320_BASE+SIS3320_ADC1_OFFSET+(i<<2), data);
}
// regWrite(myvme, SIS3320_BASE, SIS3320_KEY_DISARM, 0x0); // DisArm Sampling
status = mvme_close(myvme);
return 1;
}
void setup()
{
i2c_begin();
standbyMode(); //register settings must be made in standby mode
regWrite(REG_XYZ_DATA_CFG, FULL_SCALE_RANGE_2g);
hiResMode(); //this is the default setting and can be omitted.
//lowResMode(); //set to low res (fast mode), must use getAccXYZ(,,,false) to retrieve readings.
activeMode();
byte b;
//regRead(REG_WHO_AM_I, &b);
}
void SDICameraControl::write(const byte data[], int dataLength) const {
if(shieldInitialized) {
// Ensure any pending writes are complete before writing new data
flushWrite();
// Set up control override length and data
regWrite8(kRegOCLENGTH, dataLength);
regWrite(kRegOCDATA, data, dataLength);
// Arm the control override bank
regWrite8(kRegOCARM, kRegOCARM_ARM_Mask);
} else {
memcpy(outputBuffer, data, dataLength);
outputLength = dataLength;
}
}
void setupL3G4200D(int scale)
{
//From Jim Lindblom of Sparkfun's code
// Enable x, y, z and turn off power down:
uint8_t byteToWrite1 = 0b00001111;
uint8_t byteToWrite2 = 0b00001000;
uint8_t byteToWrite3 = 0b00000000;
uint8_t byteToWrite4 = 0b00010000;
uint8_t byteToWrite5 = 0b00110000;
uint8_t byteToWrite6 = 0b00000000;
uint8_t byteToWrite7 = 0b00000000;
regWrite(L3G4200D_Address, CTRL_REG1, byteToWrite1);
// If you'd like to adjust/use the HPF, you can edit the line below to configure CTRL_REG2:
regWrite(L3G4200D_Address, CTRL_REG2, byteToWrite6);
// Configure CTRL_REG3 to generate data ready interrupt on INT2
// No interrupts used on INT1, if you'd like to configure INT1
// or INT2 otherwise, consult the datasheet:
regWrite(L3G4200D_Address, CTRL_REG3, byteToWrite2);
// CTRL_REG4 controls the full-scale range, among other things:
if(scale == 250)
{
regWrite(L3G4200D_Address, CTRL_REG4, byteToWrite3);
}
else
{
regWrite(L3G4200D_Address, CTRL_REG4, byteToWrite4);
}
// CTRL_REG5 controls high-pass filtering of outputs, use it
// if you'd like:
regWrite(L3G4200D_Address, CTRL_REG5, byteToWrite7);
}
/**
* Initiating the Pozyx shield and test the shield
*/
int PozyxClass::begin(boolean print_result, int mode, int interrupts, int interrupt_pin){
int status = POZYX_SUCCESS;
if(print_result){
Serial.println("Pozyx Shield");
Serial.println("------------");
}
// check if the mode parameter is valid
if((mode != MODE_POLLING) && (mode != MODE_INTERRUPT))
return POZYX_FAILURE;
// check if the pin is valid
if((interrupt_pin != 0) && (interrupt_pin != 1))
return POZYX_FAILURE;
Wire.begin();
// wait a bit until the pozyx board is up and running
delay(250);
_mode = mode;
uint8_t whoami, selftest;
uint8_t regs[3];
regs[2] = 0x12;
// we read out the first 3 register values: who_am_i, firmware_version and harware version, respectively.
if(regRead(POZYX_WHO_AM_I, regs, 3) == POZYX_FAILURE){
return POZYX_FAILURE;
}
whoami = regs[0];
_sw_version = regs[1];
_hw_version = regs[2];
if(print_result){
Serial.print("WhoAmI: 0x");
Serial.println(whoami, HEX);
Serial.print("SW ver.: ");
Serial.println(_sw_version);
Serial.print("HW ver.: ");
Serial.println(_hw_version);
}
// verify if the whoami is correct
if(whoami != 0x43) {
// possibly the pozyx is not connected right. Also make sure the jumper of the boot pins is present.
status = POZYX_FAILURE;
}
// readout the selftest registers to validate the proper functioning of pozyx
if(regRead(POZYX_ST_RESULT, &selftest, 1) == POZYX_FAILURE){
return POZYX_FAILURE;
}
if(print_result){
Serial.print("selftest: 0b");
Serial.println(selftest, BIN);
}
if((_hw_version & POZYX_TYPE) == POZYX_TAG)
{
// check if the uwb, pressure sensor, accelerometer, magnetometer and gyroscope are working
if(selftest != 0b00111111) {
status = POZYX_FAILURE;
}
}else if((_hw_version & POZYX_TYPE) == POZYX_ANCHOR)
{
// check if the uwb transceiver and pressure sensor are working
if(selftest != 0b0011000) {
status = POZYX_FAILURE;
}
return status;
}
// set everything ready for interrupts
_interrupt = 0;
if(_mode == MODE_INTERRUPT){
// set the function that must be called upon an interrupt
attachInterrupt(interrupt_pin, IRQ, RISING);
// use interrupt as provided and initiate the interrupt mask
uint8_t int_mask = interrupts;
if (interrupt_pin == 1){
int_mask |= POZYX_INT_MASK_PIN;
}
if (regWrite(POZYX_INT_MASK, &int_mask, 1) == POZYX_FAILURE){
return POZYX_FAILURE;
}
}
// all done
delay(POZYX_DELAY_LOCAL_WRITE);
return status;
}
void regMakeNull(Register reg)
{
regWrite(reg, objMakeNull());
}
void nRF24L01::regClr(uint8_t reg, uint8_t bit) {
uint8_t val;
regRead(reg, &val, 1);
val &= ~(1<<bit);
regWrite(reg, &val, 1);
}
void nRF24L01::regSet(uint8_t reg, uint8_t bit) {
uint8_t val;
regRead(reg, &val, 1);
val |= (1<<bit);
regWrite(reg, &val, 1);
}
void regCopyNull(Register reg, Register regNull)
{
regWrite(reg, objCopyNull(regRead(regNull)));
}
void sis3320_Reset(MVME_INTERFACE *mvme, uint32_t base)
{
regWrite(mvme, base, SIS3320_KEY_RESET, 0);
}
void nRF24L01::setChannel(uint8_t chan) {
regWrite(REG_RF_CH, &chan, 1);
}
void nRF24L01::begin(uint8_t ad0, uint8_t ad1, uint8_t ad2, uint8_t ad3, uint8_t ad4, uint8_t chan, uint8_t width) {
_spi->begin();
_spi->setSpeed(10000000UL);
_addr[0] = ad0;
_addr[1] = ad1;
_addr[2] = ad2;
_addr[3] = ad3;
_addr[4] = ad4;
_pipeWidth = width;
pinMode(_csn, OUTPUT);
pinMode(_ce, OUTPUT);
pinMode(_intr, INPUT);
digitalWrite(_csn, HIGH);
digitalWrite(_ce, HIGH);
setChannel(chan);
regSet(REG_CONFIG, 2);
uint8_t zero = 0x00;
regWrite(REG_EN_AA, &zero, 1);
_bc[0] = 0xFF;
_bc[1] = 0xFF;
_bc[2] = 0xFF;
_bc[3] = 0xFF;
_bc[4] = 0xFF;
enablePipe(0, _bc, false);
enablePipe(1, _addr, true);
selectRX();
switch (isrHandlerCounter) {
case 0:
isrObject0 = this;
attachInterrupt(_intr, nRF24L01_isrHandler0, FALLING);
break;
case 1:
isrObject1 = this;
attachInterrupt(_intr, nRF24L01_isrHandler1, FALLING);
break;
case 2:
isrObject2 = this;
attachInterrupt(_intr, nRF24L01_isrHandler2, FALLING);
break;
case 3:
isrObject3 = this;
attachInterrupt(_intr, nRF24L01_isrHandler3, FALLING);
break;
case 4:
isrObject4 = this;
attachInterrupt(_intr, nRF24L01_isrHandler4, FALLING);
break;
case 5:
isrObject5 = this;
attachInterrupt(_intr, nRF24L01_isrHandler5, FALLING);
break;
case 6:
isrObject6 = this;
attachInterrupt(_intr, nRF24L01_isrHandler6, FALLING);
break;
case 7:
isrObject7 = this;
attachInterrupt(_intr, nRF24L01_isrHandler7, FALLING);
break;
}
isrHandlerCounter++;
uint32_t s = disableInterrupts();
digitalWrite(_csn, LOW);
_status = _spi->transfer(CMD_TX_FLUSH);
digitalWrite(_csn, HIGH);
digitalWrite(_csn, LOW);
_status = _spi->transfer(CMD_RX_FLUSH);
digitalWrite(_csn, HIGH);
restoreInterrupts(s);
uint8_t isrstat = 0x70;
regWrite(REG_STATUS, &isrstat, 1);
isrstat = 0xFF;
regWrite(REG_SETUP_RETR, &isrstat, 1);
enablePower();
}
void regMakeSymbol(Register reg, char* symbol)
{
regWrite(reg, objMakeSymbol(symbol));
}
void sis3320_RegisterWrite(MVME_INTERFACE *mvme, uint32_t base, int offset, uint32_t value)
{
regWrite(mvme, base, offset, value);
}
int rhinoProcessing(RhinoT *rhinoDevicePtr, RegisterT *rhinoRegistersPtr, server_stateT *st)
{
printf("GETTING INTO RHINO PROCESSING\n");
//RegisterT *rhinoRegistersPtr;
client_msg_T *cm, readMessage;
server_msg_T *sm, writeMessage;
reg_msg_T *rm,regMessage;
int rr, wr;
int counter=0;
int successBit;
uint16_t dataFromReg;
int state = 0;
RegisterT dummyRegister;
cm = &readMessage;
sm = &writeMessage;
rm = ®Message;
int client_send;
for(;;)
{
if(st->s_magic != SERVER_MAGIC){
printf("%s: bad magic on server state\n", __func__);
}
printf("%s:SERVER ABOUT TO RECEIVE\n", __func__);
rr = recv(st->client_socket, cm, sizeof(readMessage), 0);
//printf("CLIENT PACKET RECIEVED\n");
//client_send = send(st->client_socket, cm, sizeof(readMessage), MSG_NOSIGNAL);
//printf("CLIENT PACKET SENT\n");
if(rr < 0){
switch(errno){
case EAGAIN :
case EINTR :
return 0;
case ECONNRESET:
printf("A connection was forcibly closed by a peer\n");
return 0;
case ENOTCONN:
printf("A receive is attempted on a connection-mode socket that is not connected\n");
return 0;
case ETIMEDOUT:
printf("The connection timed out during connection establishment, or due to a transmission timeout on active connection\n");
return 0;
default :
error("tcp receive failed");
return 0;
}
}
else if (rr ==0)
{
printf("CLIENT DISCONNECTED GRACEFULLY\n");
return 0;
}
printf("%s:server receive finished\n", __func__);
cm->rhinoID = ntohl(cm->rhinoID);
strncpy(cm->regName, cm->regName, sizeof(cm->regName)-1);
cm->regName[32] = '\0';
cm->data = ntohs(cm->data);
cm->messageID = ntohl(cm->messageID);
printf("USERNAME FROM THE NETWORK: [%s]\n",cm->userName);
strncpy(cm->userName, cm->userName, sizeof(cm->userName)-1);
cm->userName[16] = '\0';
printf("Client_MsgID IS: %d\n",cm->messageID);
printf("Client_RHINOID IS: %d\n",cm->rhinoID);
printf("Client_REG_NAME IS: %s\n",cm->regName);
printf("Client_DATA IS: %d\n",cm->data);
printf("Client_USER_NAME: %s\n", cm->userName);
printf("\n");
state = cm->messageID;
switch (state){
case LOAD_BOF_FILE: //THIRD CASE IS startBofFile
printf("%s:server case tested SUCCESS OVERAALL\n", __func__);
printf("\n");
successBit = -1;
rhinoDevicePtr->successBit = -1;
rhinoDevicePtr = (RhinoT *)startBofFile(cm->rhinoID, cm->userName, cm->regName, rhinoDevicePtr, st);
if(rhinoDevicePtr == NULL)
{
printf("%s:WARNING NULL return\n", __func__);
return 1;
break;
}
//printf("I RETURNED AND ABOUT TO SLEEP\n");
//sleep(10);
//NEED TO SEND UPDATED FPGA PROGRAMMED BIT TO RHINO
strncpy(sm ->rhinoBoard.errorMsg, rhinoDevicePtr->errorMsg, sizeof(sm->rhinoBoard.errorMsg)-1);
sm->rhinoBoard.errorMsg[256] = '\0';
printf("RHINO ERROR MSG [%s]\n", sm->rhinoBoard.errorMsg);
sm->rhinoBoard.busyBit = htonl(rhinoDevicePtr->busyBit);
printf("RHINO BUSYBIT FROM RHINODEVICEPTR: [%d]\n",rhinoDevicePtr->busyBit);
//printf("RHINO BUSYBIT: [%d]\n",sm->rhinoBoard.busyBit);
sm->rhinoBoard.nameNumber = htonl(rhinoDevicePtr->nameNumber);
printf("RHINO NAME NUMBER:[%d]\n",sm->rhinoBoard.nameNumber);
//sm->rhinoBoard.ipAddress = rhinoDevicePtr->ipAddress;
strncpy(sm->rhinoBoard.ipAddress,rhinoDevicePtr->ipAddress,sizeof(sm->rhinoBoard.ipAddress)-1);
sm->rhinoBoard.ipAddress[16] = '\0';
printf("THE IP ADDRESS OF THE RHINO IS: [%s]\n", sm->rhinoBoard.ipAddress);
sm->rhinoBoard.successBit = htonl(rhinoDevicePtr->successBit);
printf("RHINO SUCCESS BIT: [%d]\n",sm->rhinoBoard.successBit);
sm->data = htons(0);
wr = send(st->client_socket, sm, sizeof(writeMessage), MSG_NOSIGNAL);
if(wr < sizeof(writeMessage))
{
switch(errno){
case EAGAIN :
case EINTR :
return 0;
default :
printf("unable to send request: %s", strerror(errno));
break;
}
}
state = NONE;
printf("MESSAGE JUST SENT\n");
printf("\n");
break;
case REGISTER_WRITE:
printf("%s:server case tested SUCCESS OVERAALL\n", __func__); //WHAT DOES THIS DO???????????????ASK????/
printf("\n");
successBit = -1;
rhinoDevicePtr->successBit = -1;
rhinoDevicePtr = (RhinoT *)regWrite(cm->rhinoID, cm->regName, cm->data, rhinoDevicePtr, st);
if(rhinoDevicePtr == NULL)
{
printf("%s:WARNING NULL return\n", __func__);
return 1;
break;
}
//printf("I RETURNED AND ABOUT TO SLEEP\n");
//sleep(10);
//NEED TO SEND UPDATED FPGA PROGRAMMED BIT TO RHINO
sm->rhinoBoard.busyBit = htonl(rhinoDevicePtr->busyBit);
printf("RHINO BUSYBIT: [%d]\n",sm->rhinoBoard.busyBit);
sm->rhinoBoard.nameNumber = htonl(rhinoDevicePtr->nameNumber);
printf("RHINO NAME NUMBER:[%d]\n",sm->rhinoBoard.nameNumber);
//sm->rhinoBoard.ipAddress = rhinoDevicePtr->ipAddress;
strncpy(sm->rhinoBoard.ipAddress,rhinoDevicePtr->ipAddress,sizeof(sm->rhinoBoard.ipAddress)-1);
sm->rhinoBoard.ipAddress[16] = '\0';
printf("THE IP ADDRESS OF THE RHINO IS: [%s]\n", sm->rhinoBoard.ipAddress);
sm->rhinoBoard.registersAccessible.readWriteBit = rhinoRegistersPtr->readWriteBit;
printf("THE RHINO REGISTER READWRITE BIT IS: [%d]\n", sm->rhinoBoard.registersAccessible.readWriteBit);
strncpy(sm->rhinoBoard.registersAccessible.regName,rhinoRegistersPtr->regName,sizeof(sm->rhinoBoard.registersAccessible.regName)-1);
sm->rhinoBoard.registersAccessible.regName[32] = '\0';
printf("THE RHINO REGISTER NAME IS: [%s]\n", sm->rhinoBoard.registersAccessible.regName);
sm->rhinoBoard.registersAccessible.rhinoNameNumber = rhinoRegistersPtr->rhinoNameNumber;
sm->rhinoBoard.successBit = htonl(rhinoDevicePtr->successBit);
printf("RHINO SUCCESS BIT: [%d]\n",sm->rhinoBoard.successBit);
sm->data = htons(0);
wr = send(st->client_socket, sm, sizeof(writeMessage), MSG_NOSIGNAL);
if(wr < sizeof(writeMessage))
{
switch(errno){
case EAGAIN :
case EINTR :
return 0;
default :
printf("unable to send request: %s", strerror(errno));
break;
}
}
state = NONE;
printf("MESSAGE JUST SENT\n");
printf("\n");
break;
case REGISTER_READ:
printf("%s:server case tested SUCCESS OVERAALL\n", __func__); //WHAT DOES THIS DO???????????????ASK????/
printf("\n");
dataFromReg = (uint16_t)regRead(cm->rhinoID,cm->regName , rhinoDevicePtr, st);
if(dataFromReg < 0)
{
printf("%s:WARNING NULL return\n", __func__);
return 1;
break;
}
//printf("I RETURNED AND ABOUT TO SLEEP\n");
//sleep(10);
//NEED TO SEND UPDATED FPGA PROGRAMMED BIT TO RHINO
sm->rhinoBoard.busyBit = htonl(rhinoDevicePtr->busyBit);
printf("RHINO BUSYBIT: [%d]\n",sm->rhinoBoard.busyBit);
sm->rhinoBoard.nameNumber = htonl(rhinoDevicePtr->nameNumber);
printf("RHINO NAME NUMBER:[%d]\n",sm->rhinoBoard.nameNumber);
//sm->rhinoBoard.ipAddress = rhinoDevicePtr->ipAddress;
strncpy(sm->rhinoBoard.ipAddress,rhinoDevicePtr->ipAddress,sizeof(sm->rhinoBoard.ipAddress)-1);
sm->rhinoBoard.ipAddress[16] = '\0';
printf("THE IP ADDRESS OF THE RHINO IS: [%s]\n", sm->rhinoBoard.ipAddress);
sm->rhinoBoard.registersAccessible.readWriteBit = rhinoRegistersPtr->readWriteBit;
printf("THE RHINO REGISTER READWRITE BIT IS: [%d]\n", sm->rhinoBoard.registersAccessible.readWriteBit);
strncpy(sm->rhinoBoard.registersAccessible.regName,rhinoRegistersPtr->regName,sizeof(sm->rhinoBoard.registersAccessible.regName)-1);
sm->rhinoBoard.registersAccessible.regName[32] = '\0';
printf("THE RHINO REGISTER NAME IS: [%s]\n", sm->rhinoBoard.registersAccessible.regName);
sm->rhinoBoard.registersAccessible.rhinoNameNumber = rhinoRegistersPtr->rhinoNameNumber;
sm->rhinoBoard.successBit = htonl(1);
printf("RHINO SUCCESS BIT: [%d]\n",sm->rhinoBoard.successBit);
sm->data = htons(dataFromReg);
wr = send(st->client_socket, sm, sizeof(writeMessage), MSG_NOSIGNAL);
if(wr < sizeof(writeMessage))
{
switch(errno){
case EAGAIN :
case EINTR :
return 0;
default :
printf("unable to send request: %s", strerror(errno));
break;
}
}
state = NONE;
printf("MESSAGE JUST SENT\n");
printf("\n");
break;
case LIST_REGISTERS:
counter = 0;
printf("%s:server case tested SUCCESS OVERAALL\n", __func__); //WHAT DOES THIS DO???????????????ASK????/
printf("\n");
rhinoRegistersPtr = listRegisters(cm->rhinoID, cm->userName, cm->regName, st);
if(rhinoRegistersPtr == NULL)
{
printf("%s:WARNING NULL return\n", __func__);
return 1;
break;
}
//printf("I RETURNED AND ABOUT TO SLEEP\n");
//sleep(10);
//NEED TO SEND UPDATED FPGA PROGRAMMED BIT TO RHINO
sm->rhinoBoard.busyBit = htonl(rhinoDevicePtr->busyBit);
printf("RHINO BUSYBIT: [%d]\n",sm->rhinoBoard.busyBit);
sm->rhinoBoard.nameNumber = htonl(rhinoDevicePtr->nameNumber);
printf("RHINO BUSYBIT: [%d]\n",sm->rhinoBoard.busyBit);
//sm->rhinoBoard.ipAddress = rhinoDevicePtr->ipAddress;
strncpy(sm->rhinoBoard.ipAddress,rhinoDevicePtr->ipAddress,sizeof(sm->rhinoBoard.ipAddress)-1);
sm->rhinoBoard.ipAddress[16] = '\0';
printf("THE IP ADDRESS OF THE RHINO IS: [%s]\n", sm->rhinoBoard.ipAddress);
strncpy(sm->rhinoBoard.registersAccessible.regName,rhinoRegistersPtr[counter].regName,sizeof(sm->rhinoBoard.registersAccessible.regName)-1);
sm->rhinoBoard.registersAccessible.regName[32] = '\0';
printf("THE RHINO REGISTER NAME IS: [%s]\n", sm->rhinoBoard.registersAccessible.regName);
sm->rhinoBoard.registersAccessible.readWriteBit =htonl(rhinoRegistersPtr[counter].readWriteBit);
printf("THE RHINO REGISTER READWRITEBIT IS: [%d]\n", sm->rhinoBoard.registersAccessible.readWriteBit);
sm->rhinoBoard.registersAccessible.rhinoNameNumber = htonl(rhinoRegistersPtr[counter].rhinoNameNumber);
printf("THE RHINO REGISTER NAMENUMBER IS: [%d]\n", sm->rhinoBoard.registersAccessible.rhinoNameNumber);
sm->rhinoBoard.registersAccessible.size = htonl(rhinoRegistersPtr[counter].size);
printf("THE RHINO REGISTER SIZE IS: [%x]\n", sm->rhinoBoard.registersAccessible.size);
sm->rhinoBoard.successBit = htonl(1);
printf("RHINO SUCCESS BIT: [%d]\n",sm->rhinoBoard.successBit);
sm->data = htons(dataFromReg);
//FIRST CHECKING THAT THE REGISTER IS NOT NULL
if(rhinoRegistersPtr == NULL)
{
wr = send(st->client_socket, sm, sizeof(writeMessage), MSG_NOSIGNAL);
if(wr < sizeof(writeMessage))
{
switch(errno){
case EAGAIN :
case EINTR :
return 0;
default :
printf("unable to send request: %s", strerror(errno));
break;
}
}
state = NONE;
printf("MESSAGE JUST SENT WITH FIRST REGISTER\n");
}
else if(rhinoRegistersPtr!= NULL) // THERE ARE REGISTERS ON THE PROCESS AND LOOP TILL THEY ARE NULL
{
wr = send(st->client_socket, sm, sizeof(writeMessage), MSG_NOSIGNAL);
if(wr < sizeof(writeMessage))
{
switch(errno){
case EAGAIN :
case EINTR :
return 0;
default :
printf("unable to send request: %s", strerror(errno));
break;
}
}
printf("MESSAGE JUST SENT WITH FIRST REGISTER\n");
for(counter +=1 ; counter< regCounter+1; counter++) //SENDS EVERY PACKET INCLUDING THE NULL ONE AS WELL
{
rm->registersAccessible.readWriteBit = htonl(rhinoRegistersPtr[counter].readWriteBit);
printf("THE RHINO REGISTER READWRITE BIT IS: [%d]\n", rm->registersAccessible.readWriteBit);
strncpy(rm->registersAccessible.regName,rhinoRegistersPtr[counter].regName,sizeof(rm->registersAccessible.regName)-1);
rm->registersAccessible.regName[32] = '\0';
printf("THE RHINO REGISTER NAME IS: [%s]\n", rm->registersAccessible.regName);
rm->registersAccessible.rhinoNameNumber = htonl(rhinoRegistersPtr[counter].rhinoNameNumber);
printf("THE RHINO REGISTER NAMENUMBER IS: [%d]\n", rm->registersAccessible.rhinoNameNumber);
rm->registersAccessible.size = htonl(rhinoRegistersPtr[counter].size);
printf("THE RHINO REGISTER SIZE IS: [%x]\n", rm->registersAccessible.size);
wr = send(st->client_socket, rm, sizeof(regMessage), MSG_NOSIGNAL);
if(wr < sizeof(regMessage))
{
switch(errno){
case EAGAIN :
case EINTR :
return 0;
default :
printf("unable to send request: %s", strerror(errno));
break;
}
}
state = NONE;
printf("MESSAGE JUST SENT WITH ANOTHER REGISTER\n");
}
}
printf("SENT ALL THE REGISTERS\n");
printf("\n");
break;
case KILL_BOF_PROCESS:
printf("%s:server case tested SUCCESS OVERAALL\n", __func__);
printf("\n");
successBit = -1;
rhinoDevicePtr->successBit = -1;
rhinoDevicePtr = (RhinoT *)stopBofFile(cm->rhinoID, cm->regName, rhinoDevicePtr, st);
if(rhinoDevicePtr == NULL)
{
printf("%s:WARNING NULL return\n", __func__);
return 1;
break;
}
//printf("I RETURNED AND ABOUT TO SLEEP\n");
//sleep(10);
//NEED TO SEND UPDATED FPGA PROGRAMMED BIT TO RHINO
sm->rhinoBoard.busyBit = htonl(rhinoDevicePtr->busyBit);
printf("RHINO BUSYBIT: [%d]\n",sm->rhinoBoard.busyBit);
sm->rhinoBoard.nameNumber = htonl(rhinoDevicePtr->nameNumber);
printf("RHINO NAME NUMBER:[%d]\n",sm->rhinoBoard.nameNumber);
//sm->rhinoBoard.ipAddress = rhinoDevicePtr->ipAddress;
strncpy(sm->rhinoBoard.ipAddress,rhinoDevicePtr->ipAddress,sizeof(sm->rhinoBoard.ipAddress)-1);
sm->rhinoBoard.ipAddress[16] = '\0';
printf("THE IP ADDRESS OF THE RHINO IS: [%s]\n", sm->rhinoBoard.ipAddress);
sm->rhinoBoard.registersAccessible.readWriteBit = rhinoRegistersPtr->readWriteBit;
printf("THE RHINO REGISTER READWRITE BIT IS: [%d]\n", sm->rhinoBoard.registersAccessible.readWriteBit);
strncpy(sm->rhinoBoard.registersAccessible.regName,rhinoRegistersPtr->regName,sizeof(sm->rhinoBoard.registersAccessible.regName)-1);
sm->rhinoBoard.registersAccessible.regName[16] = '\0';
printf("THE RHINO REGISTER NAME IS: [%s]\n", sm->rhinoBoard.registersAccessible.regName);
sm->rhinoBoard.registersAccessible.rhinoNameNumber = rhinoRegistersPtr->rhinoNameNumber;
sm->rhinoBoard.successBit = htonl(rhinoDevicePtr->successBit);
printf("RHINO SUCCESS BIT: [%d]\n",sm->rhinoBoard.successBit);
sm->data = htons(0);
wr = send(st->client_socket, sm, sizeof(writeMessage), MSG_NOSIGNAL);
if(wr < sizeof(writeMessage))
{
switch(errno){
case EAGAIN :
case EINTR :
return 0;
default :
printf("unable to send request: %s", strerror(errno));
break;
}
}
state = NONE;
printf("MESSAGE JUST SENT\n");
printf("\n");
break;
default:
printf("NO CASE IN RHINOPROCESSING \n");
break;
}
}
return 2;
}
/**
Sets all the necessary paramters for a given configuration.
The configuration is provided by the mode argument.
Add your own configuration in the case statement. Let me know
your setting if you want to include it in the distribution.
@param *mvme VME structure
@param base Module base address
@param mode Configuration mode number
@param *nentry number of entries requested and returned.
@return MVME_SUCCESS
*/
int sis3320_Setup(MVME_INTERFACE *mvme, uint32_t base, int mode)
{
switch (mode) {
case 0x1:
printf("--------------------------------------------\n");
printf("200Msps 1evt (mode:%d)\n", mode);
printf("Sample Length Stop, Sample Length 256\n");
printf("Sample Start Address 0x0\n");
printf("ADC input mode 32bits\n");
printf("Trigger from LEMO\n");
printf("--------------------------------------------\n");
regWrite(mvme, base, SIS3320_MAX_NOF_EVENT, 1);
regWrite(mvme, base, SIS3320_EVENT_CONFIG_ALL_ADC, EVENT_CONF_ENABLE_SAMPLE_LENGTH_STOP);
regWrite(mvme, base, SIS3320_SAMPLE_LENGTH_ALL_ADC, 0x1FC); // 0x200 or 512
regWrite(mvme, base, SIS3320_SAMPLE_START_ADDRESS_ALL_ADC, 0x0);
regWrite(mvme, base, SIS3320_ADC_INPUT_MODE_ALL_ADC, 0x20000);
regWrite(mvme, base, SIS3320_ACQUISTION_CONTROL
, SIS3320_ACQ_SET_CLOCK_TO_200MHZ | SIS3320_ACQ_ENABLE_LEMO_START_STOP);
printf("\n");
break;
case 0x2:
printf("--------------------------------------------\n");
printf("50Msps 1evt (mode:%d)\n", mode);
printf("Sample Length Stop, Sample Length 256\n");
printf("Sample Start Address 0x0\n");
printf("ADC input mode 32bits\n");
printf("Trigger from LEMO\n");
printf("--------------------------------------------\n");
regWrite(mvme, base, SIS3320_MAX_NOF_EVENT, 1);
regWrite(mvme, base, SIS3320_EVENT_CONFIG_ALL_ADC, EVENT_CONF_ENABLE_SAMPLE_LENGTH_STOP);
regWrite(mvme, base, SIS3320_SAMPLE_LENGTH_ALL_ADC, 0x1FC); // 0x200 or 512
regWrite(mvme, base, SIS3320_SAMPLE_START_ADDRESS_ALL_ADC, 0x0);
regWrite(mvme, base, SIS3320_ADC_INPUT_MODE_ALL_ADC, 0x20000);
regWrite(mvme, base, SIS3320_ACQUISTION_CONTROL
, SIS3320_ACQ_SET_CLOCK_TO_50MHZ | SIS3320_ACQ_ENABLE_LEMO_START_STOP);
printf("\n");
break;
default:
printf("Unknown setup mode\n");
return -1;
}
sis3320_Status(mvme, base);
return 0;
}
void isegvhs_RegisterWrite(MVME_INTERFACE *mvme, DWORD base, int offset, uint32_t value)
{
regWrite(mvme,base,offset,value);
}
