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);
}
void sis3320_Status(MVME_INTERFACE *mvme, uint32_t base)
{
printf("================================================\n");
printf("SIS3320 at A32 0x%x\n", (int)base);
printf("CSR : 0x%8.8x\n", regRead(mvme, base, SIS3320_CONTROL_STATUS));
printf("ModuleID and Firmware: 0x%x\n", regRead(mvme, base, SIS3320_MODID));
printf("Max Event Counter : %d\n", regRead(mvme, base, SIS3320_MAX_NOF_EVENT));
printf("================================================\n");
}
/*
* readRegistry
* Read a file into the registry.
*/
int
readRegistry(int f, int n)
{
meUByte filebuf [meBUF_SIZE_MAX];
meUByte rootbuf [32];
meUByte modebuf [10];
int mode = 0;
/* Get the input from the command line */
if ((meGetString((meUByte *)"Read registry root",0, 0, rootbuf, 32) == meABORT) ||
(((n & 4) == 0) &&
(meGetString((meUByte *)"Registry file",MLFILECASE, 0, filebuf, meBUF_SIZE_MAX) == meABORT)) ||
(meGetString((meUByte *)"File Mode", 0, 0, modebuf, 10) == meABORT))
return meABORT;
/* Get the mode out */
if (regDecodeMode (&mode, modebuf) == meABORT)
return meABORT;
mode &= ~meREGMODE_FROOT ;
if((n & 4) == 0)
mode |= meREGMODE_FROOT ;
/* Read the file */
if(regRead(rootbuf, filebuf, mode) == NULL)
return meFALSE;
return meTRUE;
}
void nRF24L01::unicastPacket(uint8_t *addr, 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, addr, 5);
enablePipe(0, addr, true);
enablePipe(1, _addr, true);
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);
}
/**
* Wait until pozyx has raised a specified event flag until a given timeout
* This function can work in both polled and interupt mode
*/
boolean PozyxClass::waitForFlag(uint8_t interrupt_flag, int timeout_ms)
{
long timer = millis();
// stay in this loop until the event interrupt flag is set or until the the timer runs out
while(millis()-timer < timeout_ms)
{
// in polling mode, we insert a small delay such that we don't swamp the i2c bus
if( _mode == MODE_POLLING ){
delay(1);
}
if( (_interrupt == 1) || (_mode == MODE_POLLING))
{
_interrupt = 0;
// Read out the interrupt status register. After reading from this register, pozyx automatically clears the interrupt flags.
uint8_t interrupt_status = 0;
regRead(POZYX_INT_STATUS, &interrupt_status, 1);
if((interrupt_status & interrupt_flag) == interrupt_flag)
{
// the interrupt we were waiting for arrived!
return true;
}
}
}
// too bad, pozyx didn't respond
// 1) pozyx can select from two pins to generate interrupts, make sure the correct pin is connected with the attachInterrupt() function.
// 2) make sure the interrupt we are waiting for is enabled in the POZYX_INT_MASK register)
return false;
}
int nRF24L01::available() {
uint8_t fifostat = 0;
regRead(REG_FIFO_STATUS, &fifostat, 1);
if (fifostat & (1<<0)) {
return 0;
}
return 1;
}
/*
* Remotly read from a register of another pozyx device
*/
int PozyxClass::remoteRegFunction(uint16_t destination, uint8_t reg_address, uint8_t *params, int param_size, uint8_t *pData, int size)
{
// some checks
if(!IS_FUNCTIONCALL(reg_address)) return POZYX_FAILURE; // the register is not a function
int status = 0;
// first prepare the packet to send
uint8_t tmp_data[param_size+2];
tmp_data[0] = 0;
tmp_data[1] = reg_address; // the first byte is the function register address we want to call.
memcpy(tmp_data+2, params, param_size); // the remaining bytes are the parameter bytes for the function.
status = regFunction(POZYX_TX_DATA, tmp_data, param_size+2, NULL, 0);
// stop if POZYX_TX_DATA returned an error.
if(status == POZYX_FAILURE)
return status;
// send the packet
uint8_t tx_params[3];
tx_params[0] = (uint8_t)destination;
tx_params[1] = (uint8_t)(destination>>8);
tx_params[2] = 0x08; // flag to indicate a register function call
status = regFunction(POZYX_TX_SEND, tx_params, 3, NULL, 0);
// stop if POZYX_TX_SEND returned an error.
if(status == POZYX_FAILURE)
return status;
// wait up to x ms to receive a response
if(waitForFlag(POZYX_INT_STATUS_RX_DATA, POZYX_DELAY_INTERRUPT))
{
// we received a response, now get some information about the response
uint8_t rx_info[3];
regRead(POZYX_RX_NETWORK_ID, rx_info, 3);
uint16_t remote_network_id = rx_info[0] + ((uint16_t)rx_info[1]<<8);
uint8_t data_len = rx_info[2];
if( remote_network_id == destination && data_len == size+1)
{
uint8_t return_data[size+1];
status = readRXBufferData(return_data, size+1);
if(status == POZYX_FAILURE)
return status;
memcpy(pData, return_data+1, size);
return return_data[0];
}
}else{
// timeout
return POZYX_FAILURE;
}
}
void getGyroValues(int *x, int *y, int *z)
{
uint8_t buf[6];
regRead(L3G4200D_Address, &ReadGyroXYZ, buf, 6);
*x = ((buf[1] << 8) | buf[0]);
*y = ((buf[3] << 8) | buf[2]);
*z = ((buf[5] << 8) | buf[4]);
}
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;
}
/*
* Remotly read from a register of another pozyx device
*/
int PozyxClass::remoteRegRead(uint16_t destination, uint8_t reg_address, uint8_t *pData, int size)
{
// some checks
if(!IS_REG_READABLE(reg_address)) return POZYX_FAILURE; // the register is not readable
if(size > MAX_BUF_SIZE) return POZYX_FAILURE; // trying to read too much data
if(destination == 0) return POZYX_FAILURE; // remote read not allowed in broadcast mode
int status = 0;
// first prepare the packet to send
uint8_t tmp_data[3];
tmp_data[0] = 0; // the offset in the TX buffer
tmp_data[1] = reg_address; // the first byte is the register address we want to start reading from
tmp_data[2] = size; // the number of bytes to read starting from the register address
status = regFunction(POZYX_TX_DATA, (uint8_t *)&tmp_data, 3, NULL, 0);
// stop if POZYX_TX_DATA returned an error.
if(status == POZYX_FAILURE)
return status;
// send the packet
uint8_t params[3];
params[0] = (uint8_t)destination;
params[1] = (uint8_t)(destination>>8);
params[2] = 0x02; // flag to indicate a register read
status = regFunction(POZYX_TX_SEND, (uint8_t *)¶ms, 3, NULL, 0);
// stop if POZYX_TX_SEND returned an error.
if(status == POZYX_FAILURE)
return status;
// wait up to x ms to receive a response
if(waitForFlag(POZYX_INT_STATUS_RX_DATA, POZYX_DELAY_INTERRUPT))
{
// we received a response, now get some information about the response
uint8_t rx_info[3]= {0,0,0};
regRead(POZYX_RX_NETWORK_ID, rx_info, 3);
uint16_t remote_network_id = rx_info[0] + ((uint16_t)rx_info[1]<<8);
uint8_t data_len = rx_info[2];
if( remote_network_id == destination && data_len == size)
{
status = readRXBufferData(pData, size);
return status;
}else{
return POZYX_FAILURE;
}
}else{
// timeout
return POZYX_FAILURE;
}
}
int SDICameraControl::read(byte data[], int dataLength) const {
if (!available())
return 0;
// Read control data incoming length and data
int availableLength = regRead16(kRegICLENGTH);
if (availableLength > dataLength)
return -1;
regRead(kRegICDATA, data, availableLength);
// Arm the control data incoming bank
regWrite8(kRegICARM, kRegICARM_ARM_Mask);
return availableLength;
}
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;
}
/**
* 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;
}
char* regGetSymbol(Register reg)
{
return objGetSymbol(regRead(reg));
}
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 isegvhs_Status(MVME_INTERFACE *mvme, DWORD base)
{
uint32_t sn=0, csr;
uint64_t vendor=0;
printf("ISEGVHS at A32 0x%x\n", (int)base);
vendor = (regRead(mvme,base,ISEGVHS_VENDOR_ID)<<16) | regRead(mvme,base,ISEGVHS_VENDOR_ID+2);
printf("Module Vendor : 0x%x%x\n", regRead(mvme,base,ISEGVHS_VENDOR_ID), regRead(mvme,base,ISEGVHS_VENDOR_ID+2));
printf("Module Vendor : %s\t\t", (char *)&vendor);
csr = regRead(mvme,base,ISEGVHS_MODULE_STATUS);
printf("Module Status : 0x%x\n >> ", csr);
printf("%s", csr & 0x0001 ? "FineAdj /" : " NoFineAdj /");
printf("%s", csr & 0x0080 ? "CmdCpl /" : " /");
printf("%s", csr & 0x0100 ? "noError /" : " ERROR /");
printf("%s", csr & 0x0200 ? "noRamp /" : " RAMPING /");
printf("%s", csr & 0x0400 ? "Saf closed /" : " /");
printf("%s", csr & 0x0800 ? "Evt Active /" : " /");
printf("%s", csr & 0x1000 ? "Mod Good /" : " MOD NO good /");
printf("%s", csr & 0x2000 ? "Supply Good /" : " Supply NO good /");
printf("%s\n", csr & 0x4000 ? "Temp Good /" : " Temp NO good /");
printf("Module Control : 0x%x\t\t", regRead(mvme,base,ISEGVHS_MODULE_CONTROL));
sn = regRead(mvme, base, ISEGVHS_SERIAL_NUMBER);
printf("Module S/N : %d\n", (sn<<16)|regRead(mvme, base, ISEGVHS_SERIAL_NUMBER+2));
printf("Module Temp. : %f\t\t", isegvhs_RegisterReadFloat(mvme, base, ISEGVHS_TEMPERATURE));
printf("Module Supply P5 : %f\n", regReadFloat(mvme, base, ISEGVHS_SUPPLY_P5));
printf("Module Supply P12 : %f\t\t", regReadFloat(mvme, base, ISEGVHS_SUPPLY_P12));
printf("Module Supply N12 : %f\n", regReadFloat(mvme, base, ISEGVHS_SUPPLY_N12));
printf("Module Trim V Max : %f\t\t", regReadFloat(mvme, base, ISEGVHS_VOLTAGE_MAX));
printf("Module Trim I Max : %f\n", regReadFloat(mvme, base, ISEGVHS_CURRENT_MAX));
printf("Module Event Stat : 0x%04x\t\t", regRead(mvme, base, ISEGVHS_MODULE_EVENT_STATUS));
printf("Module Event Mask : 0x%04x\n", regRead(mvme, base, ISEGVHS_MODULE_EVENT_MASK));
printf("Channel Event Stat: 0x%04x\t\t", regRead(mvme, base, ISEGVHS_CHANNEL_EVENT_STATUS));
printf("Channel Event Mask: 0x%04x\n\n", regRead(mvme, base, ISEGVHS_CHANNEL_EVENT_MASK));
}
uint32_t isegvhs_RegisterRead(MVME_INTERFACE *mvme, DWORD base, int offset)
{
return regRead(mvme, base, offset);
}
uint32_t sis3320_RegisterRead(MVME_INTERFACE *mvme, uint32_t base, int offset)
{
return regRead(mvme,base,offset);
}
void regHashSymbol(Register result, Register symbol)
{
regMakeNumber(result, objHashSymbol(regRead(symbol)));
}
int main (int argc, char* argv[]) {
uint32_t ISEGVHS_BASE = 0x4000;
MVME_INTERFACE *myvme;
int status, i;
if (argc>1) {
sscanf(argv[1],"%x", &ISEGVHS_BASE);
}
// Test under vmic
status = mvme_open(&myvme, 0);
isegvhs_Status(myvme, ISEGVHS_BASE);
// regWrite(myvme, ISEGVHS_BASE, ISEGVHS_MODULE_CONTROL, 0x40); // doCLEAR
// regWrite(myvme, ISEGVHS_BASE, ISEGVHS_MODULE_CONTROL, 0x1000); // setADJ
// regWrite(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CHANNEL_CONTROL, 0x0);
// printf(" Channel 0: Status :0x%x\n", regRead(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CHANNEL_STATUS));
// printf(" Channel 0: Control :0x%x\n\n", regRead(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CHANNEL_CONTROL));
// regWrite(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CHANNEL_CONTROL, 0x4);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_VOLTAGE_RAMP_SPEED, 5.);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CURRENT_RAMP_SPEED, 6.);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_VOLTAGE_BOUND, 1.0);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_VOLTAGE_NOMINAL, 2000.0);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_VOLTAGE_SET, 0.0);
// regWrite(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CHANNEL_CONTROL, 0x8);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CURRENT_BOUND, 0.022);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+ISEGVHS_CURRENT_NOMINAL, 0.0012);
printf("Chn Vrmp Irmp Vset Vmes Vbnd Vnom IsetmA ImesmA Ibnd CSta CCtl\n");
for (i=0;i<12;i++) {
printf("%02d ", i);
regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_VOLTAGE_BOUND, 0.5);
// regWriteFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_CURRENT_BOUND, 0.004);
printf("%8.2f ", regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_VOLTAGE_RAMP_SPEED));
printf("%8.2f ", regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CURRENT_RAMP_SPEED));
printf("%8.2f ", regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_VOLTAGE_SET));
printf("%8.2f ", regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_VOLTAGE_MEASURE));
printf("%8.2f ", regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_VOLTAGE_BOUND));
printf("%8.2f ", regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_VOLTAGE_NOMINAL));
printf("%8.3f ", 1000.*regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_CURRENT_SET));
printf("%8.3f ", 1000.*regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_CURRENT_MEASURE));
printf("%8.2f ", regReadFloat(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_CURRENT_BOUND));
printf("0x%04x ", regRead(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_CHANNEL_STATUS));
printf("0x%04x ", regRead(myvme, ISEGVHS_BASE, ISEGVHS_CHANNEL_BASE+(i*ISEGVHS_CHANNEL_OFFSET)+ISEGVHS_CHANNEL_CONTROL));
printf("\n");
}
// Close VME
status = mvme_close(myvme);
return 1;
}
void regCopyNull(Register reg, Register regNull)
{
regWrite(reg, objCopyNull(regRead(regNull)));
}
