/** * Reads an accelerometer value from a single register. Reading from * the accelerometer is common for all directions. * * @param[in] reg The register address to read from * @param[in] scale_weight The weight for the accelerometer values * @return the acceleration value in g's */ double Accel_ReadImpl(uint32_t reg, double scale_weight) { NiFpga_Status status; uint16_t value; double scaledValue; /* * Get the value of the acceleration value register. * * The returned NiFpga_Status value is stored for error checking. */ status = NiFpga_ReadU16(myrio_session, reg, &value); /* * Check if there was an error reading from the read register. * * If there was an error then the rest of the function cannot complete * correctly so print an error message to stdout and return from the * function early. */ MyRio_ReturnValueIfNotSuccess(status, 0.0, "Could not read from the accelerometer value register!") /* * The value is always stored in an unsigned 16-bit register, but the value * is actually a signed 16-bit value. Cast this value directly to a signed * 16-bit value. */ scaledValue = ((int16_t) value) * scale_weight; return scaledValue; }
/** * Reads the encoder status, returning the status as bits. * * @param[in] channel A struct containing the registers on the encoder channel * to read. * @return The status as a bit field. */ uint8_t Encoder_Status(MyRio_Encoder* channel) { NiFpga_Status status; uint8_t statusValue; /* * Get the value of the status register. * * The returned NiFpga_Status value is stored for error checking. */ status = NiFpga_ReadU8(myrio_session, channel->stat, &statusValue); /* * Check if there was an error reading from the encoder register. * * If there was an error then the status is undefined.rest Print an * error message to stdout and return a default status. */ MyRio_ReturnValueIfNotSuccess(status, 0, "Could not read from the encoder status register!"); /* * Return the value of the status. */ return statusValue; }
/** * Reads the number of steps that the encoder has gone through. The behavior * depends on the SignalMode. * * ENC_QUAD_PHASE: * The counter increments when phase A leads phase B and decrements when phase * B leads phase A. * * ENC_SET_AND_DIRECTION: * The counter increments when the direction input is low and decrements when * the direction input is high. * * @param[in] channel A struct containing the registers on the encoder channel * to read. * @return The status as a bit field. */ uint32_t Encoder_Counter(MyRio_Encoder* channel) { NiFpga_Status status; uint32_t counterValue; /* * Get the value of the counter register. * * The returned NiFpga_Status value is stored for error checking. */ status = NiFpga_ReadU32(myrio_session, channel->cntr, &counterValue); /* * Check if there was an error reading from the encoder register. * * If there was an error then the value of the counter is undefined * so print an error message to stdout and return 0. */ MyRio_ReturnValueIfNotSuccess(status, 0, "Could not read from the encoder counter register!"); /* * Return the value of the counter. */ return counterValue; }
/** * Reads a voltage value to from single channel. The channel structure must * previously been initialized with the appropriate scale factors with * AnalogScaling. * * @param[in] channel A struct containing the registers for the AIO * channel to be read from * @return the voltage value in volts */ double Aio_Read(MyRio_Aio* channel) { NiFpga_Status status; uint16_t value = 0; double scaledValue; /* * Get the value of the value register. * * The returned NiFpga_Status value is stored for error checking. */ status = NiFpga_ReadU16(myrio_session, channel->val, &value); /* * Check if there was an error reading from the read register. * * If there was an error then the rest of the function cannot complete * correctly so print an error message to stdout and return from the * function early. Return 0.0 as the read input value. */ MyRio_ReturnValueIfNotSuccess(status, 0.0, "Could not read from the AI value registers!"); /* * The value is always stored in an unsigned 16-bit register. For a signed * channel, cast this value directly to a signed 16-bit value. */ if (channel->is_signed) { scaledValue = (int16_t)value * channel->scale_weight + channel->scale_offset; } else { scaledValue = value * channel->scale_weight + channel->scale_offset; } return scaledValue; }
/** * Overview: * Demonstrates using the PWM. Generates a PWM signal from PWM 0 on * connector A. * * Instructions: * 1. Connect an oscilloscope to the PWM 0 pin on connector A. * 2. Run this program. * * Output: * The program generates a 25% duty cycle signal at 10 kHz for 60 s. * * Note: * The Eclipse project defines the preprocessor symbol for the NI myRIO-1900. * Change the preprocessor symbol to use this example with the NI myRIO-1950. */ int main(int argc, char **argv) { NiFpga_Status status; MyRio_Pwm pwmA0; uint8_t selectReg; time_t currentTime; time_t finalTime; printf("PWM\n"); /* * Initialize the PWM struct with registers from the FPGA personality. */ pwmA0.cnfg = PWMA_0CNFG; pwmA0.cs = PWMA_0CS; pwmA0.max = PWMA_0MAX; pwmA0.cmp = PWMA_0CMP; pwmA0.cntr = PWMA_0CNTR; /* * Open the myRIO NiFpga Session. * This function MUST be called before all other functions. After this call * is complete the myRIO target will be ready to be used. */ status = MyRio_Open(); if (MyRio_IsNotSuccess(status)) { return status; } /* * Set the waveform, enabling the PWM onboard device. */ Pwm_Configure(&pwmA0, Pwm_Invert | Pwm_Mode, Pwm_NotInverted | Pwm_Enabled); /* * Set the clock divider. The internal PWM counter will increments at * f_clk / 4 * * where: * f_clk = the frequency of the myRIO FPGA clock (40 MHz default) */ Pwm_ClockSelect(&pwmA0, Pwm_4x); /* * Set the maximum counter value. The counter counts from 0 to 1000. * * The counter increments at 40 MHz / 4 = 10 MHz and the counter counts * from 0 to 1000. The frequency of the PWM waveform is 10 MHz / 1000 * = 10 kHz. */ Pwm_CounterMaximum(&pwmA0, 1000); /* * Set the comparison counter value. The PWM counter counts from 0 to 1000 * and outputs from 0 to the comparison value (250). * * The duty cycle is 250 / 1000 = 25%. */ Pwm_CounterCompare(&pwmA0, 250); /* * PWM outputs are on pins shared with other onboard devices. To output on * a physical pin, select the PWM on the appropriate SELECT register. See * the MUX example for simplified code to enable-disable onboard devices. * * Read the value of the SYSSELECTA register. */ status = NiFpga_ReadU8(myrio_session, SYSSELECTA, &selectReg); MyRio_ReturnValueIfNotSuccess(status, status, "Could not read from the SYSSELECTA register!") /* * Set bit2 of the SYSSELECTA register to enable PWMA_0 functionality. * The functionality of the bit is specified in the documentation. */ selectReg = selectReg | (1 << 2); /* * Write the updated value of the SYSSELECTA register. */ status = NiFpga_WriteU8(myrio_session, SYSSELECTA, selectReg); MyRio_ReturnValueIfNotSuccess(status, status, "Could not write to the SYSSELECTA register!") /* * Normally, the main function runs a long running or infinite loop. * Keep the program running for 60 seconds so that the PWM output can be * observed using an external instrument. */ time(¤tTime); finalTime = currentTime + LoopDuration; while (currentTime < finalTime) { time(¤tTime); } /* * Close the myRIO NiFpga Session. * This function MUST be called after all other functions. */ status = MyRio_Close(); /* * Returns 0 if successful. */ return status; }