SMART STATION

CONFIG.H

The config.h header file includes the ‘plib.h’ library, and contains only a few defines for the project. Namely, it sets the oscillator source to be the 8MHz internal oscillator of the microcontroller, sets the div FPLLIDIV to be 2, the prescalar ‘FPLLMUL’ to 20, and the div’s ‘FPBDIV’ and ‘FPLLODIV’ to be 1 and 2, respectively. This combination of the divisions and multipliers generates a 40MHz system clock source and sets the peripheral bus frequency to be 40MHz.

MAIN.C

The main function within main.c sets up all of the I/O pins used within the project, initializes the ADC and I2C modules, outputs the main menu screen to the TFT display, and sets up I2C transactions between the PIC32 and the accelerometer and luminosity sensor peripherals. First, the main function calls adc_setup() which sets, opens, and enables pin AN11 for analog microphone readouts using the following configuration parameters:

// Ensure the ADC is off before setting the configuration
                    CloseADC10();

                    // ADC_FORMAT_INTG16       Use this in order to get unsigned 16 bit integers
                    //
                    // ADC_CLK_AUTO            This allows for converting the samples immediately 
                    //                         after they are read in
                    //
                    // ADC_AUTO_SAMPLING_OFF   By setting this, sampling is done when the user 
                    //                         wants rather than once the previous sample is done 
                    //                         converting
                    //
                    #define PARAM1  ADC_FORMAT_INTG16 | ADC_CLK_AUTO | ADC_AUTO_SAMPLING_OFF

                    // ADC_VREF_AVDD_AVSS      Set the voltage references to the same as that of 
                    //                         the PIC32 rather than other external references
                    //
                    // ADC_OFFSET_CAL_DISABLE  We don't want to do the extra steps in order to 
                    //                         configure perfect precision as the movement of the 
                    //                         paddle is highly relative
                    //
                    // ADC_SCAN_OFF            Scan mode is disabled because we don't have a 
                    //                         vector of inputs to scan through but rather just 
                    //                         the one
                    //
                    // ADC_SAMPLES_PER_INT_1   Only take one sample per interrupt rather than 
                    //                         more. We only need to know how the paddle moves 
                    //                         once per event
                    //
                    // ADC_ALT_BUF_OFF         Buffer configured as one 16-word buffer rather 
                    //                         than two 8-word buffers
                    //
                    // ADC_ALT_INPUT_OFF       Always use MUX A input multiplexer settings rather 
                    //                         than switching between MUX A and MUX B
                    //
                    #define PARAM2  ADC_VREF_AVDD_AVSS | ADC_OFFSET_CAL_DISABLE | ADC_SCAN_OFF | \
                                    ADC_SAMPLES_PER_INT_1 | ADC_ALT_BUF_OFF | ADC_ALT_INPUT_OFF

                    // ADC_CONV_CLK_PB         Use the peripheral bus clock
                    //
                    // ADC_SAMPLE_TIME_5       Used to properly set acquisition time
                    //
                    // ADC_CONV_CLK_Tcy2       Divide the peripheral bus clock by two in order to 
                    //                         run it at the highest rate using its 8-bit counter
                    //
                    #define PARAM3 ADC_CONV_CLK_PB | ADC_SAMPLE_TIME_5 | ADC_CONV_CLK_Tcy2 

                    // ENABLE_AN11_ANA - enables pin 24 to be our input for the ADC
                    #define PARAM4 ENABLE_AN11_ANA 

                    // SKIP_SCAN_ALL - don't set any channels to scan
                    #define PARAM5 SKIP_SCAN_ALL

                    // ADC_CH0_NEG_SAMPLEA_NVREF  Sets the negative input of the MUX to the 
                    //                            negative reference of the PIC32
                    //
                    // ADC_CH0_POS_SAMPLEA_AN11   Sets the positive input select to be AN11
                    //
                    SetChanADC10(ADC_CH0_NEG_SAMPLEA_NVREF | ADC_CH0_POS_SAMPLEA_AN11);

                    // Configure ADC using the parameters defined above
                    OpenADC10(PARAM1, PARAM2, PARAM3, PARAM4, PARAM5);

                    // Enable the ADC 
                    EnableADC10();

After initializing the ADC for the microphone peripheral, the main function initializes the TFT display and sets up pin RA2 as a digital output for the data in line of the NeoPixel LED ring. The function then calls the sensors_setup function, which initializes a global array of sensor structs with the following attributes for each sensor peripheral: name, maximum possible value, minimum possible value, high trigger value, low trigger value, and plot color. By default, the high and low trigger values were chosen so that, during our demo, we could interact with the sensors and cause them to trigger on certain events (i.e. shining a phone light on the luminosity sensor or breathing on the humidity sensor). After initializing the sensor struct, the main function then uses the i2c_rw.h driver, discussed below, to write registers that initialize I2C transactions with the accelerometer and luminosity sensors. Afterwards, the main function calibrates the accelerometer by performing a series of I2C reads and determining the appropriate constants for zeroing out the x, y, and z-acceleration readouts. Lastly, the main function calls a method which makes the NeoPixel LED ring at the top of the device turn blue before scheduling all of the program threads.

The pt_measure thread is responsible for calling of the sensor update functions and storing the new readings in the global array of current sensor values. This function reads out current microphone analog input voltage and squares it to obtain a sufficient statistic for the power output of the speaker. The program then averages the readout with the past 10 sensor readouts and stores the average power in a global variable that is used for reactive lighting in the pt_led thread. After calculating the sufficient statistic for the average mic power, the thread then calls the i2c_rw functions for the accelerometer, temperature, humidity, and luminosity sensors. These methods are described in extensive detail in the i2c_rw.h section, as well as within the comments for the file.

The pt_led thread contains all of the necessary logic for toggling between reactive music mode and idle modes depending on the current state of the device and the current power output of the mic. When the thread is first entered and the user is on the music screen, the NeoPixel LED ring will remain solid red until the first power spike in the speaker output. Once this peak is detected, the LED will alternate between one of three color states with varying levels of either red, green, and blue RGB values – with each state being based on the magnitude of the power spike (lower power spikes lead to more neutral coloring while higher power spikes lead to sharper coloring). Additionally, between any two power spikes, the direction in which the new color sweeps across the NeoPixel LED ring is reversed, creating a back and forth motion effect. Whenever the average mic power is below a specified threshold value, the NeoPixel LED ring will remain a solid color.

The protothread_input contains all of the necessary logic for reading/debouncing keypad values and performing actions on the device according to current menu that the device is in: either the main screen, the settings screen, the music screen, or the graph screen. The keypad readout code is based off of the example project located in the ZIP file on the index_TFT_display page of the ECE 4760 website. Initially, the thread declares the length 12 keytable array containing all of the various key encodings and initializes the input and output pins on the keypad. The keypad array is in order from 0-9, followed by * and #, where the absence of a valid key press is encoded by the index -1. In the while-loop for this thread, each row of the keypad is read out by driving the analog output A0 which is input to a demultiplexer, changing the demultiplexer control signal to switch between one of the first four input pins on the keypad, and reading the outputs on the keypad pins 6 through 8 which are connected to PIC32 digital input pins RB5, RB7, and RB10 respectively.

If any of the keys have been pressed, one or more of the digital inputs will detect a non-zero value which is compared with the entries in the keypad table. If there is a match, the index of the matched entry is stored in a variable. The index ‘-1’ encodes no match, ‘0-9’ encode digits 0 through 9, ‘10’ encodes *, and ‘11’ encodes #. In the debouncing state machine, there is a switch statement containing no push, maybe push, pushed, and maybe no push states. In order for a press to be registered as a valid button press and enter the pushed state of the FSM, the press must be detected for two consecutive executions of the keypad thread. The pressed state of the debug state machine contains a nested FSM where the each of the 4 screen states has its own independent switch-statement that defines what actions can be performed on that screen using the keypad buttons. The majority of these actions are simply for entering/exiting and inputting simple multi-digit integers, as performed in lab 2, with the exception of the music controls on the music screen.

The menu screen contains 3 options. Pressing the 0 key on the keypad enters the settings screen, pressing the * key enters the music screen, and pressing the # key enters the graphs screen. From any other menu within the program, this main menu can be re-entered using the * key.

Source: SMART STATION