void RnCheckSelfCh(BYTE channel) { BYTE j =0; uint temp[10]={0}; uint tempp=0; //printf("\r\n channel_%d ",channel); //APOSA for(j=0;j<10;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 100); spiRead(channel, RIF, &tempp, WIDTH_ONE_B); if(tempp&0x01)//更新中断 { break; } } spiRead(channel, POWERPA, &tempp, WIDTH_FOUR_B); temp[j] = tempp; } tempp =MeanValue(temp,10); tempp =(tempp^0xffffffff)+1; tempp =tempp&0xffff; spiWrite(channel, APOSA, tempp, WIDTH_TWO_B); *(WORD *)&SysParam[SP_RNAPOSA+channel*2]=tempp; printf("#"); #if(EleMeterCnt==6) //APOSB for(j=0;j<10;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 100); spiRead(channel, RIF, &tempp, WIDTH_ONE_B); if(tempp&0x01) { break; } } spiRead(channel, POWERPB, &tempp, WIDTH_FOUR_B); temp[j]=tempp; } tempp =MeanValue(temp,10); tempp =(tempp^0xffffffff)+1; tempp =tempp&0xffff; spiWrite(channel, APOSB, tempp, WIDTH_TWO_B); *(WORD *)&SysParam[SP_RNAPOSB+channel*2]=tempp; printf("#"); #endif //rposa/rposb for(j=0;j<10;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 100); spiRead(channel, RIF, &tempp, WIDTH_ONE_B); if(tempp&0x01) { break; } } spiRead(channel, POWERQ, &tempp, WIDTH_FOUR_B); temp[j]=tempp; } tempp =MeanValue(temp,10); tempp =(tempp^0xffffffff)+1; tempp =tempp&0xffff; spiRead(channel, EMUSTATUS, &temp[0], WIDTH_THREE_B); if(temp[0]&0x200000) { spiWrite(channel, RPOSB, tempp, WIDTH_TWO_B); *(WORD *)&SysParam[SP_RNRPOSB+channel*2]=tempp; } else { spiWrite(channel, RPOSA, tempp, WIDTH_TWO_B); *(WORD *)&SysParam[SP_RNRPOSA+channel*2]=tempp; } printf("#"); //iarmsos for(j=0;j<10;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 100); spiRead(channel, RIF, &tempp, WIDTH_ONE_B); if(tempp&0x01) { break; } } spiRead(channel, IARMS, &tempp, WIDTH_THREE_B); temp[j] = tempp; } tempp =MeanValue(temp,10); tempp =tempp*tempp; tempp =(tempp^0xffffffff)+1; tempp =tempp>>8; //tempp =tempp&0xffff; tempp =(tempp&0xffff)|((tempp>>8)&0x8000); spiWrite(channel, IARMSOS, tempp, WIDTH_TWO_B); *(WORD *)&SysParam[SP_RNIARMSOS+channel*2]=tempp; printf("#"); #if(EleMeterCnt==6) //ibrmsos for(j=0;j<10;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 100); spiRead(channel, RIF, &tempp, WIDTH_ONE_B); if(tempp&0x01) { break; } } spiRead(channel, IBRMS, &tempp, WIDTH_THREE_B); temp[j] =tempp; } tempp =MeanValue(temp,10); tempp =tempp*tempp; tempp =(tempp^0xffffffff)+1; tempp =tempp>>8; //tempp =tempp&0xffff; tempp =(tempp&0xffff)|((tempp>>8)&0x8000); spiWrite(channel, IBRMSOS, tempp, WIDTH_TWO_B); *(WORD *)&SysParam[SP_RNIBRMSOS+channel*2]=tempp; #endif }
void DeviceMemCard::safeSelectOn(void) { implSelectEnable(); spiRead(); }
// C++ level interrupt handler for this instance void RH_RF22::handleInterrupt() { digitalWrite(2, HIGH); uint8_t _lastInterruptFlags[2]; // Read the interrupt flags which clears the interrupt spiBurstRead(RH_RF22_REG_03_INTERRUPT_STATUS1, _lastInterruptFlags, 2); #if 0 // Caution: Serial printing in this interrupt routine can cause mysterious crashes Serial.print("interrupt "); Serial.print(_lastInterruptFlags[0], HEX); Serial.print(" "); Serial.println(_lastInterruptFlags[1], HEX); if (_lastInterruptFlags[0] == 0 && _lastInterruptFlags[1] == 0) Serial.println("FUNNY: no interrupt!"); #endif #if 0 // TESTING: fake an RH_RF22_IFFERROR static int counter = 0; if (_lastInterruptFlags[0] & RH_RF22_IPKSENT && counter++ == 10) { _lastInterruptFlags[0] = RH_RF22_IFFERROR; counter = 0; } #endif if (_lastInterruptFlags[0] & RH_RF22_IFFERROR) { resetFifos(); // Clears the interrupt if (_mode == RHModeTx) restartTransmit(); else if (_mode == RHModeRx) clearRxBuf(); // Serial.println("IFFERROR"); } // Caution, any delay here may cause a FF underflow or overflow if (_lastInterruptFlags[0] & RH_RF22_ITXFFAEM) { // See if more data has to be loaded into the Tx FIFO sendNextFragment(); // Serial.println("ITXFFAEM"); } if (_lastInterruptFlags[0] & RH_RF22_IRXFFAFULL) { // Caution, any delay here may cause a FF overflow // Read some data from the Rx FIFO readNextFragment(); // Serial.println("IRXFFAFULL"); } if (_lastInterruptFlags[0] & RH_RF22_IEXT) { // This is not enabled by the base code, but users may want to enable it handleExternalInterrupt(); // Serial.println("IEXT"); } if (_lastInterruptFlags[1] & RH_RF22_IWUT) { // This is not enabled by the base code, but users may want to enable it handleWakeupTimerInterrupt(); // Serial.println("IWUT"); } if (_lastInterruptFlags[0] & RH_RF22_IPKSENT) { // Serial.println("IPKSENT"); _txGood++; // Transmission does not automatically clear the tx buffer. // Could retransmit if we wanted // RH_RF22 transitions automatically to Idle _mode = RHModeIdle; } if (_lastInterruptFlags[0] & RH_RF22_IPKVALID) { uint8_t len = spiRead(RH_RF22_REG_4B_RECEIVED_PACKET_LENGTH); // Serial.println("IPKVALID"); // May have already read one or more fragments // Get any remaining unread octets, based on the expected length // First make sure we dont overflow the buffer in the case of a stupid length // or partial bad receives if ( len > RH_RF22_MAX_MESSAGE_LEN || len < _bufLen) { _rxBad++; _mode = RHModeIdle; clearRxBuf(); return; // Hmmm receiver buffer overflow. } spiBurstRead(RH_RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, len - _bufLen); _rxHeaderTo = spiRead(RH_RF22_REG_47_RECEIVED_HEADER3); _rxHeaderFrom = spiRead(RH_RF22_REG_48_RECEIVED_HEADER2); _rxHeaderId = spiRead(RH_RF22_REG_49_RECEIVED_HEADER1); _rxHeaderFlags = spiRead(RH_RF22_REG_4A_RECEIVED_HEADER0); _rxGood++; _bufLen = len; _mode = RHModeIdle; _rxBufValid = true; } if (_lastInterruptFlags[0] & RH_RF22_ICRCERROR) { // Serial.println("ICRCERR"); _rxBad++; clearRxBuf(); resetRxFifo(); _mode = RHModeIdle; setModeRx(); // Keep trying } if (_lastInterruptFlags[1] & RH_RF22_IPREAVAL) { // Serial.println("IPREAVAL"); _lastRssi = (int8_t)(-(spiRead(RH_RF22_REG_26_RSSI) / 2)); _lastPreambleTime = millis(); resetRxFifo(); clearRxBuf(); } }
uint8_t RH_RF22::rssiRead() { return spiRead(RH_RF22_REG_26_RSSI); }
bool RH_RF22::init() { if (!RHSPIDriver::init()) return false; // Determine the interrupt number that corresponds to the interruptPin int interruptNumber = digitalPinToInterrupt(_interruptPin); if (interruptNumber == NOT_AN_INTERRUPT) return false; // Software reset the device reset(); // Get the device type and check it // This also tests whether we are really connected to a device _deviceType = spiRead(RH_RF22_REG_00_DEVICE_TYPE); if ( _deviceType != RH_RF22_DEVICE_TYPE_RX_TRX && _deviceType != RH_RF22_DEVICE_TYPE_TX) { return false; } // Add by Adrien van den Bossche <*****@*****.**> for Teensy // ARM M4 requires the below. else pin interrupt doesn't work properly. // On all other platforms, its innocuous, belt and braces pinMode(_interruptPin, INPUT); // Enable interrupt output on the radio. Interrupt line will now go high until // an interrupt occurs spiWrite(RH_RF22_REG_05_INTERRUPT_ENABLE1, RH_RF22_ENTXFFAEM | RH_RF22_ENRXFFAFULL | RH_RF22_ENPKSENT | RH_RF22_ENPKVALID | RH_RF22_ENCRCERROR | RH_RF22_ENFFERR); spiWrite(RH_RF22_REG_06_INTERRUPT_ENABLE2, RH_RF22_ENPREAVAL); // Set up interrupt handler // Since there are a limited number of interrupt glue functions isr*() available, // we can only support a limited number of devices simultaneously // On some devices, notably most Arduinos, the interrupt pin passed in is actually the // interrupt number. You have to figure out the interruptnumber-to-interruptpin mapping // yourself based on knowledge of what Arduino board you are running on. _deviceForInterrupt[_interruptCount] = this; if (_interruptCount == 0) attachInterrupt(interruptNumber, isr0, FALLING); else if (_interruptCount == 1) attachInterrupt(interruptNumber, isr1, FALLING); else if (_interruptCount == 2) attachInterrupt(interruptNumber, isr2, FALLING); else return false; // Too many devices, not enough interrupt vectors _interruptCount++; setModeIdle(); clearTxBuf(); clearRxBuf(); // Most of these are the POR default spiWrite(RH_RF22_REG_7D_TX_FIFO_CONTROL2, RH_RF22_TXFFAEM_THRESHOLD); spiWrite(RH_RF22_REG_7E_RX_FIFO_CONTROL, RH_RF22_RXFFAFULL_THRESHOLD); spiWrite(RH_RF22_REG_30_DATA_ACCESS_CONTROL, RH_RF22_ENPACRX | RH_RF22_ENPACTX | RH_RF22_ENCRC | (_polynomial & RH_RF22_CRC)); // Configure the message headers // Here we set up the standard packet format for use by the RH_RF22 library // 8 nibbles preamble // 2 SYNC words 2d, d4 // Header length 4 (to, from, id, flags) // 1 octet of data length (0 to 255) // 0 to 255 octets data // 2 CRC octets as CRC16(IBM), computed on the header, length and data // On reception the to address is check for validity against RH_RF22_REG_3F_CHECK_HEADER3 // or the broadcast address of 0xff // If no changes are made after this, the transmitted // to address will be 0xff, the from address will be 0xff // and all such messages will be accepted. This permits the out-of the box // RH_RF22 config to act as an unaddresed, unreliable datagram service spiWrite(RH_RF22_REG_32_HEADER_CONTROL1, RH_RF22_BCEN_HEADER3 | RH_RF22_HDCH_HEADER3); spiWrite(RH_RF22_REG_33_HEADER_CONTROL2, RH_RF22_HDLEN_4 | RH_RF22_SYNCLEN_2); setPreambleLength(8); uint8_t syncwords[] = { 0x2d, 0xd4 }; setSyncWords(syncwords, sizeof(syncwords)); setPromiscuous(false); // Set some defaults. An innocuous ISM frequency, and reasonable pull-in setFrequency(434.0, 0.05); // setFrequency(900.0); // Some slow, reliable default speed and modulation setModemConfig(FSK_Rb2_4Fd36); // setModemConfig(FSK_Rb125Fd125); setGpioReversed(false); // Lowish power setTxPower(RH_RF22_TXPOW_8DBM); return true; }
bool RH_RF95::init() { if (!RHSPIDriver::init()) return false; // Determine the interrupt number that corresponds to the interruptPin int interruptNumber = digitalPinToInterrupt(_interruptPin); if (interruptNumber == NOT_AN_INTERRUPT) return false; #ifdef RH_ATTACHINTERRUPT_TAKES_PIN_NUMBER interruptNumber = _interruptPin; #endif // Tell the low level SPI interface we will use SPI within this interrupt spiUsingInterrupt(interruptNumber); // No way to check the device type :-( // Set sleep mode, so we can also set LORA mode: spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE); delay(10); // Wait for sleep mode to take over from say, CAD // Check we are in sleep mode, with LORA set if (spiRead(RH_RF95_REG_01_OP_MODE) != (RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE)) { // Serial.println(spiRead(RH_RF95_REG_01_OP_MODE), HEX); return false; // No device present? } // Add by Adrien van den Bossche <*****@*****.**> for Teensy // ARM M4 requires the below. else pin interrupt doesn't work properly. // On all other platforms, its innocuous, belt and braces pinMode(_interruptPin, INPUT); // Set up interrupt handler // Since there are a limited number of interrupt glue functions isr*() available, // we can only support a limited number of devices simultaneously // ON some devices, notably most Arduinos, the interrupt pin passed in is actuallt the // interrupt number. You have to figure out the interruptnumber-to-interruptpin mapping // yourself based on knwledge of what Arduino board you are running on. if (_myInterruptIndex == 0xff) { // First run, no interrupt allocated yet if (_interruptCount <= RH_RF95_NUM_INTERRUPTS) _myInterruptIndex = _interruptCount++; else return false; // Too many devices, not enough interrupt vectors } _deviceForInterrupt[_myInterruptIndex] = this; if (_myInterruptIndex == 0) attachInterrupt(interruptNumber, isr0, RISING); else if (_myInterruptIndex == 1) attachInterrupt(interruptNumber, isr1, RISING); else if (_myInterruptIndex == 2) attachInterrupt(interruptNumber, isr2, RISING); else return false; // Too many devices, not enough interrupt vectors // Set up FIFO // We configure so that we can use the entire 256 byte FIFO for either receive // or transmit, but not both at the same time spiWrite(RH_RF95_REG_0E_FIFO_TX_BASE_ADDR, 0); spiWrite(RH_RF95_REG_0F_FIFO_RX_BASE_ADDR, 0); // Packet format is preamble + explicit-header + payload + crc // Explicit Header Mode // payload is TO + FROM + ID + FLAGS + message data // RX mode is implmented with RXCONTINUOUS // max message data length is 255 - 4 = 251 octets setModeIdle(); // Set up default configuration // No Sync Words in LORA mode. setModemConfig(Bw125Cr45Sf128); // Radio default // setModemConfig(Bw125Cr48Sf4096); // slow and reliable? setPreambleLength(8); // Default is 8 // An innocuous ISM frequency, same as RF22's setFrequency(434.0); // Lowish power setTxPower(13); return true; }
// C++ level interrupt handler for this instance void RF22::handleInterrupt() { uint8_t _lastInterruptFlags[2]; // Read the interrupt flags which clears the interrupt spiBurstRead(RF22_REG_03_INTERRUPT_STATUS1, _lastInterruptFlags, 2); if (_lastInterruptFlags[0] & RF22_IFFERROR) { resetFifos(); // Clears the interrupt if (_mode == RF22_MODE_TX) restartTransmit(); else if (_mode == RF22_MODE_RX) clearRxBuf(); } // Caution, any delay here may cause a FF underflow or overflow if (_lastInterruptFlags[0] & RF22_ITXFFAEM) { // See if more data has to be loaded into the Tx FIFO sendNextFragment(); } if (_lastInterruptFlags[0] & RF22_IRXFFAFULL) { // Caution, any delay here may cause a FF overflow // Read some data from the Rx FIFO readNextFragment(); } if (_lastInterruptFlags[0] & RF22_IEXT) { // This is not enabled by the base code, but users may want to enable it handleExternalInterrupt(); } if (_lastInterruptFlags[1] & RF22_IWUT) { // This is not enabled by the base code, but users may want to enable it handleWakeupTimerInterrupt(); } if (_lastInterruptFlags[0] & RF22_IPKSENT) { _txGood++; // Transmission does not automatically clear the tx buffer. // Could retransmit if we wanted // RF22 transitions automatically to Idle _mode = RF22_MODE_IDLE; } if (_lastInterruptFlags[0] & RF22_IPKVALID) { uint8_t len = spiRead(RF22_REG_4B_RECEIVED_PACKET_LENGTH); // May have already read one or more fragments // Get any remaining unread octets, based on the expected length // First make sure we dont overflow the buffer in the case of a stupid length // or partial bad receives if ( len > RF22_MAX_MESSAGE_LEN || len < _bufLen) { _rxBad++; _mode = RF22_MODE_IDLE; clearRxBuf(); return; // Hmmm receiver buffer overflow. } spiBurstRead(RF22_REG_7F_FIFO_ACCESS, _buf + _bufLen, len - _bufLen); _rxGood++; _bufLen = len; _mode = RF22_MODE_IDLE; _rxBufValid = true; } if (_lastInterruptFlags[0] & RF22_ICRCERROR) { _rxBad++; clearRxBuf(); resetRxFifo(); _mode = RF22_MODE_IDLE; setModeRx(); // Keep trying } if (_lastInterruptFlags[1] & RF22_IPREAVAL) { _lastRssi = spiRead(RF22_REG_26_RSSI); clearRxBuf(); } }
void MPU6000::read() { sensors.accXByteH = spiRead(ACCEL_XOUT_H); sensors.accXByteL = spiRead(ACCEL_XOUT_L); sensors.accYByteH = spiRead(ACCEL_YOUT_H); sensors.accYByteL = spiRead(ACCEL_YOUT_L); sensors.accZByteH = spiRead(ACCEL_ZOUT_H); sensors.accZByteL = spiRead(ACCEL_ZOUT_L); sensors.gyrXByteH = spiRead(GYRO_XOUT_H); sensors.gyrXByteL = spiRead(GYRO_XOUT_L); sensors.gyrYByteH = spiRead(GYRO_YOUT_H); sensors.gyrYByteL = spiRead(GYRO_YOUT_L); sensors.gyrZByteH = spiRead(GYRO_ZOUT_H); sensors.gyrZByteL = spiRead(GYRO_ZOUT_L); }
/**************************************************************************//** * @brief Perform read from DVK board control register * @param addr Address of register to read from *****************************************************************************/ uint16_t DVK_readRegister(uint16_t *addr) { uint16_t data; if (addr != lastAddr) { spiWrite(0x00, 0xFFFF & ((uint32_t) addr)); /*LSBs of address*/ spiWrite(0x01, 0xFF & ((uint32_t) addr >> 16)); /*MSBs of address*/ spiWrite(0x02, (0x0C000000 & (uint32_t) addr) >> 26); /*Chip select*/ } /* Read twice */ data = spiRead(0x03, 0); data = spiRead(0x03, 0); lastAddr = addr; return data; } /**************************************************************************//** * @brief Perform write to DVK board control register * @param addr Address of register to write to * @param data 16-bit to write into register *****************************************************************************/ void DVK_writeRegister(uint16_t *addr, uint16_t data) { if (addr != lastAddr) { spiWrite(0x00, 0xFFFF & ((uint32_t) addr)); /*LSBs of address*/
bool RF22::init() { //TODO check. wiringPiSetup(); // // Wait for RF22 POR (up to 16msec) // delay(16); if (wiringPiSPISetup(_slaveSelectPin, 1000000) == -1) { printf("Could not initialize SPI\n"); return false; } delay(20); // Software reset the device reset(); delay(1); // Get the device type and check it // This also tests whether we are really connected to a device _deviceType = spiRead(RF22_REG_00_DEVICE_TYPE); if (_deviceType != RF22_DEVICE_TYPE_RX_TRX && _deviceType != RF22_DEVICE_TYPE_TX) return false; // Set up interrupt handler if (_interrupt == 0) { _RF22ForInterrupt[0] = this; //attaching interrupt to gpio pins. see wiringPi.com -> gpio chart wiringPiISR(6, INT_EDGE_FALLING, RF22::isr0); } else if (_interrupt == 1) { _RF22ForInterrupt[1] = this; wiringPiISR(4, INT_EDGE_FALLING, RF22::isr1); } else return false; clearTxBuf(); clearRxBuf(); // Most of these are the POR default spiWrite(RF22_REG_7D_TX_FIFO_CONTROL2, RF22_TXFFAEM_THRESHOLD); spiWrite(RF22_REG_7E_RX_FIFO_CONTROL, RF22_RXFFAFULL_THRESHOLD); spiWrite(RF22_REG_30_DATA_ACCESS_CONTROL, RF22_ENPACRX | RF22_ENPACTX | RF22_ENCRC | RF22_CRC_CRC_16_IBM); // Configure the message headers // Here we set up the standard packet format for use by the RF22 library // 8 nibbles preamble // 2 SYNC words 2d, d4 // Header length 4 (to, from, id, flags) // 1 octet of data length (0 to 255) // 0 to 255 octets data // 2 CRC octets as CRC16(IBM), computed on the header, length and data // On reception the to address is check for validity against RF22_REG_3F_CHECK_HEADER3 // or the broadcast address of 0xff // If no changes are made after this, the transmitted // to address will be 0xff, the from address will be 0xff // and all such messages will be accepted. This permits the out-of the box // RF22 config to act as an unaddresed, unreliable datagram service spiWrite(RF22_REG_32_HEADER_CONTROL1, RF22_BCEN_HEADER3 | RF22_HDCH_HEADER3); spiWrite(RF22_REG_33_HEADER_CONTROL2, RF22_HDLEN_4 | RF22_SYNCLEN_2 | 0x1); setPreambleLength(8); uint8_t syncwords[] = { 0x2d, 0xd4 }; setSyncWords(syncwords, sizeof(syncwords)); setPromiscuous(false); // Check the TO header against RF22_DEFAULT_NODE_ADDRESS spiWrite(RF22_REG_3F_CHECK_HEADER3, RF22_DEFAULT_NODE_ADDRESS); // Set the default transmit header values setHeaderTo(RF22_DEFAULT_NODE_ADDRESS); setHeaderFrom(RF22_DEFAULT_NODE_ADDRESS); setHeaderId(0); setHeaderFlags(0); // Ensure the antenna can be switched automatically according to transmit and receive // This assumes GPIO0(out) is connected to TX_ANT(in) to enable tx antenna during transmit // This assumes GPIO1(out) is connected to RX_ANT(in) to enable rx antenna during receive spiWrite(RF22_REG_0B_GPIO_CONFIGURATION0, 0x12); // TX state spiWrite(RF22_REG_0C_GPIO_CONFIGURATION1, 0x15); // RX state //spiWrite(RF22_REG_0D_GPIO_CONFIGURATION2, 0x14); //raw data to port 4 have to activate it later? //put into a mode where the interrupt frequency is not as high as the clock of the rfm22. //the raspberry is connected to that pin and would freeze if an isr is registered. spiWrite(RF22_REG_0D_GPIO_CONFIGURATION2, 0x13); // Enable interrupts spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM | RF22_ENRXFFAFULL | RF22_ENPKSENT | RF22_ENPKVALID | RF22_ENCRCERROR | RF22_ENFFERR); spiWrite(RF22_REG_06_INTERRUPT_ENABLE2, RF22_ENPREAVAL); // Set some defaults. An innocuous ISM frequency, and reasonable pull-in setFrequency(434.0, 0.05); // setFrequency(900.0); // Some slow, reliable default speed and modulation setModemConfig(FSK_Rb2_4Fd36); // setModemConfig(FSK_Rb125Fd125); // Minimum power setTxPower(RF22_TXPOW_8DBM); // setTxPower(RF22_TXPOW_17DBM); return true; }
void Check_KPA_KPB(BYTE channel,uint datp) { BYTE j =0; BYTE i =0; uint temp =0; uint temp1[10]={0}; uint len=10; unsigned long long dbuf=0; for(j=0;j<len;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 150); spiRead(channel, RIF, &temp, WIDTH_ONE_B); if(temp&0x01) { break; } } spiRead(channel, POWERPA, &temp, WIDTH_FOUR_B); if(temp < 0x80000000)//大于 0x80000000 时为负 { temp1[i] = temp; i++; } temp = 0; } temp = MeanValue(temp1,i); dbuf = datp;//避免数据溢出 *(WORD *)&SysParam[SP_RNKAP+2*channel] = dbuf*1000000/temp;//最小单位为0.1W 来计算的K i =0; printf("#"); /* for(j=0;j<len;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 100); spiRead(channel, RIF, &temp, WIDTH_ONE_B); if(temp&0x01) { break; } } spiRead(channel, POWERPB, &temp, WIDTH_FOUR_B); if(tempp < 0x80000000)//大于 0x80000000 时为负 { temp1[i] = temp; i++; } temp = 0; } tempp = MeanValue(temp1,i); *(WORD *)&SysParam[SP_RNKBP+2*channel] = datp*1000000/tempp; //最小单位0.1W 来计算的K printf("*");*/ }
void Check_KIA_KIB(BYTE channel,uint dati) { BYTE j =0; BYTE i =0; uint temp=0; uint temp1[10]={0}; uint len=10; unsigned long long dbuf = 0; for(j=0;j<len;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 150); spiRead(channel, RIF, &temp, WIDTH_ONE_B); if(temp&0x01) { break; } } spiRead(channel, IARMS, &temp, WIDTH_THREE_B); if(temp < 0x800000)//大于 0x800000 时做零处理 { temp1[i] = temp; i++; } temp = 0; } temp = MeanValue(temp1,i); dbuf = dati; *(WORD *)&SysParam[SP_RNKIA+2*channel] = dbuf*10000/temp; // 最小单位为1mA来计算的K i =0; printf("#"); #if(EleMeterCnt==6) for(j=0;j<len;j++) { while(1) { OSTimeDlyHMSM(0, 0, 0, 150); spiRead(channel, RIF, &temp, WIDTH_ONE_B); if(temp&0x01) { break; } } spiRead(channel, IBRMS, &temp, WIDTH_THREE_B); if(temp < 0x800000)//大于 0x800000 时做零处理 { temp1[i] = temp; i++; } temp = 0; } tempp = MeanValue(temp1,i); *(WORD *)&SysParam[SP_RNKIB+2*channel] = dati*10000/tempp; printf("#"); #endif }
void taskPriod ( void *pParam ) { static unsigned long long data = 0; static uint Flag = 0; static uint tempAi[9] ={0}; // static uint tempBi[9] ={0}; static uint tempU[9] ={0}; static uint tempEE[9] ={0}; static uint tempPA[9] ={0}; // static uint tempPB[9] ={0}; // static ulong tempQE[9] ={0}; static BYTE channel =0; static BYTE i=0; static BYTE count=0; printf ( "\r\nPriod task begin..." ); while ( 1 ) { OSTimeDly ( OS_TICKS_PER_SEC*2); updatePeriodChk(); ReadRealtime(); count++; for(channel=0;channel<9;channel++) { spiRead(channel, IARMS, (uint *)&data, WIDTH_THREE_B); //printf("IARMS=%d\r\n",*(uint *)&data); if(data >= 0x800000) { data = 0; tempAi[channel]= 0; } else { tempAi[channel]= (uint)(((*(WORD *)&SysParam[SP_RNKIA+2*channel])*data)/10000+1);// 0.1mA 补偿0.1mA } #if(EleMeterCnt==6) spiRead(channel, IBRMS, &data, WIDTH_THREE_B); if(data >= 0x800000) { data = 0; tempBi[channel] =0; } else { tempBi[channel] = ((*(WORD *)&SysParam[SP_RNKIB+2*channel]) * data)/10000+1;// 0.1mA 补偿0.1mA } #endif spiRead(channel, URMS, (uint *)&data, WIDTH_THREE_B); //printf("URMS=%d\r\n",*(uint *)&data); if((data >= 0x800000)||(data < 0x24B)) { data = 0; } tempU[channel] = (uint)(((*(WORD *)&SysParam[SP_RNKU+2*channel])* data)/1000000);// 0.1V //A通道功率 spiRead(channel, POWERPA, (uint *)&data, WIDTH_FOUR_B); //printf("POWERPA=%d\r\n",*(uint *)&data); if(data>0x80000000)//负数 { spiRead(channel, EMUSTATUS, &Flag, WIDTH_THREE_B); if(Flag&0x20000)//REVP=1 { data = (data-1)^0x8fffffff; data = data&0x7fffffff; } else { data =0; } } tempPA[channel] = (uint)(((*(WORD *)&SysParam[SP_RNKAP+2*channel])*data)/1000000);// 0.1W #if(EleMeterCnt==6) spiRead(channel, POWERPB, (uint *)&data, WIDTH_FOUR_B); if(data>0x80000000)//负数 { spiRead(channel, EMUSTATUS, &Flag, WIDTH_THREE_B); if(Flag&0x20000)//REVP=1 { data = (data-1)^0x8fffffff; } else { data =0; } } tempPB[channel] = ((*(WORD*)&SysParam[SP_RNKBP+2*channel])*data)/1000000; #endif #if 0 //无功功率 spiRead(channel, POWERQ, &data, WIDTH_FOUR_B); if(data>0x80000000)//负数 { spiRead(channel, EMUSTATUS, &Flag, WIDTH_THREE_B); if(Flag&0x40000)//REVQ=1 { data = (data-1)^0x8fffffff; } else { data =0; } } #endif //读中断标志位 spiRead(channel, RIF, (uint *)&data, WIDTH_ONE_B); if(data & RN_RPEOIF)//溢出中断 { printf("overflow=%d\n",channel); *(DWORD *)&EEPROMPARAM[EEPROM_ENERGY+4*channel]= 0; EEPROMPARAM[EEPROM_OVERFLOW+channel] +=1; Write_FM24C(FMSLAVE_ADDR, EEPROM_OVERFLOWADDR+channel,&EEPROMPARAM[EEPROM_OVERFLOW+channel], 1); } spiRead(channel, ENERGYP, (uint *)&data, WIDTH_THREE_B);// *(DWORD *)&EEPROMPARAM[EEPROM_ENERGYLAST+4*channel] = data; data += *(DWORD *)&EEPROMPARAM[EEPROM_ENERGY+4*channel] ; if(count == 5)//10s { if(channel == 8) { count = 0; } Write_FM24C(FMSLAVE_ADDR, EEPROM_ENERGY+4*channel,(BYTE *)&data, 4); Write_FM24C(FMSLAVE_ADDR, EEPROM_ENERGYLAST+4*channel,(BYTE *)&EEPROMPARAM[EEPROM_ENERGYLAST+4*channel], 4); } tempEE[channel]=(data+EEPROMPARAM[EEPROM_OVERFLOW + channel]*0xffffff)/(EC/100); } #if(EleMeterCnt==3) for(i=0;i<3;i++) { EMeterDat[i].Ai = tempAi[i]/10;//mA EMeterDat[i].Bi = tempAi[i+3]/10; EMeterDat[i].Ci = tempAi[i+6]/10; EMeterDat[i].Au = (tempU[0]+tempU[1]+tempU[2])/3;//100mV 0.1V EMeterDat[i].Bu = (tempU[3]+tempU[4]+tempU[5])/3; EMeterDat[i].Cu = (tempU[6]+tempU[7]+tempU[8])/3; EMeterDat[i].AE = tempEE[i];// 0.01kWh,电表常数3200 EMeterDat[i].BE = tempEE[i+3]; EMeterDat[i].CE = tempEE[i+6]; EMeterDat[i].PWRA = tempPA[i];//功率 EMeterDat[i].PWRB = tempPA[i+3]; EMeterDat[i].PWRC = tempPA[i+6]; EMeterDat[i].PWR = tempPA[0+i]+tempPA[i+3]+tempPA[i+6]; EMeterDat[i].EE = EMeterDat[i].AE+EMeterDat[i].BE+EMeterDat[i].CE;// 0.01kwh } #else for(i=0;i<6;i++) { if((i%2)==0) { EMeterDat[i].Ai=tempAi[i/2]/10;//mA EMeterDat[i].Bi=tempAi[i/2+3]/10; EMeterDat[i].Ci=tempAi[i/2+6]/10; } else { EMeterDat[i].Ai=tempBi[i/2]/10;//mA EMeterDat[i].Bi=tempBi[i/2+3]/10; EMeterDat[i].Ci=tempBi[i/2+6]/10; } EMeterDat[i].Au=(tempU[0]+tempU[1]+tempU[2])/3;//100mV 0.1V EMeterDat[i].Bu=(tempU[3]+tempU[4]+tempU[5])/3; EMeterDat[i].Cu=(tempU[6]+tempU[7]+tempU[8])/3; if((i%2)==0) { EMeterDat[i].AE=tempEE[i/2];//0.01kwh EMeterDat[i].BE=tempEE[i/2+3]; EMeterDat[i].CE=tempEE[i/2+6]; } else { EMeterDat[i].AE=EEB[i/2];//0.01kwh EMeterDat[i].BE=EEB[i/2+3]; EMeterDat[i].CE=EEB[i/2+6]; } EMeterDat[i].EE=EMeterDat[i].AE+EMeterDat[i].BE+EMeterDat[i].CE;// 0.01kwh } #endif } }
void DeviceMemCard::safeSelectOff(void) { spiRead(); implSelectDisable(); spiRead(); }
uint8_t RF22::headerTo() { return spiRead(RF22_REG_47_RECEIVED_HEADER3); }
bool RH_RF69::init() { if (!RHSPIDriver::init()) return false; // Determine the interrupt number that corresponds to the interruptPin int interruptNumber = digitalPinToInterrupt(_interruptPin); if (interruptNumber == NOT_AN_INTERRUPT) return false; #ifdef RH_ATTACHINTERRUPT_TAKES_PIN_NUMBER interruptNumber = _interruptPin; #endif // Get the device type and check it // This also tests whether we are really connected to a device // My test devices return 0x24 _deviceType = spiRead(RH_RF69_REG_10_VERSION); if (_deviceType == 00 || _deviceType == 0xff) return false; // Add by Adrien van den Bossche <*****@*****.**> for Teensy // ARM M4 requires the below. else pin interrupt doesn't work properly. // On all other platforms, its innocuous, belt and braces pinMode(_interruptPin, INPUT); // Set up interrupt handler // Since there are a limited number of interrupt glue functions isr*() available, // we can only support a limited number of devices simultaneously // ON some devices, notably most Arduinos, the interrupt pin passed in is actuallt the // interrupt number. You have to figure out the interruptnumber-to-interruptpin mapping // yourself based on knwledge of what Arduino board you are running on. if (_myInterruptIndex == 0xff) { // First run, no interrupt allocated yet if (_interruptCount <= RH_RF69_NUM_INTERRUPTS) _myInterruptIndex = _interruptCount++; else return false; // Too many devices, not enough interrupt vectors } _deviceForInterrupt[_myInterruptIndex] = this; if (_myInterruptIndex == 0) attachInterrupt(interruptNumber, isr0, RISING); else if (_myInterruptIndex == 1) attachInterrupt(interruptNumber, isr1, RISING); else if (_myInterruptIndex == 2) attachInterrupt(interruptNumber, isr2, RISING); else return false; // Too many devices, not enough interrupt vectors setModeIdle(); // Configure important RH_RF69 registers // Here we set up the standard packet format for use by the RH_RF69 library: // 4 bytes preamble // 2 SYNC words 2d, d4 // 2 CRC CCITT octets computed on the header, length and data (this in the modem config data) // 0 to 60 bytes data // RSSI Threshold -114dBm // We dont use the RH_RF69s address filtering: instead we prepend our own headers to the beginning // of the RH_RF69 payload spiWrite(RH_RF69_REG_3C_FIFOTHRESH, RH_RF69_FIFOTHRESH_TXSTARTCONDITION_NOTEMPTY | 0x0f); // thresh 15 is default // RSSITHRESH is default // spiWrite(RH_RF69_REG_29_RSSITHRESH, 220); // -110 dbM // SYNCCONFIG is default. SyncSize is set later by setSyncWords() // spiWrite(RH_RF69_REG_2E_SYNCCONFIG, RH_RF69_SYNCCONFIG_SYNCON); // auto, tolerance 0 // PAYLOADLENGTH is default // spiWrite(RH_RF69_REG_38_PAYLOADLENGTH, RH_RF69_FIFO_SIZE); // max size only for RX // PACKETCONFIG 2 is default spiWrite(RH_RF69_REG_6F_TESTDAGC, RH_RF69_TESTDAGC_CONTINUOUSDAGC_IMPROVED_LOWBETAOFF); // If high power boost set previously, disable it spiWrite(RH_RF69_REG_5A_TESTPA1, RH_RF69_TESTPA1_NORMAL); spiWrite(RH_RF69_REG_5C_TESTPA2, RH_RF69_TESTPA2_NORMAL); // The following can be changed later by the user if necessary. // Set up default configuration uint8_t syncwords[] = { 0x2d, 0xd4 }; setSyncWords(syncwords, sizeof(syncwords)); // Same as RF22's // Reasonably fast and reliable default speed and modulation setModemConfig(GFSK_Rb250Fd250); // 3 would be sufficient, but this is the same as RF22's setPreambleLength(4); // An innocuous ISM frequency, same as RF22's setFrequency(434.0); // No encryption setEncryptionKey(NULL); // +13dBm, same as power-on default setTxPower(13); return true; }
uint8_t RF22::headerFrom() { return spiRead(RF22_REG_48_RECEIVED_HEADER2); }
bool RH_RF95::init() { bool result = false; if (_resetPin != PIN_UNUSED) pinMode(_resetPin, INPUT); if (_powerPin != PIN_UNUSED) { pinMode(_powerPin, OUTPUT); digitalWrite(_powerPin, HIGH); if (_resetPin != PIN_UNUSED) while (digitalRead(_resetPin) != HIGH) ; delay(20); } if (!RHSPIDriver::init()) return false; // Determine the interrupt number that corresponds to the interruptPin int interruptNumber = digitalPinToInterrupt(_interruptPin); if (interruptNumber == NOT_AN_INTERRUPT) return false; // Set sleep mode, so we can also set LORA mode: spiWrite(RH_RF95_REG_01_OP_MODE, RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE); delay(10); // Wait for sleep mode to take over from say, CAD _revision = spiRead(RH_RF95_REG_42_VERSION); // Check we are in sleep mode, with LORA set if (spiRead(RH_RF95_REG_01_OP_MODE) == (RH_RF95_MODE_SLEEP | RH_RF95_LONG_RANGE_MODE)) { // Add by Adrien van den Bossche <*****@*****.**> for Teensy // ARM M4 requires the below. else pin interrupt doesn't work properly. // On all other platforms, its innocuous, belt and braces pinMode(_interruptPin, INPUT_PULLDOWN); // Set up interrupt handler // Since there are a limited number of interrupt glue functions isr*() available, // we can only support a limited number of devices simultaneously // ON some devices, notably most Arduinos, the interrupt pin passed in is actuallt the // interrupt number. You have to figure out the interruptnumber-to-interruptpin mapping // yourself based on knwledge of what Arduino board you are running on. if (_myInterruptIndex == 0xFF) { // First run, no interrupt allocated yet if (_interruptCount < RH_RF95_NUM_INTERRUPTS) _myInterruptIndex = _interruptCount++; // else Too many devices, not enough interrupt vectors } if (_myInterruptIndex < RH_RF95_NUM_INTERRUPTS) { _deviceForInterrupt[_myInterruptIndex] = this; if (_myInterruptIndex == 0) attachInterrupt(interruptNumber, isr0, RISING); else if (_myInterruptIndex == 1) attachInterrupt(interruptNumber, isr1, RISING); else if (_myInterruptIndex == 2) attachInterrupt(interruptNumber, isr2, RISING); // Set up FIFO // We configure so that we can use the entire 256 byte FIFO for either receive // or transmit, but not both at the same time spiWrite(RH_RF95_REG_0E_FIFO_TX_BASE_ADDR, 0); spiWrite(RH_RF95_REG_0F_FIFO_RX_BASE_ADDR, 0); result = true; } } if (result) { // Packet format is preamble + explicit-header + payload + crc // Explicit Header Mode // payload is TO + FROM + ID + FLAGS + message data // RX mode is implmented with RXCONTINUOUS // max message data length is 255 - 4 = 251 octets setModeIdle(); // Set up default configuration // No Sync Words in LORA mode. // setModemConfig(Bw125Cr45Sf128); // Radio default medium // setModemConfig(Bw125Cr48Sf4096); // slow and reliable? setModemConfig(Bw31_25Cr48Sf512); setPreambleLength(8); // Default is 8 setFrequency(434.0); // An innocuous ISM frequency, same as RF22's setTxPower(23); // Highest power } return result; }
uint8_t RF22::headerId() { return spiRead(RF22_REG_49_RECEIVED_HEADER1); }
void RFM69_setMode(uint8_t newMode) { spiWrite(RFM69_REG_01_OPMODE, (spiRead(RFM69_REG_01_OPMODE) & 0xE3) | newMode); _mode = newMode; }
uint8_t RF22::headerFlags() { return spiRead(RF22_REG_4A_RECEIVED_HEADER0); }
uint8_t mcp3301ReadBuf(uint8_t * d,uint16_t len){ spiRead(MCP3301_SPI_PORT,1,d,len); }
uint8_t RF22::init() { // Wait for RF22 POR (up to 16msec) usleep (16); // Initialise the slave select pin _cs = mraa_gpio_init(_slaveSelectPin); mraa_gpio_dir(_cs, MRAA_GPIO_OUT); mraa_gpio_write(_cs, 0x1); // start the SPI library: // Note the RF22 wants mode 0, MSB first and default to 1 Mbps _spi = mraa_spi_init(0); mraa_spi_mode (_spi, MRAA_SPI_MODE0); mraa_spi_lsbmode(_spi, 0); mraa_spi_frequency(_spi, 1000000); // 1Mhz usleep (100); // Software reset the device reset(); // Get the device type and check it // This also tests whether we are really connected to a device _deviceType = spiRead(RF22_REG_00_DEVICE_TYPE); if ( _deviceType != RF22_DEVICE_TYPE_RX_TRX && _deviceType != RF22_DEVICE_TYPE_TX) return 0; _irq = mraa_gpio_init(_interrupt + 2); mraa_gpio_dir(_irq, MRAA_GPIO_IN); gpio_edge_t edge = MRAA_GPIO_EDGE_FALLING; // Set up interrupt handler if (_interrupt == 0) { _RF22ForInterrupt[0] = this; mraa_gpio_isr(_irq, edge, &RF22::isr0, NULL); } else if (_interrupt == 1) { _RF22ForInterrupt[1] = this; mraa_gpio_isr(_irq, edge, &RF22::isr1, NULL); } else return 0; clearTxBuf(); clearRxBuf(); // Most of these are the POR default spiWrite(RF22_REG_7D_TX_FIFO_CONTROL2, RF22_TXFFAEM_THRESHOLD); spiWrite(RF22_REG_7E_RX_FIFO_CONTROL, RF22_RXFFAFULL_THRESHOLD); spiWrite(RF22_REG_30_DATA_ACCESS_CONTROL, RF22_ENPACRX | RF22_ENPACTX | RF22_ENCRC | RF22_CRC_CRC_16_IBM); // Configure the message headers // Here we set up the standard packet format for use by the RF22 library // 8 nibbles preamble // 2 SYNC words 2d, d4 // Header length 4 (to, from, id, flags) // 1 octet of data length (0 to 255) // 0 to 255 octets data // 2 CRC octets as CRC16(IBM), computed on the header, length and data // On reception the to address is check for validity against RF22_REG_3F_CHECK_HEADER3 // or the broadcast address of 0xff // If no changes are made after this, the transmitted // to address will be 0xff, the from address will be 0xff // and all such messages will be accepted. This permits the out-of the box // RF22 config to act as an unaddresed, unreliable datagram service spiWrite(RF22_REG_32_HEADER_CONTROL1, RF22_BCEN_HEADER3 | RF22_HDCH_HEADER3); spiWrite(RF22_REG_33_HEADER_CONTROL2, RF22_HDLEN_4 | RF22_SYNCLEN_2); setPreambleLength(8); uint8_t syncwords[] = { 0x2d, 0xd4 }; setSyncWords(syncwords, sizeof(syncwords)); setPromiscuous(0); // Check the TO header against RF22_DEFAULT_NODE_ADDRESS spiWrite(RF22_REG_3F_CHECK_HEADER3, RF22_DEFAULT_NODE_ADDRESS); // Set the default transmit header values setHeaderTo(RF22_DEFAULT_NODE_ADDRESS); setHeaderFrom(RF22_DEFAULT_NODE_ADDRESS); setHeaderId(0); setHeaderFlags(0); // Ensure the antenna can be switched automatically according to transmit and receive // This assumes GPIO0(out) is connected to TX_ANT(in) to enable tx antenna during transmit // This assumes GPIO1(out) is connected to RX_ANT(in) to enable rx antenna during receive spiWrite (RF22_REG_0B_GPIO_CONFIGURATION0, 0x12) ; // TX state spiWrite (RF22_REG_0C_GPIO_CONFIGURATION1, 0x15) ; // RX state // Enable interrupts spiWrite(RF22_REG_05_INTERRUPT_ENABLE1, RF22_ENTXFFAEM | RF22_ENRXFFAFULL | RF22_ENPKSENT | RF22_ENPKVALID | RF22_ENCRCERROR | RF22_ENFFERR); spiWrite(RF22_REG_06_INTERRUPT_ENABLE2, RF22_ENPREAVAL); // Set some defaults. An innocuous ISM frequency, and reasonable pull-in setFrequency(434.0, 0.05); // setFrequency(900.0); // Some slow, reliable default speed and modulation setModemConfig(FSK_Rb2_4Fd36); // setModemConfig(FSK_Rb125Fd125); // Minimum power setTxPower(RF22_TXPOW_8DBM); // setTxPower(RF22_TXPOW_17DBM); return 1; }
uint8_t RH_RF22::statusRead() { return spiRead(RH_RF22_REG_02_DEVICE_STATUS); }
/* * initialise card. * logic from SD Simplified, page 95, with extentions * for SanDisk MMCs 1.3 that accept CMD55 */ int DeviceMemCard::open(unsigned short vhs) { int i; unsigned char r1; int res; if (m_isOpened) return MEMCARD_ERROR_OPENED; m_bufLen = 0; m_capabilities = 0; implSelectInit(); spiInitLowSpeed(); // send more than 80 clocks prior to starting bus communication // before slecting the card for (i = 10; i != 0; --i) spiRead(); // 1 mS for just in case, not from the specs OS::busyWaitMillis(1); res = 0; safeSelectOn(); res = enterIdle(); if (res != 0) { OSDeviceDebug::putString("idle="); OSDeviceDebug::putHex((unsigned short)res); OSDeviceDebug::putNewLine(); goto out; } // now in idle state unsigned long l; unsigned char icmd; int ires; icmd = 0; ires = 0; sendCommand(SDC_SEND_IF_COND, (unsigned long) vhs); r1 = receiveR1(); l = receiveLong(); if ((r1 & ~MMC_R1_IN_IDLE_STATE) == 0) { // no error, v2.0 SD Card or later #if defined(OS_INCLUDE_MEMCARD_MEMBER_VHS) m_VHS = l; // store to member #endif OSDeviceDebug::putString("SD Card v2.0 or later"); OSDeviceDebug::putNewLine(); #if defined(OS_INCLUDE_MEMCARD_VALIDATEVOLTAGE) if (!validateVoltage(l)) { res = MEMCARD_ERROR_VOLTAGE; goto out; } #endif // card with compatible voltage range sendCommand(SDC_READ_OCR, 0L); r1 = receiveR1(); l = receiveLong(); if ((r1 & ~MMC_R1_IN_IDLE_STATE) == 0) { // no error, v2.0 SD OSDeviceDebug::putString("OCR="); OSDeviceDebug::putHex((unsigned short) (l >> 16)); OSDeviceDebug::putHex((unsigned short) l); OSDeviceDebug::putNewLine(); #if defined(OS_INCLUDE_MEMCARD_OCR) m_OCR = l; #endif m_capabilities |= MEMCARD_CAPABILITIES_SDC; m_capabilities |= MEMCARD_CAPABILITIES_SDC2; if ((l & SDC_OCR_CAPACITY) != 0) { OSDeviceDebug::putString("SD Card v2.0 HC"); OSDeviceDebug::putNewLine(); m_capabilities |= MEMCARD_CAPABILITIES_SDC2_HC; res = MEMCARD_OPEN_SDC2HC; } else { OSDeviceDebug::putString("SD Card v2.0 SS"); OSDeviceDebug::putNewLine(); res = MEMCARD_OPEN_SDC2SS; } icmd = SDC_A_SEND_OP_COND; ires = MEMCARD_ERROR_SD_SEND_OP_COND; }
uint8_t RH_RF22::ezmacStatusRead() { return spiRead(RH_RF22_REG_31_EZMAC_STATUS); }
void getRawMeasure(int channel) { unsigned long long data=0; //ulong data=0; uint Flag; //float temp = 0.0; uint temp =0; BYTE NflagPA =0;//有功通道A // BYTE NflagPB =0;//有功通道B // BYTE NflagPQ =0;//无功通道 if(channel > 8 || channel < 0) { printf("\nSPI channel over range.\n"); return ; } spiRead(channel, SYSCON, (uint *)&data, WIDTH_TWO_B); printf("\n SYSCON = 0x%x", (uint)data); spiRead(channel, EMUCON, (uint *)&data, WIDTH_TWO_B); printf("\n EMUCON = 0x%x", (uint)data); spiRead(channel, HFCONST, (uint *)&data, WIDTH_TWO_B); printf("\n HFCONST = 0x%x", (uint)data); spiRead(channel, PSTART, (uint *)&data, WIDTH_TWO_B); printf("\n PSTART = 0x%x", (uint)data); spiRead(channel, PFCNT, (uint *)&data, WIDTH_TWO_B); printf("\n PFCNT = 0x%x", (uint)data); spiRead(channel, QFCNT, (uint *)&data, WIDTH_TWO_B); printf("\n QFCNT = 0x%x\n", (uint)data); spiRead(channel, IARMSOS, (uint *)&data, WIDTH_TWO_B); printf("\n IARMSOS = 0x%x", (uint)data); spiRead(channel, IBRMSOS, (uint *)&data, WIDTH_TWO_B); printf("\n IBRMSOS = 0x%x", (uint)data); spiRead(channel, GPQA, (uint *)&data, WIDTH_TWO_B); printf("\n GPQA = 0x%x", (uint)data); spiRead(channel, GPQB, (uint *)&data, WIDTH_TWO_B); printf("\n GPQB = 0x%x", (uint)data); spiRead(channel, APOSA, (uint *)&data, WIDTH_TWO_B); printf("\n APOSA = 0x%x", (uint)data); spiRead(channel, APOSB, (uint *)&data, WIDTH_TWO_B); printf("\n APOSB = 0x%x", (uint)data); spiRead(channel, RPOSA, (uint *)&data, WIDTH_TWO_B); printf("\n RPOSA = 0x%x", (uint)data); spiRead(channel, RPOSB, (uint *)&data, WIDTH_TWO_B); printf("\n RPOSB = 0x%x", (uint)data); spiRead(channel, PHSA, (uint *)&data, WIDTH_ONE_B); printf("\n PHSA = 0x%x", (uint)data); spiRead(channel, PHSB, (uint *)&data, WIDTH_ONE_B); printf("\n PHSB = 0x%x", (uint)data); spiRead(channel, QPHSCAL, (uint *)&data, WIDTH_TWO_B); printf("\n QPHSCAL = 0x%x\n", (uint)data); spiRead(channel, IARMS, (uint *)&data, WIDTH_THREE_B); if((data >= 0x800000)||(data == 0)) { data = 0; temp = 0; } else { temp = (uint)(((*(WORD *)&SysParam[SP_RNKIA+2*channel])*data)/10000+1);//补偿0.1mA } printf("\n IARMS = 0x%x current:%d.%d mA KiA=%d", (uint)data, temp/10,temp%10,*(WORD *)&SysParam[SP_RNKIA+2*channel]); printf("\n IARMSV =%dmV ",(uint)(data*2500/(0x7FFFFF+1))); /* spiRead(channel, IBRMS, &data, WIDTH_THREE_B); if((data >= 0x800000)||(data == 0)) { data = 0; temp = 0; } else { temp = ((*(WORD *)&SysParam[SP_RNKIB+2*channel]) * data)/10000+1;// 补偿0.1mA } printf("\n IBRMS = 0x%x current:%d.%d mA KiB=%d", data, temp/10,temp%10,*(WORD *)&SysParam[SP_RNKIB+2*channel]); */ spiRead(channel, URMS, (uint *)&data, WIDTH_THREE_B); printf("\n URMS = 0x%x ", (uint)data); if((data >= 0x800000)||(data < 0x24B)) { data = 0; } temp = (uint)(((*(WORD *)&SysParam[SP_RNKU+2*channel])* data)/1000000); printf("\n URMS = 0x%x voltage:%d.%d V Ku=%d", (uint)data, temp/10,temp%10,(*(WORD *)&SysParam[SP_RNKU+2*channel])); printf("\n URMSV =%dmV ",(uint)(data*2500/(0x7FFFFF+1))); spiRead(channel, UFREQ, (uint *)&data, WIDTH_TWO_B); printf("\n UFREQ = 0x%x\n", (uint)data); spiRead(channel, POWERPA, (uint *)&data, WIDTH_FOUR_B); printf("\n POWERPA = 0x%x", (uint)data); if(data>0x80000000)//负数 { spiRead(channel, EMUSTATUS, &Flag, WIDTH_THREE_B); if((Flag&0x20000)&&((Flag&0x200000)==0))//REVP=1,chnsel=0 { data = (data-1)^0x7fffffff; data =data&0x7fffffff; //data = ~data+1; NflagPA=1; } else { data =0; } } //数据有溢出可能 temp = (uint )(((*(WORD *)&SysParam[SP_RNKAP+2*channel])*data)/1000000);//扩大10 if(NflagPA == 1) { NflagPA=0; printf("\n POWERPA = 0x%x PA=-%d.%d W KpA=%d", (uint)data,temp/10,temp%10,*(WORD *)&SysParam[SP_RNKAP+2*channel]); } else { printf("\n POWERPA = 0x%x PA= %d.%d W KpA=%d", (uint)data,temp/10,temp%10,*(WORD *)&SysParam[SP_RNKAP+2*channel]); } /* spiRead(channel, POWERPB, &data, WIDTH_FOUR_B); printf("\n POWERPB = 0x%x", data ); if(data>0x80000000)//负数 { spiRead(channel, EMUSTATUS, &Flag, WIDTH_THREE_B); if((Flag&0x20000)&&((Flag&0x200000)==1))//REVP=1,chnsel=1 { data = (data-1)^0x7fffffff; data = data&0x7fffffff; NflagPB =1; } else { data =0; } } temp = ((*(WORD*)&SysParam[SP_RNKBP+2*channel])*data)/1000000; if(NflagPB == 1) { NflagPB =0; printf("\n POWERPB = 0x%x PB=-%d.%d W KpB=%d", data,temp/10,temp%10,*(WORD*)&SysParam[SP_RNKBP+2*channel]); } else { printf("\n POWERPB = 0x%x PB= %d.%d W KpB=%d", data,temp/10,temp%10,*(WORD*)&SysParam[SP_RNKBP+2*channel]); } spiRead(channel, POWERQ, &data, WIDTH_FOUR_B); printf("\n POWERQ = 0x%x", data); if(data>0x80000000)//负数 { spiRead(channel, EMUSTATUS, &Flag, WIDTH_THREE_B); if(Flag&0x30000)//REVQ=1 { data = ((data-1)^0x7fffffff); data = data&0x7fffffff; NflagPQ =1; } else { data =0; } } if(NflagPQ ==1) { NflagPQ = 0; } else { } printf("\n POWERQ = 0x%x\n", data); */ spiRead(channel, ENERGYP, (uint *)&data, WIDTH_THREE_B); temp = (data+ *(DWORD *)&EEPROMPARAM[EEPROM_ENERGY + 4*channel])*100/EC; printf("\n ENERGYP = 0x%x , EE= %d.%d%d kWh", (uint)data,temp/100,temp%100/10,temp%10); spiRead(channel, ENERGYP2, (uint *)&data, WIDTH_THREE_B); temp = data*100/EC; printf("\n ENERGYP2 = 0x%x ,EE2= %d.%d%d kWh", (uint)data,temp/100,temp%100/10,temp%10); spiRead(channel, ENERGYQ, (uint *)&data, WIDTH_THREE_B); printf("\n ENERGYQ = 0x%x", (uint)data); temp = data*100/EC; printf("\n ENERGYPQ = %d kVARh\n", (uint)data); spiRead(channel, IF, (uint *)&data, WIDTH_ONE_B); printf("\n interrupt = 0x%x", (uint)data); spiRead(channel, IE, (uint *)&data, WIDTH_ONE_B); printf("\n IE = 0x%x", (uint)data); spiRead(channel, EMUSTATUS, (uint *)&data, WIDTH_THREE_B); printf("\n EMUSTATUS = 0x%x", (uint)data); spiRead(channel, HFCONST, (uint *)&data, WIDTH_TWO_B); printf("\n HFCONST = 0x%x buf=0x%x", (uint)data,*(WORD *)&SysParam[SP_RNHFCONST+2*channel]); QF_PF_IRQn_Output(channel); }