const uint16_t samples = 128;
double signalFrequency = 1000;
double samplingFrequency = 5000;
uint8_t amplitude = 100;

double vReal[samples];
double vImag[samples];

uint8_t mySensVals[samples];
float freq1;
float freq2;
float freq3;
uint8_t ampl1;
uint8_t ampl2;
uint8_t ampl3;
uint8_t i1;
uint8_t i2;
uint8_t i3;

for (uint8_t i = 0; i < samples; i++)

  {

    vReal[i] = analogRead(A0);

    delayMicroseconds(100);

    vImag[i] = 0;

  }

FFT.Windowing(vReal, samples, FFT_WIN_TYP_HAMMING, FFT_FORWARD);

  FFT.Compute(vReal, vImag, samples, FFT_FORWARD);

  FFT.ComplexToMagnitude(vReal, vImag, samples);

  PrintVector(vReal, (samples >> 1), SCL_FREQUENCY);

PrintVector(vImag, (samples >> 1), SCL_FREQUENCY);

i1 = 2;

  for (int k = 2;k < 64; k++){

    if(mySensVals[k]>mySensVals[i1]){

      i1 = k;

    }

  }

  i2 = 2;

  for (int k = 2;k < 64; k++){

    if((mySensVals[k]>mySensVals[i2]) && (k!=i1)){

      i2 = k;

    }

  }

  i3 = 2;

  for (int k = 2;k < 64; k++){

    if((mySensVals[k]>mySensVals[i3]) && (k!=i1) && (k!=i2)){

      i3 = k;

    }

  }

freq1 = scailing(i1);

freq2 = scailing(i2);

freq3 = scailing(i3);

tone(speaker_pin1, freq1);

tone(speaker_pin2, freq2);

tone(speaker_pin3, freq3);

void PrintVector(double *vData, uint8_t bufferSize, uint8_t scaleType)

{

  for (uint16_t i = 2; i < bufferSize; i++)

  {

    uint8_t val_temp = map(vData[i],0,1000,0,255);

    mySensVals[i] = val_temp;

    /*Serial.print(bufferSize);

    Serial.print(” “);*/

  }

}

float scailing(int i){

  float ans = 200 + (1000-200)/(50-12)*(i-12);

  return ans;

}

#include <FrequencyTimer2.h>

//도트 매트릭스 사용에 필요한 라이브러리를 가져옴.

//진동, 소음 센서의 경우 추가적인 라이브러리 불필요.

#define X  { \

    {1, 0, 0, 0, 0, 0, 0, 1}, \

    {0, 1, 0, 0, 0, 0, 1, 0}, \

    {0, 0, 1, 0, 0, 1, 0, 0}, \

    {0, 0, 0, 1, 1, 0, 0, 0}, \

    {0, 0, 0, 1, 1, 0, 0, 0}, \

    {0, 0, 1, 0, 0, 1, 0, 0}, \

    {0, 1, 0, 0, 0, 0, 1, 0}, \

    {1, 0, 0, 0, 0, 0, 0, 1}  \

} 

#define D { \

    {0, 0, 0, 0, 0, 0, 0, 0},\

    {0, 0, 0, 0, 0, 0, 0, 0},\

    {0, 0, 0, 0, 0, 0, 0, 0},\

    {0, 0, 0, 0, 0, 0, 0, 0},\

    {0, 0, 0, 0, 0, 0, 0, 0},\

    {0, 0, 0, 0, 0, 0, 0, 0},\

    {0, 0, 0, 0, 0, 0, 0, 0},\

    {0, 0, 0, 0, 0, 0, 0, 0},\

}

//도트 매트릭스로 비춰줄 X 모양 상태와 불빛이 모두 꺼져있는 상태를 1과 0으로 지정해줌.

int SOUND_SENSOR = A5;

int threshold = 25;

//소음 센서를 A5로 받고, 감도조절 threshold를 25로 설정, Sensor_Value로 소음센서 정의함.

int tact = A5;      

//택트 스위치 A5에 연결

byte col = 0;       

//COL을 0으로 초기화

byte leds[8][8];    

//현재 출력해야 할 LED 모양 업로드하는 배열함.

//맨 처음 PINS[0]은 사용하지 않기때문에 -1로 설정. 1~16번까지의 핀을 PIN에 연결함.

int pins[17]= {-1, 5, 4, 3, 2, 14, 15, 16, 17, 13, 12, 11, 10, 9, 8, 7, 6};

//행 0~7번까지 핀 연결해 주기

int cols[8] = {pins[13], pins[3], pins[4], pins[10], pins[6], pins[11], pins[15], pins[16]};

//열 0~ 7번까지 핀 연결해 주기

int rows[8] = {pins[9], pins[14], pins[8], pins[12], pins[1], pins[7], pins[2], pins[5]};

const int numPatterns = 2;      

//총 사용할 패턴 수를 지정하기.

byte patterns[numPatterns][8][8] = { X, D };   

//위에서 정의한 led 모양을 patterns에 입력해 주기

int pattern = 0;

pattern의 초기값을 0으로 지정.

int Sensor_value;

void clearLeds() { 

  for (int i = 0; i < 8; i++) 

    for (int j = 0; j < 8; j++) 

      leds[i][j] = 0;  }

//led를 다 초기화 시키는 clearLeds 정의.

void display() {

  digitalWrite(cols[col], HIGH);  

//이전 행들 다 꺼지게끔 해주기

  col++;

  if (col == 8) {

    col = 0;

  }

  for (int row = 0; row <= 7; row++) {

    if (leds[col][7 - row] == 1) {     // 위의 배열에서 1일때 해당되는 위치 불빛 켜주기

      digitalWrite(rows[row], HIGH);

    }

    else {                          // 위 배열에서 0일때 해당되는 위치 불빛 꺼줌.

      digitalWrite(rows[row], LOW);

    }

  }

  digitalWrite(cols[col], LOW);     

// 다음 패턴을 위해 led 다 꺼줌.

}

void setPattern(int pattern) {        // LED 배열에 PATTREN 입력하기

  for (int i = 0; i < 8; i++) 

    for (int j = 0; j < 8; j++) 

      leds[i][j] = patterns[pattern][i][j];  

}

void setup() {

// 1~16번 까지의 핀을 출력으로 설정

  for (int i = 1; i <= 16; i++) {

    pinMode(pins[i], OUTPUT);

  }

// 행 0~7번까지를 high로 

  for (int i = 0; i < 8; i++) {

    digitalWrite(cols[i], HIGH );

  }

// 열 0~7번 까지를 low로

  for (int i = 0; i < 8; i++) {

    digitalWrite(rows[i], HIGH);

  }

 clearLeds();   // led 초기화

FrequencyTimer2::setOnOverflow(display);  

//leds를 보여주기 위해서 setOnOverFlow를 사용

  pinMode(tact, INPUT); 

//SW 를 설정, 아두이노 풀업저항 사용

  setPattern(pattern); 

Serial.begin(9600); 

// 시리얼모니터 출력

  pinMode(SOUND_SENSOR, INPUT);  

-메인 loop 함수

void loop() { 

  int val; 

 val=analogRead(4);

 Serial.print(val,DEC);

delay(100);  

//진동 센서 값을 아날로그 4핀으로 받고 val 로 정의한 뒤 delay 100의 지연시간으로 진동 센서 값을 시리얼 모니터에 표시함.

Sensor_value = analogRead(A5);   

  Serial.println(Sensor_value);   

  delay(100);

//소음 센서 값을 아날로그 5핀으로 받고 Sensor_value로 정의한 뒤 delay 100의 지연시간으로 소음 센서 값을 시리얼 모니터에 표시함.

int readTact = digitalRead(tact);

  if((Sensor_value>=300) || (val>=300)){

 // 소음센서 또는 진동센서의 값이 300을 넘는 값을 가질 때

    if(readTact == LOW){     

// 택트 스위치가 low일때 

      if(pattern == 2) pattern = 0;   

//패턴의 끝까지 다 출력하고 다시 처음을 출력

      else pattern++;                

// 다음 패턴 출력을 위해 pattern ++

     delay(300);                 

// 길게 눌러 패턴이 순식간에 넘어가지 않기 위해서 딜레이를 줌

    }    

       setPattern(pattern);           

// 패턴 출력 

  }

  else  

 clearLeds();

  Sensor_value = analogRead(A5);

//아닐 경우 다시 처음으로 돌아가 측정을 시작.

  }

#include “arduinoFFT.h”
#define twoPi 6.28318531
#define fourPi 12.56637061
arduinoFFT::arduinoFFT(void)
{
/* Constructor */
}

arduinoFFT::~arduinoFFT(void)
{
/* Destructor */
}

uint8_t arduinoFFT::Revision(void)
{
return(FFT_LIB_REV);
}
void arduinoFFT::Compute(double *vReal, double *vImag, uint16_t samples, uint8_t dir)
{
Compute(vReal, vImag, samples, Exponent(samples), dir);
}

void arduinoFFT::Compute(double *vReal, double *vImag, uint16_t samples, uint8_t power, uint8_t dir)
{
/* Computes in-place complex-to-complex FFT */
/* Reverse bits */
uint16_t j = 0;
for (uint16_t i = 0; i < (samples – 1); i++) {
if (i < j) {
Swap(&vReal[i], &vReal[j]);
Swap(&vImag[i], &vImag[j]);
}
uint16_t k = (samples >> 1);
while (k <= j) {
j -= k;
k >>= 1;
}
j += k;
}
/* Compute the FFT */
double c1 = -1.0;
double c2 = 0.0;
uint8_t l2 = 1;
for (uint8_t l = 0; (l < power); l++) {
uint8_t l1 = l2;
l2 <<= 1;
double u1 = 1.0;
double u2 = 0.0;
for (j = 0; j < l1; j++) {
for (uint16_t i = j; i < samples; i += l2) {
uint16_t i1 = i + l1;
double t1 = u1 * vReal[i1] – u2 * vImag[i1];
double t2 = u1 * vImag[i1] + u2 * vReal[i1];
vReal[i1] = vReal[i] – t1;
vImag[i1] = vImag[i] – t2;
vReal[i] += t1;
vImag[i] += t2;
}
double z = ((u1 * c1) – (u2 * c2));
u2 = ((u1 * c2) + (u2 * c1));
u1 = z;
}
c2 = sqrt((1.0 – c1) / 2.0);
if (dir == FFT_FORWARD) {
c2 = -c2;
}
c1 = sqrt((1.0 + c1) / 2.0);
}
/* Scaling for reverse transform */
if (dir != FFT_FORWARD) {
for (uint16_t i = 0; i < samples; i++) {
vReal[i] /= samples;
vImag[i] /= samples;
}
}
}
void arduinoFFT::ComplexToMagnitude(double *vReal, double *vImag, uint16_t samples)
{
/* vM is half the size of vReal and vImag */
for (uint8_t i = 0; i < samples; i++) {
vReal[i] = sqrt(sq(vReal[i]) + sq(vImag[i]));
}
}

void arduinoFFT::Windowing(double *vData, uint16_t samples, uint8_t windowType, uint8_t dir)
{
/* Weighing factors are computed once before multiple use of FFT */
/* The weighing function is symetric; half the weighs are recorded */
double samplesMinusOne = (double(samples) – 1.0);
for (uint16_t i = 0; i < (samples >> 1); i++) {
double indexMinusOne = double(i);
double ratio = (indexMinusOne / samplesMinusOne);
double weighingFactor = 1.0;
/* Compute and record weighting factor */
switch (windowType) {
case FFT_WIN_TYP_RECTANGLE: /* rectangle (box car) */
weighingFactor = 1.0;
break;
case FFT_WIN_TYP_HAMMING: /* hamming */
weighingFactor = 0.54 – (0.46 * cos(twoPi * ratio));
break;
case FFT_WIN_TYP_HANN: /* hann */
weighingFactor = 0.54 * (1.0 – cos(twoPi * ratio));
break;
case FFT_WIN_TYP_TRIANGLE: /* triangle (Bartlett) */
weighingFactor = 1.0 – ((2.0 * abs(indexMinusOne – (samplesMinusOne / 2.0))) / samplesMinusOne);
break;
case FFT_WIN_TYP_BLACKMAN: /* blackmann */
weighingFactor = 0.42323 – (0.49755 * (cos(twoPi * ratio))) + (0.07922 * (cos(fourPi * ratio)));
break;
case FFT_WIN_TYP_FLT_TOP: /* flat top */
weighingFactor = 0.2810639 – (0.5208972 * cos(twoPi * ratio)) + (0.1980399 * cos(fourPi * ratio));
break;
case FFT_WIN_TYP_WELCH: /* welch */
weighingFactor = 1.0 – sq((indexMinusOne – samplesMinusOne / 2.0) / (samplesMinusOne / 2.0));
break;
}
if (dir == FFT_FORWARD) {
vData[i] *= weighingFactor;
vData[samples - (i + 1)] *= weighingFactor;
}
else {
vData[i] /= weighingFactor;
vData[samples - (i + 1)] /= weighingFactor;
}
}
}

double arduinoFFT::MajorPeak(double *vD, uint16_t samples, double samplingFrequency)
{
double maxY = 0;
uint16_t IndexOfMaxY = 0;
for (uint16_t i = 1; i < ((samples >> 1) – 1); i++) {
if ((vD[i-1] < vD[i]) && (vD[i] > vD[i+1])) {
if (vD[i] > maxY) {
maxY = vD[i];
IndexOfMaxY = i;
}
}
}
double delta = 0.5 * ((vD[IndexOfMaxY-1] – vD[IndexOfMaxY+1]) / (vD[IndexOfMaxY-1] – (2.0 * vD[IndexOfMaxY]) + vD[IndexOfMaxY+1]));
double interpolatedX = ((IndexOfMaxY + delta) * samplingFrequency) / (samples-1);
/* retuned value: interpolated frequency peak apex */
return(interpolatedX);
}

/* Private functions */

void arduinoFFT::Swap(double *x, double *y)
{
double temp = *x;
*x = *y;
*y = temp;
}

uint8_t arduinoFFT::Exponent(uint16_t value)
{
/* Computes the Exponent of a powered 2 value */
uint8_t result = 0;
while (((value >> result) & 1) != 1) result++;
return(result);
}