// Begin executing the specified proc. // NOTE: place the current proc into the correct queue before calling void SwitchToProc(PCB *next_proc, UserContext *user_context) { TracePrintf(TRACE_LEVEL_FUNCTION_INFO, ">>> SwitchToProc()\n"); assert(user_context); assert(next_proc); // Save current user state current_proc->user_context = *user_context; TracePrintf(TRACE_LEVEL_DETAIL_INFO, "Loading next proc context into %p\n", user_context); TracePrintf(TRACE_LEVEL_DETAIL_INFO, "Loading next proc PID: %d\n", next_proc->pid); *user_context = next_proc->user_context; // Set the TLB registers for the region 1 page table. WriteRegister(REG_PTBR1, (unsigned int) next_proc->region_1_page_table); WriteRegister(REG_TLB_FLUSH, TLB_FLUSH_1); PCB *old_proc = current_proc; current_proc = next_proc; int rc = KernelContextSwitch(&SaveKernelContextAndSwitch, old_proc, next_proc); if (SUCCESS == rc) { TracePrintf(TRACE_LEVEL_DETAIL_INFO, "Succesfully switched kernel context!\n"); } else { TracePrintf(TRACE_LEVEL_NON_TERMINAL_PROBLEM, "Failed to save kernel context!\n"); char *err_str = calloc(TERMINAL_MAX_LINE, sizeof(char)); sprintf(err_str, "KernelContextSwitch failed!!! HALTING!!!\n", current_proc->pid); KernelTtyWriteInternal(0, err_str, strnlen(err_str, TERMINAL_MAX_LINE), user_context); free(err_str); Halt(); } // Restore user state of new current process *user_context = current_proc->user_context; TracePrintf(TRACE_LEVEL_FUNCTION_INFO, "<<< SwitchToProc()\n"); }
void TurboNRF24L01::SetPayloadSize(uint8_t payload) { m_Payload = payload; // Set length of incoming payload WriteRegister(RX_PW_P0, m_Payload); WriteRegister(RX_PW_P1, m_Payload); }
void LoadNextProc(UserContext *context, int block) { DelayPop(); if (!queueIsEmpty(ready_queue)) { if (current_process) { current_process->user_context = *context; if (block == NO_BLOCK) { queuePush(ready_queue, current_process); } } PCB *next = queuePop(ready_queue); TracePrintf(1, "LoadNextProc: Next Process Id: %d\n", next->id); if(next->id == 2) TracePrintf(3, "LoadNextProc: PCB has %p child\n", next->parent->children->head); WriteRegister(REG_PTBR1, (unsigned int) &(next->cow.pageTable)); WriteRegister(REG_TLB_FLUSH, TLB_FLUSH_1); KernelContextSwitch(MyKCS, current_process, next); TracePrintf(1, "LoadNextProc: Got past MyKCS\n"); *context = current_process->user_context; TracePrintf(3, "LoadNextProc: current user context pc is %p\n", context->pc); } }
void NRF24L01p::Transmit(uint8_t* data, uint8_t size) { uint8_t reg = 0; reg = ReadRegister(NRF24L01p_REGISTER_ADDRESS_CONFIG); reg &= ~((uint8_t)(0b1<<NRF24L01p_MNEMONIC_CONFIG_PRIM_RX)); //Put the device in TX mode. WriteRegister(NRF24L01p_REGISTER_ADDRESS_CONFIG, reg); CyDelayUs(150); //Wait for the device to switch to TX mode. uint8_t buffer[33] = {0}; buffer[0] = NRF24L01p_INSTRUCTION_W_TX_PAYLOAD_NO_ACK; memcpy(&buffer[1], data, size); NRF24L01p_CS_Write(0); NRF24L01p_SPI_CONTROLLER_PutArray(buffer, size+1); CyDelayUs(10); NRF24L01p_CS_Write(1); NRF24L01p_CE_Write(1); //Make the NRF24L01p transmit the data. CyDelayUs(10); NRF24L01p_CE_Write(0); reg |= 0b1<<NRF24L01p_MNEMONIC_CONFIG_PRIM_RX; //Put the device in RX mode. CyDelayUs(1400); WriteRegister(NRF24L01p_REGISTER_ADDRESS_CONFIG, reg); }
void SetHardwareAttenuator(unsigned char attenuatormode) { unsigned char old_value; old_value = ReadRegister(CONFIG_REG_ADDR); if (attenuatormode != 0) WriteRegister(CONFIG_REG_ADDR, old_value |= HARDWAREATT_SET_FLAG); else WriteRegister(CONFIG_REG_ADDR, old_value &= ~HARDWAREATT_SET_FLAG); }
void SetRadioEnabledState(unsigned char mode) { unsigned char old_value; old_value = ReadRegister(CONFIG_REG_ADDR); if (mode != 0) WriteRegister(CONFIG_REG_ADDR, old_value |= RADIO_ENABLED_FLAG); else WriteRegister(CONFIG_REG_ADDR, old_value &= ~RADIO_ENABLED_FLAG); }
void TurboNRF24L01::PowerUpRX() { m_IsSendState = 0; m_CE.Low(); WriteRegister(CONFIG, CRC_CONFIG | ((1 << PWR_UP) | (1 << PRIM_RX))); m_CE.High(); WriteRegister(STATUS, (1 << TX_DS) | (1 << MAX_RT)); }
static void rfid_task(void *pvParameters) { int i; static unsigned char data[80]; /* touch unused Parameter */ (void) pvParameters; /* release reset line after 400ms */ vTaskDelay( 400 / portTICK_RATE_MS); rfid_reset(1); /* wait for PN532 to boot */ vTaskDelay( 100 / portTICK_RATE_MS); /* read firmware revision */ debug_printf("\nreading firmware version...\n"); data[0] = PN532_CMD_GetFirmwareVersion; rfid_execute(&data, 1, sizeof(data)); /* enable debug output */ debug_printf("\nenabling debug output...\n"); WriteRegister(0x6328, 0xFC); // select test bus signal WriteRegister(0x6321, 6); // select test bus type WriteRegister(0x6322, 0x07); while (1) { /* wait 100ms */ vTaskDelay( 100 / portTICK_RATE_MS); /* detect cards in field */ GPIOSetValue(LED_PORT, LED_BIT, LED_ON); debug_printf("\nchecking for cards...\n"); data[0] = PN532_CMD_InListPassiveTarget; data[1] = 0x01; /* MaxTg - maximum cards */ data[2] = 0x00; /* BrTy - 106 kbps type A */ if (((i = rfid_execute(&data, 3, sizeof(data))) >= 11) && (data[1] == 0x01) && (data[2] == 0x01)) { debug_printf("card id: "); rfid_hexdump(&data[7], data[6]); } else debug_printf("unknown response of %i bytes\n", i); GPIOSetValue(LED_PORT, LED_BIT, LED_OFF); /* turning field off */ debug_printf("\nturning field off again...\n"); data[0] = PN532_CMD_RFConfiguration; data[1] = 0x01; /* CfgItem = 0x01 */ data[2] = 0x00; /* RF Field = off */ rfid_execute(&data, 3, sizeof(data)); } }
bool BME280::WriteSettings() { uint8_t ctrlHum, ctrlMeas, config; CalculateRegisters(ctrlHum, ctrlMeas, config); WriteRegister(CTRL_HUM_ADDR, ctrlHum); WriteRegister(CTRL_MEAS_ADDR, ctrlMeas); WriteRegister(CONFIG_ADDR, config); }
int main(void) { WDTCTL = WDTPW | WDTHOLD; // Interrompe o watchdog timer. BCSCTL1 = CALBC1_16MHZ; // Configura o DCO para 16MHz. DCOCTL = CALDCO_16MHZ; BCSCTL2 = BCSCTL2 | DIVS_0; // Configura SMCLK para 16MHz. P2DIR = P2DIR & (~PIN_INT1) & (~PIN_INT2); // Configura pinos INT1 e INT2. P4OUT = P4OUT | PIN_CS_ACC; // Configura pino CS do acelerômetro. P4DIR = P4DIR | PIN_CS_ACC; P3SEL = P3SEL | PIN_MOSI | PIN_MISO | PIN_SCK; // Configura pinos SPI. UCB0CTL0 = UCB0CTL0 | UCSYNC | UCMODE_1 | UCMST | UCMSB | UCCKPH; // Configura SPI. UCB0CTL1 = UCB0CTL1 | UCSSEL_2; UCB0BR0 = 0x08; // SPI Speed = 16MHz/8 = 2MHz // Maximum Speed = 4MHz. UCB0BR1 = 0x00; UCB0CTL1 = UCB0CTL1 & (~UCSWRST); P4OUT = P4OUT & (~PIN_CS_ACC); // Configura acelerômetro. WriteRegister(MCTL, 0x05); if (ReadRegister(MCTL) == 0x05) { P2OUT = ~PIN_LED1 | ~PIN_LED2 | ~PIN_LED3; P2DIR = PIN_LED1 | PIN_LED2 | PIN_LED3; } acc_id = ReadRegister(WHOAMI); while(1); }
/*XmitPacket: send a data byte/block to the rf module*/ BYTE XmitPacket(BYTE *data, BYTE length) { RF_CE = 0; //early return if packet length is too long if (length > 32) return 1; //Clear Interrupts WriteRegister(STATUS, (STATUS_TX_DS | STATUS_RX_DR | STATUS_MAX_RT)); //load tx fifo WriteTxPayload(data, length); //send packet PulseCe(); //block until acknowledge or timeout while (1) { if (CheckInterrupt(STATUS_MAX_RT)) { OutCommand(FLUSH_TX); return 2; } if (CheckInterrupt(STATUS_TX_DS)) return 0; } /*FIXME:implement state?*/ //set state }
uint8_t cc1101_t::Init() { // ==== GPIO ==== PinSetupOut (CC_GPIO, CC_CS, omPushPull); PinSetupAlterFunc(CC_GPIO, CC_SCK, omPushPull, pudNone, CC_SPI_AF); PinSetupAlterFunc(CC_GPIO, CC_MISO, omPushPull, pudNone, CC_SPI_AF); PinSetupAlterFunc(CC_GPIO, CC_MOSI, omPushPull, pudNone, CC_SPI_AF); IGdo0.Init(ttFalling); //PinSetupAnalog (CC_GPIO, CC_GDO2); // GDO2 not used CsHi(); // ==== SPI ==== // MSB first, master, ClkLowIdle, FirstEdge, Baudrate no more than 6.5MHz ISpi.Setup(boMSB, cpolIdleLow, cphaFirstEdge, sbFdiv16); ISpi.Enable(); // ==== Init CC ==== if(Reset() != OK) { ISpi.Disable(); Uart.Printf("\rCC Rst Fail"); return FAILURE; } // Check if success WriteRegister(CC_PKTLEN, 7); uint8_t Rpl = ReadRegister(CC_PKTLEN); if(Rpl != 7) { ISpi.Disable(); Uart.Printf("\rCC R/W Fail; rpl=%u", Rpl); return FAILURE; } // Proceed with init FlushRxFIFO(); RfConfig(); IGdo0.EnableIrq(IRQ_PRIO_HIGH); return OK; }
/***************************************************************************** Modifica la base de exposicion nBaseExposicion - en microsegundos Devuelve true si todo bien *****************************************************************************/ bool ModificaBaseExposicion(int nBaseExposicion) { if (Address == 0) //Primera vez que se accede al registro avanzado de la base de exposicion { Address = LeeAddressTimeBase(); if (Address == 0) return false; // Leer cabecera (COMPROBACION) if (ReadRegister(M_sistema, M_DEV0, Address + 0) == 0) return false; } // Escribir shutter time base float fShutterTimeBase = (float)nBaseExposicion/(float)1000000; QUADLET qTimeBase = *((QUADLET *)&fShutterTimeBase); WriteRegister(M_sistema, M_DEV0, Address + 16, qTimeBase); // Leer shutter time base (COMPROBACION) QUADLET Value = ReadRegister(M_sistema, M_DEV0, Address + 16); float base = *((float *)&Value); base = base * 1000000; ASSERT((int)base == nBaseExposicion); return true; }
bool NRF24L01p::Receive(uint8_t* data, uint8_t size) { NRF24L01p_CE_Write(1); //Start listening. CyDelay(2); //Give it some time to receive the package. uint8_t status = ReadRegister(NRF24L01p_REGISTER_ADDRESS_STATUS); if(status&(0b1<<NRF24L01p_MNEMONIC_STATUS_RX_DR)) //Check if we received a package. { WriteRegister(NRF24L01p_REGISTER_ADDRESS_STATUS, 0b1<<NRF24L01p_MNEMONIC_STATUS_RX_DR); //Clear the bit that says we received a package. NRF24L01p_CS_Write(0); NRF24L01p_SPI_CONTROLLER_WriteTxData(NRF24L01p_INSTRUCTION_R_RX_PAYLOAD); //Prepare to read the payload. CyDelayUs(5); for(uint8_t c=0; c<size; c++) //Receive the data. { NRF24L01p_SPI_CONTROLLER_WriteTxData(NRF24L01p_INSTRUCTION_NOP); //Sending NOPs all day long. Sending NOPs while I sing this song. CyDelayUs(5); //Give the received data some time to settle in. data[c] = NRF24L01p_SPI_INPUT_REG_ReadRegValue(); } CyDelayUs(10); //TODO: Check why this one is here. NRF24L01p_CS_Write(1); NRF24L01p_CE_Write(0); NRF24L01p_SPI_CONTROLLER_WriteTxData(NRF24L01p_INSTRUCTION_FLUSH_RX); //Clean up any other packets. CyDelayUs(5); return true; } NRF24L01p_CE_Write(0); return false; }
/** * Set the display window area with a upper, left-hand corner at (x, y) * that is sx pixels wide and sy pixels high. * * @param x upper left hand X coordinate window position * @param y upper left hand Y coordinate window position * @param sx width of window in pixels * @param sy height of window in pixels */ void OSD0201QILK::Window(uint32_t x, uint32_t y, uint32_t sx, uint32_t sy) { // Vertical start address. WriteRegister (0x35, y); // Vertical end address. WriteRegister (0x36, y + sy - 1); // Horizontal address range. WriteRegister (0x37, ((x + 0x20) << 8) | (x + sx + 0x20 - 1)); // X start address. WriteRegister (0x20, x + 0x20); // Y start address. WriteRegister (0x21, y); }
void TurboNRF24L01::GetRecvData(uint8_t * val) { m_CSN.Low();// Pull down chip select m_SPI.Send(R_RX_PAYLOAD);// Send cmd to read rx payload m_SPI.Receive(val, m_Payload);// Read payload m_CSN.High(); // Pull up chip select WriteRegister(STATUS, (1 << RX_DR)); // Reset status register }
void OGNRadio::SendPacket(uint8_t *Packet, uint16_t Size, uint16_t Freq, uint8_t TxPower) { uint8_t i; SetTxPower(TxPower); SetFrequency(Freq); WriteRegister(REG_PAYLOADLENGTH, Size); WriteRegister(REG_SYNCCONFIG,RF_SYNC_OFF); WriteRegister(REG_PREAMBLEMSB, 0x00); WriteRegister(REG_PREAMBLELSB, 0x80); ClearIRQFlags(); for(i=0;i<Size;i++) { WriteRegister(REG_FIFO,Packet[i]); } WriteRegister(REG_OPMODE , RF_DATAMODUL_MODULATIONTYPE_FSK | RF_OPMODE_LISTEN_OFF | RF_OPMODE_TRANSMITTER); do {} while( (ReadRegister(REG_IRQFLAGS2) & RF_IRQFLAGS2_PACKETSENT ) != RF_IRQFLAGS2_PACKETSENT); WriteRegister(REG_OPMODE, RF_DATAMODUL_MODULATIONTYPE_FSK | RF_OPMODE_LISTEN_OFF | RF_OPMODE_STANDBY); }
IMU::IMU(void) { char buf[1]; bcm2835_init(); bcm2835_i2c_begin(); bcm2835_i2c_setSlaveAddress(MPU6050_ADDRESS); WriteRegister(SMPRT_DIV,0x07); // Set the sample rate to 1000Hz - 8kHz/(7+1) = 1000Hz WriteRegister(CONFIG,0x00); // Disable FSYNC and set 260 Hz Acc filtering, 256 Hz Gyro filtering, 8 KHz sampling WriteRegister(GYRO_CONFIG,0x00); //250dpi WriteRegister(ACCEL_CONFIG,0x00); //2g resolution WriteRegister(PWR_MGMT_1,0x00); //sleep mode disabled regaddr[0]=WHO_AM_I; bcm2835_i2c_write(regaddr, 1); bcm2835_i2c_read(buf, 1); if(buf[0]==0x88) { printf("sensor config was successful WHO_AM_I: %x\n",buf[0]); } else { printf("sensor config was unsuccessful, %x\n",buf[0]); } bcm2835_i2c_end(); ///////////SETUP VARIABLES ReadGyr(); ReadAccel(); #ifdef RESTRICT_PITCH // Eq. 25 and 26 KFData.roll = atan2(AData.y, AData.z) * RAD_TO_DEG; KFData.pitch = atan(-AData.x / sqrt(AData.y * AData.y + AData.z * AData.z)) * RAD_TO_DEG; #else // Eq. 28 and 29 KFData.roll = atan(AData.y / sqrt(AData.x * AData.x + AData.z * AData.z)) * RAD_TO_DEG; KFData.pitch = atan2(-AData.x, AData.z) * RAD_TO_DEG; #endif kalmanX.setAngle(KFData.roll); // Set starting angle kalmanY.setAngle(KFData.pitch); }
bool RegisterContextPOSIXProcessMonitor_arm64::WriteRegister(const lldb_private::RegisterInfo *reg_info, const lldb_private::RegisterValue &value) { const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB]; if (IsGPR(reg)) return WriteRegister(reg, value); return false; }
void Beep(unsigned frequency) { if (!m_hasBeeper) return; if (frequency == 0) { WriteRegister(0x1a, 0x1); // Turn Beeper off return; } int divisor = 46875 / frequency - 1; if (divisor < 1) divisor = 1; else if (divisor > 255) divisor = 255; WriteRegister(0x18, divisor); // set frequency WriteRegister(0x1a, 0x9); // Turn Beeper on }
//Write individual bits of the configure register void RfConfigure(BYTE bitNum, BYTE enable) { BYTE config = 0; config = ReadRegister(CONFIG); if (enable) config |= 1 << bitNum; else config &= ~(1 << bitNum); WriteRegister(CONFIG, config); }
void SetFrequency( U8 radio, U32 frequency_hz ) { //this function should have greater than 1khz resolution. U8 hbsel_val = 0; U8 fb = 0; U16 fc = 0; U32 temp = 0; U8 reg = 0; if( frequency_hz < 240000000 ) return; if( frequency_hz > 930000000 ) return; //check if high band should be enabled. if( frequency_hz >= 480000000 ) hbsel_val = 1; //find fband, integer component. fb = ((frequency_hz-(240000000 * (hbsel_val + 1)))/10000000); if( hbsel == 1 ) fb = ((frequency_hz-480000000)/10000000); //fc = ( frequency_hz / ( 10000000 * (hbsel + 1) ) - fb - 24 ) * 64000; temp = ( 24ul + fb ) * 10000000ul * ( hbsel_val + 1 ); temp = frequency_hz - temp; temp = temp * 64; temp = temp / (10000 * (hbsel_val + 1)); fc = temp; reg = fb | ( hbsel_val << 5 ) | sbsel; WriteRegister( radio, RFREG_FREQ_BAND_SEL, sbsel | reg ); WriteRegister( radio, RFREG_NOMINAL_CARRIER_FREQ_1, fc >> 8 ); //fc[15:8] WriteRegister( radio, RFREG_NOMINAL_CARRIER_FREQ_0, fc ); //fc[7:0] }
static void OPL_SDL_PortWrite(opl_port_t port, unsigned int value) { if (port == OPL_REGISTER_PORT) { register_num = value; } else if (port == OPL_DATA_PORT) { WriteRegister(register_num, value); } }
/** * * IChannACGainCal() .. returns true on a successful gain setting to 1 and successful * calibration send. */ bool cs5463spi::IChannACGainCal() { bool bSuccess = false; int registerWrite, result; registerWrite = WriteRegister(m_cs5463NumList[i_gain].addr, 0x40, 0x00, 0x00); //sets Gain to 1; result = sendCmd(m_sysCalGain.V_CHAN_AC_GAIN); // Inits I channel AC Gain Calibration if(registerWrite >= 0 && result >= 0) bSuccess = true; return bSuccess; }
void Flea3Camera::SetRawBayerOutput(bool& raw_bayer_output) { // Because this only works in standard video mode, we only enable this if // video mode is not format 7 const auto video_mode_frame_rate_pg = GetVideoModeAndFrameRate(camera_); if (video_mode_frame_rate_pg.first == VIDEOMODE_FORMAT7) { raw_bayer_output = false; return; } // See Point Grey Register Reference document section 5.8 WriteRegister(camera_, 0x1050, static_cast<unsigned>(raw_bayer_output)); }
void SetDataRate( U8 radio, U32 dataRate_bps ) { U8 txdr_lower = 0x00; U8 txdr_upper = 0x00; U16 txdr = 0x0000; if ( dataRate_bps < 30000 ) { // Use txdtrtscale = 1. WriteRegister( radio, RFREG_MOD_MODE_CTRL_1, txdtrtscale ); } else { WriteRegister( radio, RFREG_MOD_MODE_CTRL_1, 0x00 ); } txdr = ComputeTxRateReg( dataRate_bps ); txdr_lower = (U8)txdr; txdr_upper = (U8)( txdr >> 8 ); //data rate below 30 kbps. manchester off. data whitening off. //WriteRegister( radio, RFREG_TX_DATA_RATE_1, 0x27 ); //txdr[15:8] //WriteRegister( radio, RFREG_TX_DATA_RATE_0, 0x52 ); //txdr[7:0] WriteRegister( radio, RFREG_TX_DATA_RATE_1, txdr_upper ); //txdr[15:8] WriteRegister( radio, RFREG_TX_DATA_RATE_0, txdr_lower ); //txdr[7:0] }
/** * Constructor. */ ADIS16448_IMU::ADIS16448_IMU() : m_spi(SPI::Port::kMXP) { m_spi.SetClockRate(1000000); m_spi.SetMSBFirst(); m_spi.SetSampleDataOnFalling(); m_spi.SetClockActiveLow(); m_spi.SetChipSelectActiveLow(); ReadRegister(kRegPROD_ID); // dummy read // Validate the part ID if (ReadRegister(kRegPROD_ID) != 16448) { DriverStation::ReportError("could not find ADIS16448"); return; } // Set IMU internal decimation to 102.4 SPS WriteRegister(kRegSMPL_PRD, 769); // Enable Data Ready (LOW = Good Data) on DIO1 (PWM0 on MXP) WriteRegister(kRegMSC_CTRL, 4); // Configure IMU internal Bartlett filter WriteRegister(kRegSENS_AVG, 1030); m_cmd[0] = kGLOB_CMD; m_cmd[1] = 0; // Configure interrupt on MXP DIO0 m_interrupt.reset(new InterruptSource(10)); m_interrupt->RequestInterrupts(); m_interrupt->SetUpSourceEdge(false, true); // Start monitoring thread m_freed = false; m_task = std::thread(&ADIS16448_IMU::Calculate, this); Calibrate(); //HALReport(HALUsageReporting::kResourceType_ADIS16448, 0); LiveWindow::GetInstance()->AddSensor("ADIS16448_IMU", 0, this); }
bool cs5463spi::IchannACoffsetCal() { bool bCalRdy = false; int result, registerWrite; registerWrite = WriteRegister(m_cs5463NumList[i_ac_offset].addr,0x00, 0x00, 0x00);// Clears I_AC_Offset Register result = sendCmd(m_sysCalOffset.I_CHAN_AC_OFFSET); // Inits I channel AC Offset Calibration if(result >= 0 && registerWrite >= 0) bCalRdy = CalStatusReadyCheck(6E9); return bCalRdy; }
// devuelve 0 si no es posible acceder a la caracteristica avanzada de base de exposicion QUADLET LeeAddressTimeBase() { const int nACR = 0xF2F00000; //direccion del ACR (Access Control Register) (para todos los features) // Set feature set ID to unlock advanced features. NO ES NECESARIO, SIEMPRE HABILITADO EN CAMARAS BASLER QUADLET Enabled1, Enabled2; WriteRegister(M_sistema, M_DEV0, nACR + 0x00, 0x0030533B); WriteRegister(M_sistema, M_DEV0, nACR + 0x04, 0x73C3F000);//last three zeros represent a timeout value, 000 means always available Enabled1 = ReadRegister(M_sistema, M_DEV0, nACR + 0x00); Enabled2 = ReadRegister(M_sistema, M_DEV0, nACR + 0x04); if (Enabled1 == 0xFFFFFFFF && Enabled2 == 0xFFFFFFFF) return false; // Recuperamos la direccion CSR (Control and Status Register) para el shutter time base feature // Escribimos al Smart Features Inquiry Register (que esta 0x10 despues respecto al ACR) // El Inquiry Register esta ordenado asi: D1 | D3 | D2 | D4[3] | D4[2] | D4[1] | D4[0] | D4[7] | D4[6] | D4[5] | D4[4] // El CSR GUID para el shutter time base es D1:648BE1DA D2:A416 D3:11D8 D4:9B47 00105A5BAE55 WriteRegister(M_sistema, M_DEV0, nACR + 0x10, 0x648BE1DA); WriteRegister(M_sistema, M_DEV0, nACR + 0x14, 0x11D8A416); WriteRegister(M_sistema, M_DEV0, nACR + 0x18, 0x1000479B); WriteRegister(M_sistema, M_DEV0, nACR + 0x1C, 0x55AE5B5A); // Al haber "preguntado" por nuestro CSR GUID, obtenemos la direccion CSR // la direccion estará en el Smart Features Addres Register (desplazado 0x20 del ACR return ReadRegister(M_sistema, M_DEV0, nACR + 0x20); }
bool cs5463spi::DisableInterrupts(){ bool action = false; if(WriteRegister(m_cs5463NumList[status].addr, 0x00, 0x00, 0x00)) { //disables interrupts action = true; } else // m_mySPISysLog->writeErrLog("Disable Interrupts failed."); m_pMyLogger->WriteLocal(LOG_LOCAL0, LOG_ERR, "Disable Interrupts failed."); return action; }