Work Distribution

Project group picture

Code Appendix

# By Amy Wang (yw575) and Nick George (nkg37)
# ECE 5725 Final Project: Visual FFT
# FFT_screen_class.py :calculates FFT and send the data to the Arduino Uno

import serial
from time import sleep
import numpy as np
from LED_control import LED
import RPi.GPIO as GPIO
from threading import Thread

#class to manage all of the project
class FFT_Screen(Thread):
    def __init__(self, middle=0):
        #run needed threading components
        super(FFT_Screen, self).__init__()
        #control whether middle mode on or not
        self.middle = middle
        #number of FFT points coming in 
        self.FFT_size = 64
        #setting up the serial port to be used
        self.ser = serial.Serial('/dev/ttyUSB0', 115200);
        #make class to control the LED display
        self.screen = LED(bar_data_length=32, middle_mode=self.middle)
        #start sending data to the arduino
        self.screen.start()
        #to control the display mode
        self.display_mode = 0 #0 = 3 max mode 1 = 1 max mode
        #if true all diaplyed bars have the be greater than 2
        self.filtering = True
        #number of maximums to highlight
        self.num_maxes = 3
        #gpio related stuff
        GPIO.cleanup()
        GPIO.setmode(GPIO.BCM)
        GPIO.setup(26, GPIO.IN, pull_up_down=GPIO.PUD_UP)
        GPIO.setup(19, GPIO.IN, pull_up_down=GPIO.PUD_UP)

    def run(self):
        while True:
            #button Stuff
            if not GPIO.input(26):
                print("pressed")
                self.display_mode = 1-self.display_mode
                sleep(0.5)
            if not GPIO.input(19):
                self.screen.middle_mode = 1-self.screen.middle_mode
                sleep(0.5)
            #FFT stuff
            #decode the Data coming in from the Pico
            values = self.ser.readline().decode('ascii')
            #remove the first element from the data it does not contai anything
            values = values.split(",")[1:-1]
            #remove blanks form the data
            values = [int(i) for i in values if i != ""]
            #run the FFT
            yf = np.fft.fft(values)
            #only run if 64 data points sent
            N = len(values)
            if(N == self.FFT_size):
                #division by 2 due to FFT shift. Only use half of the values since only half are positive frequencies
                yff = (1.0/N * np.abs(yf[:N//2]))
                #filter off anything under 2 in height
                if self.filtering == True:
                    yff = np.array([i if i>2 else 0 for i in list(yff)])
                #Single maximum display mode
                if self.display_mode == 1:
                    #get the position of the highest value frequency
                    index = yff[1:].argmax()
                    #convert back to a list
                    yff = list(yff)
                    #make the maximum frequency bar blue, make the rest red
                    for i in range(self.FFT_size//2):
                        if i==index+1:
                            self.screen.column_color[i] = 2
                        else:
                            self.screen.column_color[i] = 0
                        self.screen.column_height[i] = int(yff[i])
                #3 Maximum mode where the highest 3 frequencies are highlighted
                elif self.display_mode == 0:
                    #make all of the bars red
                    for i in range(self.FFT_size//2):
                        self.screen.column_height[i] = int(yff[i])
                        self.screen.column_color[i] = 0
                    find_max = yff[1:]
                    #make the 3 highest red blue and green (high to low)
                    for i in range(self.num_maxes):
                        index = find_max.argmax()
                        self.screen.column_color[index+1] = i+1
                        find_max[index] = -1
                #quit if any other mode is given
                else:
                    quit()


if __name__ == "__main__":
    #run the project
    project = FFT_Screen()
    project.start()
    
              

# By Amy Wang (yw575) and Nick George (nkg37)
# ECE 5725 Final Project: Visual FFT
# LED_controls.py :controls how data is displayed on the LED screen

from threading import Thread
import serial
from time import sleep

"""
    This class exists to deal with all of the communicatiom between the PI and the Arduino to display
    each of the frequency bars. It is designed to run a thread to constantly send data to the raspberry pi
    while each bar and color can be controlled through different arrays
""" 
class LED(Thread):
    def __init__(self, bar_data_length=15, middle_mode = 1):
        #run all things related the Threading parent class
        super(LED, self).__init__()
        #Number of data points sent
        self.bar_data_length=bar_data_length
        #array describing the bar Height
        self.column_height = [0]*self.bar_data_length
        #array describing the color of each bar. 0 = red, 1 = white, 2 = blue, 3 = green
        self.column_color = [0]*self.bar_data_length
        #used to turn on or off middle mode where the frequencies spread out from the center of the LED screen
        self.middle_mode = middle_mode
        #delay of sending the data
        self.sending_delay = 0.1
        #connect to serial port
        self.ser = serial.Serial('/dev/ttyACM0', 115200);
    
    #function to send the data to the arduino
    def send(self):
        #make the message packet. The first data point is whether to use middle mode or not
        message = [self.middle_mode]
        #Pack the message with the height and color of each column
        for i in range(self.bar_data_length):
            """
            The code here was used in order to shorten how many numbers we had to send. There are 32 bars with 32 different colors. Thats
            is 64 different numbers to send. In order to compress that into 32 number bit shifting was used. Each serial transimssion is 
            1 byte or 8 bits. The first 4 bits are the color of the bar and the last 4 bytes are the height. Bit shifting was used to acomplish
            this 
            """
            compressed = min(self.column_height[i],15)|(self.column_color[i]<<4)
            message.append(compressed)
        self.ser.write(message)
    
    #function which runs in the thread sending the data over and over again.
    def run(self):
        while True:
            self.send()
            sleep(self.sending_delay)

/**
 * ECE5725_PROJECT: VISUAL FFT by Amy Wang (yw575) and Nick George (nkg37)
 * adc.c
 *
 * Code took inspiration from:
 * Hunter Adams (vha3@cornell.edu)
 * 
 * Core 0 collects audio samples and does ADC. Core 1 blinks the LED (to make sure the Pico is working).
 *
 * HARDWARE CONNECTIONS
 *  - GPIO 26 ---> Audio input [0-3.3V]
 *
 * RESOURCES USED
 *  - ADC channel 0
 *
 */

// Include standard libraries
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
// Include Pico libraries
#include "pico/stdlib.h"
#include "pico/multicore.h"
// Include hardware libraries
#include "hardware/pio.h"
#include "hardware/dma.h"
#include "hardware/adc.h"
#include "hardware/irq.h"
// Include protothreads
#include "pt_cornell_rp2040_v1.h"

// Define the LED pin
#define LED     25

// === the fixed point macros (16.15) ========================================
typedef signed int fix15 ;
#define multfix15(a,b) ((fix15)((((signed long long)(a))*((signed long long)(b)))>>15))
#define float2fix15(a) ((fix15)((a)*32768.0)) // 2^15
#define fix2float15(a) ((float)(a)/32768.0)
#define absfix15(a) abs(a) 
#define int2fix15(a) ((fix15)(a << 15))
#define fix2int15(a) ((int)(a >> 15))
#define char2fix15(a) (fix15)(((fix15)(a)) << 15)

/////////////////////////// ADC configuration ////////////////////////////////
// ADC Channel and pin
#define ADC_CHAN 0
#define ADC_PIN 26
// Number of samples
#define NUM_SAMPLES 64
// Sample rate (Hz)
#define Fs 10000.0
// ADC clock rate (unmutable!)
#define ADCCLK 48000000.0

// DMA channels for sampling ADC
int sample_chan = 2 ;
int control_chan = 3 ;

// Max and min macros
#define max(a,b) ((a>b)?a:b)
#define min(a,b) ((a<b)?a:b)

// Here's where we'll have the DMA channel put ADC samples
uint8_t sample_array[NUM_SAMPLES] ;

// int array for audio samples
int fr_int[NUM_SAMPLES] ;

//variables used to convert audio samples to a char array
char *str;
char *str2;
char *c;

// Pointer to address of start of sample buffer
uint8_t * sample_address_pointer = &sample_array[0] ;

// Runs on core 0
static PT_THREAD (protothread_fft(struct pt *pt))
{
    // Indicate beginning of thread
    PT_BEGIN(pt) ;
    // Start the ADC channel
    dma_start_channel_mask((1u << sample_chan)) ;
    // Start the ADC
    adc_run(true) ;

    //static variable: incrementing loop variable
    static int i ;                  


    char *str;
    str = "\n";
    //allocate memory for the char arrays
    char *str2 = malloc(64*NUM_SAMPLES*sizeof(char));
    char *c = malloc(4*sizeof(char)); 

    while(1) {
        // Wait for NUM_SAMPLES samples to be gathered
        // Measure wait time with timer. THIS IS BLOCKING
        dma_channel_wait_for_finish_blocking(sample_chan);

        //copy in audio samples
        for (i=0; i<NUM_SAMPLES; i++) {
            fr_int[i]=((int)sample_array[i]);
        }

        //initialize a 0 as the first char in the array
        str = "0,";
        //copy str to str2
        strcpy(str2, str);

        //convert the integer audio samples array into a char array
        for (int i=0; i<NUM_SAMPLES+1; i++) {
            c = malloc(4*sizeof(char));

            if(i == NUM_SAMPLES){
                sprintf(c, "\n", fr_int[i]);
            }else{
                sprintf(c, "%d,", fr_int[i]);
            }

            strcat(str2, c);
            free(c);
        }

        //write the char array to uart to be sent to the Pi THIS IS BLOCKING
        uart_puts(uart0, str2);

        // Restart the sample channel, now that we have our copy of the samples
        dma_channel_start(control_chan);
    }
    PT_END(pt) ;
}

static PT_THREAD (protothread_blink(struct pt *pt))
{
    // Indicate beginning of thread
    PT_BEGIN(pt) ;
    while (1) {
        // Toggle LED, then wait half a second
        gpio_put(LED, !gpio_get(LED)) ;
        PT_YIELD_usec(500000) ;
    }
    PT_END(pt) ;
}

// Core 1 entry point (main() for core 1)
void core1_entry() {
    // Add and schedule threads
    pt_add_thread(protothread_blink) ;
    pt_schedule_start ;
}

// Core 0 entry point
int main() {
    // Initialise UART 0
    uart_init(uart0, 115200);
 
    // Set the GPIO pin mux to the UART - 0 is TX, 1 is RX
    gpio_set_function(0, GPIO_FUNC_UART);
    gpio_set_function(1, GPIO_FUNC_UART);
 
    // Initialize stdio
    stdio_init_all();

    // Map LED to GPIO port, make it low
    gpio_init(LED) ;
    gpio_set_dir(LED, GPIO_OUT) ;
    gpio_put(LED, 0) ;

    ///////////////////////////////////////////////////////////////////////////////
    // ============================== ADC CONFIGURATION ==========================
    //////////////////////////////////////////////////////////////////////////////
    // Init GPIO for analogue use: hi-Z, no pulls, disable digital input buffer.
    adc_gpio_init(ADC_PIN);

    // Initialize the ADC harware
    // (resets it, enables the clock, spins until the hardware is ready)
    adc_init() ;

    // Select analog mux input (0...3 are GPIO 26, 27, 28, 29; 4 is temp sensor)
    adc_select_input(ADC_CHAN) ;

    // Setup the FIFO
    adc_fifo_setup(
        true,    // Write each completed conversion to the sample FIFO
        true,    // Enable DMA data request (DREQ)
        1,       // DREQ (and IRQ) asserted when at least 1 sample present
        false,   // We won't see the ERR bit because of 8 bit reads; disable.
        true     // Shift each sample to 8 bits when pushing to FIFO
    );

    // Divisor of 0 -> full speed. Free-running capture with the divider is
    // equivalent to pressing the ADC_CS_START_ONCE button once per `div + 1`
    // cycles (div not necessarily an integer). Each conversion takes 96
    // cycles, so in general you want a divider of 0 (hold down the button
    // continuously) or > 95 (take samples less frequently than 96 cycle
    // intervals). This is all timed by the 48 MHz ADC clock. This is setup
    // to grab a sample at 10kHz (48Mhz/10kHz - 1)
    adc_set_clkdiv(ADCCLK/Fs);

    /////////////////////////////////////////////////////////////////////////////////
    // ============================== ADC DMA CONFIGURATION =========================
    /////////////////////////////////////////////////////////////////////////////////

    // Channel configurations
    dma_channel_config c2 = dma_channel_get_default_config(sample_chan);
    dma_channel_config c3 = dma_channel_get_default_config(control_chan);


    // ADC SAMPLE CHANNEL
    // Reading from constant address, writing to incrementing byte addresses
    channel_config_set_transfer_data_size(&c2, DMA_SIZE_8);
    channel_config_set_read_increment(&c2, false);
    channel_config_set_write_increment(&c2, true);
    // Pace transfers based on availability of ADC samples
    channel_config_set_dreq(&c2, DREQ_ADC);
    // Configure the channel
    dma_channel_configure(sample_chan,
        &c2,            // channel config
        sample_array,   // dst
        &adc_hw->fifo,  // src
        NUM_SAMPLES,    // transfer count
        false            // don't start immediately
    );

    // CONTROL CHANNEL
    channel_config_set_transfer_data_size(&c3, DMA_SIZE_32);      // 32-bit txfers
    channel_config_set_read_increment(&c3, false);                // no read incrementing
    channel_config_set_write_increment(&c3, false);               // no write incrementing
    channel_config_set_chain_to(&c3, sample_chan);                // chain to sample chan

    dma_channel_configure(
        control_chan,                         // Channel to be configured
        &c3,                                // The configuration we just created
        &dma_hw->ch[sample_chan].write_addr,  // Write address (channel 0 read address)
        &sample_address_pointer,                   // Read address (POINTER TO AN ADDRESS)
        1,                                  // Number of transfers, in this case each is 4 byte
        false                               // Don't start immediately.
    );

    // Launch core 1
    multicore_launch_core1(core1_entry);
    
    pt_add_thread(protothread_fft) ;
    pt_schedule_start ;

}

// By Amy Wang (yw575) and Nick George (nkg37)
// ECE 5725 Final Project: Visual FFT
// raspi-led-control.ino: Arduino Uno controls LED screen

#include <RGBmatrixPanel.h>

#define CLK  8   // USE THIS ON ARDUINO UNO, ADAFRUIT METRO M0, etc.
//#define CLK A4 // USE THIS ON METRO M4 (not M0)
//#define CLK 11 // USE THIS ON ARDUINO MEGA
#define OE   9
#define LAT 10
#define A   A0
#define B   A1
#define C   A2

//parameters defining the data comming in 
#define horizontal_length 32
#define num_bars 32
#define num_parameters 2
#define overhead_length 1 // one extra byte for whether to use middle mode or not

//class object to control the LED screen
RGBmatrixPanel matrix(A, B, C, CLK, LAT, OE, false);

//constants for the size of the whole message
#define size_message num_bars+overhead_length
#define data_size num_bars*num_parameters

//Variabe to store all of the bar data, color and height
uint16_t line[num_bars][num_parameters];

//Variables to control middle mode or not
int middle_mode = 1;
int middle_height = 0;

//buffer for data
byte buf[size_message];
int line_index = 0;

//common colors
uint16_t red;
uint16_t white;
uint16_t blue;
uint16_t green;
uint16_t color_list[4];

void setup() {
  //Setup the serial module
  Serial.begin(115200);
  matrix.begin();
  //get the values for all the colors
  red = matrix.Color333(1, 0, 0);
  white = matrix.Color333(1, 1, 1);
  blue = matrix.Color333(0, 0, 1);
  green =  matrix.Color333(0,1,0);

  //Initialize all of the bars
  color_list[0] = red;
  color_list[1] = white;
  color_list[2] = blue;
  color_list[3] = green;
}
                                                                                          
void loop() {
  while(Serial.available()>0){
    //Read in the serial data
    Serial.readBytes(buf ,size_message);
    //capture the middle mode byte
    middle_mode = buf[0];
    //extract the column data for each frequency bin
    for(int index=0; index<num_bars; index+=1){
      line[index][0]= (int)(buf[index+1]&0b1111) >= 15 ? 15 : buf[index+1]&0b1111;
      int color = (buf[index+1]>>4);
      line[index][1]= color_list[color];
    }
  }
 
  matrix.fillScreen(matrix.Color333(0, 0, 0));
  //draw all of the lines 
  for(int i=0; i<num_bars; i++){
    //put them starting from the center if its in middle mode
    if(!middle_mode){
      matrix.drawLine(horizontal_length-1-i, 0, horizontal_length-1-i, line[i][0], line[i][1]);
    }
    //run in normal mode
    else{
      middle_height = line[i][0]/2;
      matrix.drawLine(horizontal_length-1-i, (7-middle_height), horizontal_length-1-i, (7+middle_height), line[i][1]);
    }
  }
  //do some delaay before reading serial data again
  delay(20);
}