作者 主题:制作一个声音相机 (Read 6599 times)

0会员和1位客人正在查看此主题。

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
制作一个声音相机
« on: 2018年4月30日,晚上11:27:42»
你好,
不'很高兴看到声音,如此吗?
这样做的常用方式是使用每个麦克风的FFT拉动FFT并计算一些相位的δ。
是否有可能在不诉诸编程的情况下这样做,甚至可能使用模拟组件?

换句话说:
m-m-m
|   |   |
m-m-m
|   |   |
m-m-m
对于每个M,确定具有最高幅度的频率的相位偏移
为每个M的PCB另一侧点亮LED(如果它)'S正,这意味着声音在邻居麦克风领先地位)*幅度

编辑:改变了标题,因为我们'仍然弄清楚如何制作这件事。
« 上次编辑:2018年5月01日,第11:04:31由Daslolo »
九九九
 

 离线 发光机

  • 常规贡献者
  • *
  • 帖子:56
  • 国家:  茹
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#1开: 2018年4月30日,晚上11:44:34»
这个问题的最愚蠢的解决方案是:
如果您有频率W和带有相同频率PHI的延迟SINEWAVE的SINEWAVE,则将它们乘以:
COS(W * t)* cos(w * t + phi)= 0.5 * cos(2 * w * t + phi)+ 0.5 * cos(phi)
然后,您可以将低通滤波器耗尽,以摆脱高频部分,低频部分仅取决于SineWaves的相位差  :-+.
现在这里出现问题,对于不同的频率相同的相移意味着不同的距离行驶:Delta-Phi = 2 * pi *距离/波长,因此您必须有一些方法来区分不同的频率。真的这件事只是要求DSP和FFT。  :)
« 上次编辑:2018年4月30日,PM Sparker晚上11:55:13 »
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#2开: 2018年5月01日,01:17:49»
我喜欢你的解决方案,它唱歌。
I'D真的很想不要使用我必须编程的芯片,所以也许每个麦克风都经过一下,在进入自己的相位检测器之前几乎没有重叠的滤波器。
M-F(n)-phd(n)            \
   -F(n+1)-PHD(n+1)    - 结合形成RGB - LED
   -F(n+2)-PHD(n+2)   /
    ....
九九九
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#3开: 2018年5月01日,01:22:35»
m-m-m
对于每个M,确定具有最高幅度的频率的相位偏移
问题是,每个m都有它'S自己最高的幅度频率。 FFT是唯一的解决方案,不一定是FPGA - STM32等小型UCPU板,SAM3X或ATMEGA328就足够了
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#4开: 2018年5月01日,01:33:51»
m-m-m
对于每个M,确定具有最高幅度的频率的相位偏移
问题是,每个m都有它'S自己最高的幅度频率。 FFT是唯一的解决方案,不一定是FPGA - STM32等小型UCPU板,SAM3X或ATMEGA328就足够了
在我的ESP32 ADC转换的经验中需要时间,在规范表上的1US,如果通过Arduino lib访问(1k样本需要10 ms !!!),我认为(避风港'T弄清楚如何测试),如果我ADC一个引脚,那么另一个引脚,另一个将在第一个引脚上进行采样1US,因此通过采样会导致已经相移。
现在我可能错了,也许有一种方法可以同时冻结所有ADC桶。
九九九
 

 离线 发光机

  • 常规贡献者
  • *
  • 帖子:56
  • 国家:  茹
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#5: 2018年5月01日,01:46:35»
您可能需要n个ADC或ADC,可以从许多通道中同时采样,然后在串行中给您提供数据。它们必须同时计时,但是当转换结束时,您可以在下一次转换开始之前使用任何方法来读取数据。也许他们的串行接口可以串行连接?也许它们具有并行接口,您可以并行连接到MCU的读取端口,并使用芯片选择特定的ADC来读取数据。  :-// 这么多的可能性和多种ADC。
如果您只关心0 ... 10 kHz频段,您可以在大约20 kHz上进行样品,其中50个样本之间的美国。可能AVR可以轻松处理此数据速率。
只需将此数据存储到缓冲区,尽可能多的样本,然后您可以使用它。一世'd将其卸载到Matlab / Octave,并尝试首先处理它。
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#6开启: 2018年5月01日,02:02:19»
如果我ADC一个引脚,那么另一个引脚,另一个引脚将在第一个引起的1US上进行采样,因此通过采样引起的已经相移。
现在我可能错了,也许有一种方法可以同时冻结所有ADC桶。
You don'T需要抽样 同步。当然,有一个ADC会有阶段偏移,但它'S常数通过采样率定义。 只要减去相位差。
 
以下用户感谢此帖子: 发光机 , 韦德利斯

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#7: 2018年5月01日,02:10:14 AM»
如果我ADC一个引脚,那么另一个引脚,另一个引脚将在第一个引起的1US上进行采样,因此通过采样引起的已经相移。
现在我可能错了,也许有一种方法可以同时冻结所有ADC桶。
You don'T需要抽样 同步。当然,有一个ADC会有阶段偏移,但它'S常数通过采样率定义。 只要减去相位差。
这是我在我开车去买巧克力! :D
如何评估阶段班次?
九九九
 

 离线 发光机

  • 常规贡献者
  • *
  • 帖子:56
  • 国家:  茹
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#8开: 2018年5月01日,02:23:37»
确实是你不'T需要同步样品。 :palm: 显然必须是周期性的抽样。
相移检查"Shift in time" DFT property: //en.wikipedia.org/wiki/Discrete-time_Fourier_transform
所以在DFT输出时'LL与频率箱的阶段成比例地增加到当前箱的频率,并按比例转换。
« 上次编辑:2018年5月01日,02:29:44 AM Sparker »
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#9: 2018年5月01日,02:41:38»
是假想组件的FFT的阶段吗?
可以使用N麦克风,输出PWM而不是模拟有助于提升UC的一些负载吗?
九九九
 

 离线 发光机

  • 常规贡献者
  • *
  • 帖子:56
  • 国家:  茹
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#10: 2018年5月01日,03:14:22»
否,相位是向量和真实轴之间的角度,如在复幅或复杂阻抗中使用的相位。

引用
可以使用N麦克风,输出PWM而不是模拟有助于提升UC的一些负载吗?
什么 do you mean?

我也没有'T了解NI工作的整个信号处理方式。也许有人可以解释? :)
 

 在线的 哈姆斯特_NZ.

  • 超级贡献者
  • ***
  • 帖子:2397
  • 国家:  NZ.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#11开: 2018年5月01日,07:22:28»
你确定你在说阶段三角洲吗?这对于不同的频率会有所不同....

大学教师'你只想要延迟,这对于所有频率都是常量的? (每米左右的距离〜3 ms)

还是我困惑? (我经常是)


凝视不进入深渊,以免让你被认为是深渊领域专家,他们期望你继续凝视该死的事情。
 
以下用户感谢此帖子: 灵魂曼

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#12: 2018年5月01日,07:45:10»
你确定你在说阶段三角洲吗?这对于不同的频率会有所不同....

大学教师'你只想要延迟,这对于所有频率都是常量的? (每米左右的距离〜3 ms)

还是我困惑? (我经常是)

阶段听起来很酷,但也许你是对的。
最终目标是在麦克风上显示一个blob,在阵列上首先被声音击中。
九九九
 

 在线的 哈姆斯特_NZ.

  • 超级贡献者
  • ***
  • 帖子:2397
  • 国家:  NZ.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#13开启: 2018年5月01日,08:44:29»
哼。第一猜。

寻找令人靠近的声音(例如 一个中心频道的突然响度)。

窗口它(逐渐消退),所以你得到你正在寻找的模式。使窗口小于FFT尺寸(例如FFT大小的一半)。

FFT它,所以你得到了你正在寻找的复杂频谱签名。

拿所有渠道。 FFT它们为每个通道获得频率展示。

通过签名乘以乘以's spectrum.

逆FFT每个得到的光谱。这将为您提供一个时间序列,信号匹配签名模式的匹配程度。你应该在每个频道(也许回声)中有尖峰。

识别每个频道中的主要尖峰。使用相对延迟来三角形源。

(我使用这种技术来查找直接合成扩频信号一次)

凝视不进入深渊,以免让你被认为是深渊领域专家,他们期望你继续凝视该死的事情。
 

 离线 发光机

  • 常规贡献者
  • *
  • 帖子:56
  • 国家:  茹
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#14: 2018年5月1日,晚上12:58:10»
我猜这是因为我们想测量频道之间的时间延迟, 交叉相关 功能适合更多的需求。
想象一下,你有两个麦克风,都击中了相同的信号,延迟未知。您录制信号并交叉相关。互相关函数输出处的峰值将在等于时间偏移的时间  :-+.
现在添加第二维正交到第一个 一个并乘以彼此的两个互相关函数输出(但是一个是水平的,另一个是垂直),并且您将具有峰值朝向声源旋转的2D图像。通过它虽然一些2D过滤器(如高斯平滑过滤器),但我想,您应该将与视频中的家伙相同的结果。   ::)
大概三个麦克风将足够,在中间,另一个x厘米以上,第三个x厘米。  :-/O
« 最后编辑:2018年5月1日,2018年12:59:55 PM Sparker »
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#15: 2018年5月01日,06:18:08 PM»
@sparker和@hamster_nz你'两个都用你自己的话来描述同样的事情。目前我不知道这看起来像fft是钥匙。好事是我不'在显示频率的任期内需要太多的视觉分辨率,因此必须足够了一个128箱FFT。这是ESP32上的3ms非常快。

我早些时候在考虑使用i2s mems来绕过ADC转换时间......它似乎是一个好主意,但转移I2S流的时间需要多长时间?我认为它'LL需要长时间读取,它等同于将时间延迟移动到数据传输。也许有人可以确认?
九九九
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#16开: 2018年5月1日,07:10:31 PM»
大学教师'T关于ESP32,但由于任何数字总线I2C追踪时间由时钟速率*比特数定义。 I2C标准AFAIK支持100K,400K和3.4M时钟。看看你的esp32的时钟是什么 司机。为自己,我通常 使用任何备用数字引脚和范围测量Arduino速度性能,在开始时和时间关键函数的起始末端设置高/低。
Millis()也在软件中做同样的事情。
关于FFT的尺寸,取决于较低的频率范围&带宽。例如,10 k采样和128个箱只提供10000/128 = 78.125 Hz频率。解析度。这意味着,你可以't尺寸低于此值,更重要,错误误差为78 Hz,10%左右(不确定是否'S线性,但你得到一个想法,并在780 Hz处做数学工作来验证),这可能是不可接受的。

交叉相关与DFT相同。实用价值很少或零,因为FFT速度速度速度大约成千上万。 
 

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#17开: 5月01日,2018年,08:05:35 PM»
是否有可能在不诉诸编程的情况下这样做,甚至可能使用模拟组件?
如果您限制了信号的频率,然后剪辑它们,则可以执行相位检测器A 4046 ...只要延迟小于它可以确定延迟的最高频率的逆。虽然只能用一个小锥体工作。做得不仅仅是迅速变得非常艰难的行为。
 

 离线 奥格登

  • 超级贡献者
  • ***
  • 帖子:3416
  • 国家:  Lv.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#18开启: 2018年5月1日,08:37:48 PM»
大学教师'T关于ESP32,但由于任何数字总线I2C追踪时间由时钟速率*比特数定义。 I2C标准AFAIK支持100K,400K和3.4M时钟。

我担心你将I2S与I2C困惑,这是完全不同的动物:

我早些时候在考虑使用i2s mems来绕过ADC转换时间......它似乎是一个好主意,但转移I2S流的时间需要多长时间?

任何ADC都会延迟信号一段时间,因此无关紧要 - 它是I2S ADC与否。 MEMS麦克风的I2S确实很好。
« 上次编辑:2018年5月1日,08:53:04由Ogden »
 

 离线 奥格登

  • 超级贡献者
  • ***
  • 帖子:3416
  • 国家:  Lv.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#19: 2018年5月01日,08:49:23 PM»
是否有可能在不诉诸编程的情况下这样做,甚至可能使用模拟组件?
如果您限制了信号的频率,然后剪辑它们,则可以执行相位检测器A 4046 ...只要延迟小于它可以确定延迟的最高频率的逆。虽然只能用一个小锥体工作。做得不仅仅是迅速变得非常艰难的行为。

这种剪辑方法仅在文本书示例中工作,用于清洁正弦音的单个信号源,而不是来自各种复杂声音来自多个来源的真实世界应用程序。此应用程序确实需要DSP处理,从而进行编程。
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#20开: 2018年5月1日,09:22:52 PM»
大学教师'T关于ESP32,但由于任何数字总线I2C追踪时间由时钟速率*比特数定义。 I2C标准AFAIK支持100K,400K和3.4M时钟。

我担心你将I2S与I2C困惑,这是完全不同的动物:
ooops,mea culpa,误读。  Didn't知道esp32可以支持I2S。我界面的互相界面 WM8731超过I2S / DMA,但它's仅为1编解码器 - 2个通道/输出。 虽然将I2S带入图片会使项目更难构建/程序。
这是一段代码,概述复杂性:
代码: [选择]
void DMAC_Handler(void)
{
  uint32_t dma_status;

//  digitalWrite( test_pin, HIGH);
  dma_status = DMAC->DMAC_EBCISR;
  // BUG : ISR = if (dma_status & (DMAC_EBCIER_CBTC0 << SSC_DMAC_RX_CH))
  if (dma_status & (DMAC_EBCISR_BTC0 << SSC_DMAC_RX_CH)) {
    flag_adcv = 1;
    }

  if (dma_status & (DMAC_EBCISR_BTC0 << SSC_DMAC_TX_CH)) {
    flag_dacv = 1;
    }
  if(flag_adcv && (!flag_dacv))  adcdac_first = 1; 
  if((!flag_adcv) && flag_dacv)  adcdac_first = 2; 
//  digitalWrite( test_pin,  LOW);
}

void ssc_dma_cfg()
{
  desc[0].ul_source_addr      = (uint32_t)(&SSC->SSC_RHR);
  desc[0].ul_destination_addr = (uint32_t) inp[0];
  desc[0].ul_ctrlA = DMAC_CTRLA_BTSIZE(INP_BUFF) |/* Set Buffer Transfer Size */
                     DMAC_CTRLA_SRC_WIDTH_WORD |  /* Source transfer size is set to 32-bit width */
                     DMAC_CTRLA_DST_WIDTH_WORD;   /* Destination transfer size is set to 32-bit width */

  desc[0].ul_ctrlB = DMAC_CTRLB_SRC_DSCR_FETCH_DISABLE |
                     DMAC_CTRLB_DST_DSCR_FETCH_FROM_MEM |           
                     DMAC_CTRLB_FC_PER2MEM_DMA_FC |                 
                     DMAC_CTRLB_SRC_INCR_FIXED |             
                     DMAC_CTRLB_DST_INCR_INCREMENTING;       
  desc[0].ul_descriptor_addr = (uint32_t) &desc[1];

  desc[1].ul_source_addr      = (uint32_t)(&SSC->SSC_RHR);
  desc[1].ul_destination_addr = (uint32_t) inp[1];
  desc[1].ul_ctrlA = DMAC_CTRLA_BTSIZE(INP_BUFF) |   
                     DMAC_CTRLA_SRC_WIDTH_WORD |                 
                     DMAC_CTRLA_DST_WIDTH_WORD;                   

  desc[1].ul_ctrlB = DMAC_CTRLB_SRC_DSCR_FETCH_DISABLE |
                     DMAC_CTRLB_DST_DSCR_FETCH_FROM_MEM |           
                     DMAC_CTRLB_FC_PER2MEM_DMA_FC |                 
                     DMAC_CTRLB_SRC_INCR_FIXED |             
                     DMAC_CTRLB_DST_INCR_INCREMENTING;           
  desc[1].ul_descriptor_addr = (uint32_t) &desc[0];       
 
  DMAC->DMAC_CH_NUM[SSC_DMAC_RX_CH].DMAC_SADDR = desc[0].ul_source_addr;
  DMAC->DMAC_CH_NUM[SSC_DMAC_RX_CH].DMAC_DADDR = desc[0].ul_destination_addr;
  DMAC->DMAC_CH_NUM[SSC_DMAC_RX_CH].DMAC_CTRLA = desc[0].ul_ctrlA;
  DMAC->DMAC_CH_NUM[SSC_DMAC_RX_CH].DMAC_CTRLB = desc[0].ul_ctrlB;
  DMAC->DMAC_CH_NUM[SSC_DMAC_RX_CH].DMAC_DSCR  = desc[0].ul_descriptor_addr;

  DMAC->DMAC_CHER = DMAC_CHER_ENA0 << SSC_DMAC_RX_CH;
  ssc_enable_rx(SSC);

// transmit
  desc[2].ul_source_addr      = (uint32_t) out[0];
  desc[2].ul_destination_addr = (uint32_t) (&SSC->SSC_THR);
  desc[2].ul_ctrlA = DMAC_CTRLA_BTSIZE(INP_BUFF) |
                     DMAC_CTRLA_SRC_WIDTH_WORD | 
                     DMAC_CTRLA_DST_WIDTH_WORD;   

  desc[2].ul_ctrlB = DMAC_CTRLB_SRC_DSCR_FETCH_FROM_MEM |
                     DMAC_CTRLB_DST_DSCR_FETCH_DISABLE |       
                     DMAC_CTRLB_FC_MEM2PER_DMA_FC |                 
                     DMAC_CTRLB_SRC_INCR_INCREMENTING |             
                     DMAC_CTRLB_DST_INCR_FIXED;                       
  desc[2].ul_descriptor_addr = (uint32_t) &desc[3];       

  desc[3].ul_source_addr      = (uint32_t) out[1];
  desc[3].ul_destination_addr = (uint32_t) (&SSC->SSC_THR);
  desc[3].ul_ctrlA = DMAC_CTRLA_BTSIZE(INP_BUFF) |
                     DMAC_CTRLA_SRC_WIDTH_WORD |               
                     DMAC_CTRLA_DST_WIDTH_WORD;               

  desc[3].ul_ctrlB = DMAC_CTRLB_SRC_DSCR_FETCH_FROM_MEM |
                     DMAC_CTRLB_DST_DSCR_FETCH_DISABLE |       
                     DMAC_CTRLB_FC_MEM2PER_DMA_FC |                 
                     DMAC_CTRLB_SRC_INCR_INCREMENTING |             
                     DMAC_CTRLB_DST_INCR_FIXED;                       
  desc[3].ul_descriptor_addr = (uint32_t) &desc[2];       

  DMAC->DMAC_CH_NUM[SSC_DMAC_TX_CH].DMAC_SADDR = desc[2].ul_source_addr;
  DMAC->DMAC_CH_NUM[SSC_DMAC_TX_CH].DMAC_DADDR = desc[2].ul_destination_addr;
  DMAC->DMAC_CH_NUM[SSC_DMAC_TX_CH].DMAC_CTRLA = desc[2].ul_ctrlA;
  DMAC->DMAC_CH_NUM[SSC_DMAC_TX_CH].DMAC_CTRLB = desc[2].ul_ctrlB;
  DMAC->DMAC_CH_NUM[SSC_DMAC_TX_CH].DMAC_DSCR  = desc[2].ul_descriptor_addr;

  DMAC->DMAC_CHER = DMAC_CHER_ENA0 << SSC_DMAC_TX_CH;
  ssc_enable_tx(SSC);
}

void init_dma() {
  uint32_t ul_cfg;

  pmc_enable_periph_clk(ID_DMAC);
  DMAC->DMAC_EN &= (~DMAC_EN_ENABLE);
  DMAC->DMAC_GCFG = (DMAC->DMAC_GCFG & (~DMAC_GCFG_ARB_CFG)) | DMAC_GCFG_ARB_CFG_ROUND_ROBIN;
  DMAC->DMAC_EN = DMAC_EN_ENABLE;

  ul_cfg = 0;
  ul_cfg = DMAC_CFG_SRC_PER(SSC_DMAC_RX_ID) |
           DMAC_CFG_SRC_H2SEL |
           DMAC_CFG_SOD_DISABLE | //SOD: Stop On Done
           DMAC_CFG_FIFOCFG_ALAP_CFG;

  DMAC->DMAC_CH_NUM[SSC_DMAC_RX_CH].DMAC_CFG = ul_cfg;
  DMAC->DMAC_CHDR = DMAC_CHDR_DIS0 << SSC_DMAC_RX_CH;

//transmit
  ul_cfg = 0;
  ul_cfg = DMAC_CFG_DST_PER(SSC_DMAC_TX_ID) |
           DMAC_CFG_DST_H2SEL |
           DMAC_CFG_SOD_DISABLE | //SOD: Stop On Done
           DMAC_CFG_FIFOCFG_ALAP_CFG;

  DMAC->DMAC_CH_NUM[SSC_DMAC_TX_CH].DMAC_CFG = ul_cfg;
  DMAC->DMAC_CHDR = DMAC_CHDR_DIS0 << SSC_DMAC_TX_CH;
//

  NVIC_EnableIRQ(DMAC_IRQn);

  DMAC->DMAC_EBCIER = DMAC_EBCIER_BTC0 << SSC_DMAC_RX_CH;

  DMAC->DMAC_EBCIER = DMAC_EBCIER_BTC0 << SSC_DMAC_TX_CH;

  DMAC->DMAC_EBCISR;
}

void init_ssc() {
  clock_opt_t        rx_clk_option;
  data_frame_opt_t   rx_data_frame_option;
  clock_opt_t        tx_clk_option;
  data_frame_opt_t   tx_data_frame_option;

  memset((uint8_t *)&rx_clk_option,        0, sizeof(clock_opt_t));
  memset((uint8_t *)&rx_data_frame_option, 0, sizeof(data_frame_opt_t));
  memset((uint8_t *)&tx_clk_option,        0, sizeof(clock_opt_t));
  memset((uint8_t *)&tx_data_frame_option, 0, sizeof(data_frame_opt_t));

  pmc_enable_periph_clk(ID_SSC);
  ssc_reset(SSC);

  rx_clk_option.ul_cks               = SSC_RCMR_CKS_RK;
  rx_clk_option.ul_cko               = SSC_RCMR_CKO_NONE;
  rx_clk_option.ul_cki               = SSC_RCMR_CKI;
  //1 = The data inputs (Data and Frame Sync signals)
  //    are sampled on Receive Clock rising edge. 
  rx_clk_option.ul_ckg               = SSC_RCMR_CKG_NONE; // bylo 0;
  rx_clk_option.ul_start_sel         = SSC_RCMR_START_RF_RISING;
  rx_clk_option.ul_period            = 0;
  rx_clk_option.ul_sttdly            = 1;

  rx_data_frame_option.ul_datlen     = BIT_LEN_PER_CHANNEL - 1;
  rx_data_frame_option.ul_msbf       = SSC_RFMR_MSBF;
  rx_data_frame_option.ul_datnb      = 1;//stereo
  rx_data_frame_option.ul_fslen      = 0;
  rx_data_frame_option.ul_fslen_ext  = 0;
  rx_data_frame_option.ul_fsos       = SSC_RFMR_FSOS_NONE;
  rx_data_frame_option.ul_fsedge     = SSC_RFMR_FSEDGE_POSITIVE;

  ssc_set_receiver(SSC, &rx_clk_option, &rx_data_frame_option);
  ssc_disable_rx(SSC);
//  ssc_disable_interrupt(SSC, 0xFFFFFFFF);

  tx_clk_option.ul_cks               = SSC_TCMR_CKS_RK;
  tx_clk_option.ul_cko               = SSC_TCMR_CKO_NONE;
  tx_clk_option.ul_cki               = 0; //example Atmel. bylo SSC_TCMR_CKI;
  //1 = The data outputs (Data and Frame Sync signals)
  //    are shifted out on Transmit Clock rising edge.
  tx_clk_option.ul_ckg               = SSC_TCMR_CKG_NONE; // bylo 0.
  tx_clk_option.ul_start_sel         = SSC_TCMR_START_RF_RISING;
  tx_clk_option.ul_period            = 0;
  tx_clk_option.ul_sttdly            = 1;

  tx_data_frame_option.ul_datlen     = BIT_LEN_PER_CHANNEL - 1;
  tx_data_frame_option.ul_msbf       = SSC_TFMR_MSBF;
  tx_data_frame_option.ul_datnb      = 1;
  tx_data_frame_option.ul_fslen      = 0; // :fsden=0
  tx_data_frame_option.ul_fslen_ext  = 0;
  tx_data_frame_option.ul_fsos       = SSC_TFMR_FSOS_NONE; //input-slave
  tx_data_frame_option.ul_fsedge     = SSC_TFMR_FSEDGE_POSITIVE;

  ssc_set_transmitter(SSC, &tx_clk_option, &tx_data_frame_option);
  ssc_disable_tx(SSC);
  ssc_disable_interrupt(SSC, 0xFFFFFFFF);
}

void pio_B_SSC(void)
{
// DUE: PA15(B)-D24, PA16(B)-A0, PA14(B)-D23 = DACLRC, DACDAT, BCLK 
  PIOA->PIO_PDR   = PIO_PA14B_TK;
  PIOA->PIO_IDR   = PIO_PA14B_TK;
  PIOA->PIO_ABSR |= PIO_PA14B_TK;
 
  PIOA->PIO_PDR   = PIO_PA15B_TF;
  PIOA->PIO_IDR   = PIO_PA15B_TF;
  PIOA->PIO_ABSR |= PIO_PA15B_TF;

  PIOA->PIO_PDR   = PIO_PA16B_TD;
  PIOA->PIO_IDR   = PIO_PA16B_TD;
  PIOA->PIO_ABSR |= PIO_PA16B_TD;
}
 
以下用户感谢此帖子: 达斯洛罗

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#21开: 2018年5月1日,晚上10:30:26»
这种剪辑方法仅在文本书示例中工作,用于清洁正弦音的单个信号源,而不是来自各种复杂声音来自多个来源的真实世界应用程序。此应用程序确实需要DSP处理,从而进行编程。
他谈到了使用9个LED ......仅在有限情况下工作的东西'似乎对我来说是一个巨大的问题。这显然比产品更多的科学公平。
 

 离线 奥格登

  • 超级贡献者
  • ***
  • 帖子:3416
  • 国家:  Lv.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#22: 2018年5月1日,晚上10:53:24»
这种剪辑方法仅在文本书示例中工作,用于清洁正弦音的单个信号源,而不是来自各种复杂声音来自多个来源的真实世界应用程序。此应用程序确实需要DSP处理,从而进行编程。
他谈到了使用9个LED ...... 仅在有限情况下工作的东西'似乎对我来说是一个巨大的问题。这显然比产品更多的科学公平。

无论您使用3x3 LED或HD显示屏 - 剪切方法都不重要。

Siemens LMS声音相机确实是产品:


 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#23开: 2018年5月01日,晚上11:03:03»
是的那个。它们都使用对数螺旋。任何人都知道为什么?
@ogden是什么'剪切方法的问题?
@mastert好事复杂性强化了我所有模拟的决定。
顺便说一下,谈论ADC,在那里均在那里进行大规模转换吗?然后我就不会'T必须在MCU中花时间并反击信号。

无论如何,我得到了FFT运行,有两个核心是甜蜜的,所以我也可以使用编程来制作这个东西。
//github.com/laurentopia/M5-Signal-Multimeter
« 上次编辑:2018年5月1日,晚上11:12:50由Daslolo »
九九九
 

 离线 奥格登

  • 超级贡献者
  • ***
  • 帖子:3416
  • 国家:  Lv.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#24开: 2018年5月1日,晚上11:27:59»
是的那个。它们都使用对数螺旋。任何人都知道为什么?

imho的理由是营销。螺旋看起来比直梁好。

引用
@ogden是什么'剪切方法的问题?

使用剪裁丢失信号幅度信息。同样 - 甚至安静的嘶嘶声骑在声音顶部会增加如此多的噪音和"jitter"相位测量值,W / O平均它将无法正常工作。如果您需要的平均或多或少是DSP处理 - 那么为什么不't做了很多开始,为什么将分辨率降低到1bit以后奋斗的斗争(分辨率)回来?

引用
@mastert好事复杂性强化了我所有模拟的决定。

我很乐意看到工作,完全模拟系统 :)

引用
顺便说一下,谈论ADC,在那里均在那里进行大规模转换吗?然后我就不会'T必须在MCU中花时间并反击信号。

有Flash ADC'这非常快。再次 - 处理将增加延迟。声音传播毕竟是即时的。所以它实际上并不重要 - 您可以找到1ms,2ms或10ms延迟的声音方向。
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#25 on: 2018年5月1日,晚上11:40:13»
是的那个。它们都使用对数螺旋。任何人都知道为什么?

@mastert好事复杂性强化了我所有模拟的决定。
顺便说一下,谈论ADC,在那里均在那里进行大规模转换吗?然后我就不会'T必须在MCU中花时间并反击信号。

无论如何,我得到了FFT运行,有两个核心是甜蜜的,所以我也可以使用编程来制作这个东西。
对数螺旋是给潜在客户留下深刻印象,声音相机确实非常复杂,因此成本高昂的功能。顺便说一句,我应该说最近的一两次听起来是一个声音器/相机,一个带Arduino Leonardo和Arduino到期。
你不'T必须花费120 USEC左右等待ADC转换完成。有两种方法可以节省时间。在8位Atmega控制器上,您可以激活ADC Conv。完全中断,并在样本准备就绪时进入中断子程序。它'大约6-10 USEC,与等候国家进行比较120 USEC。一世'm说ammega328 / Atmega32u4等
Arduino到期有DMA,所以只有在完整的数据阵列准备好一次时,只能进入中断子功能,并采样1 MSPS非常容易进行CPU参与。   

很高兴你有FFT运行,现在你应该检查时间,如果你可以在数据流上运行FFT(4麦克风 - 10k * 4 = 40 ksps等)。 可能需要一些优化。 Arduino由于IIS,能够通过FFT处理数据,即使Hi-Fi 48kHz * 4 =也不会重新定量优化。< 200 ksps sound. 但我确实优化了Arduino Leonardo的处理,左/右上比顶/底麦克风的交织加工,因为Leonardo适用于大约20ksps。 
 

 离线 发光机

  • 常规贡献者
  • *
  • 帖子:56
  • 国家:  茹
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#26: 2018年5月01日,晚上11:59:39»
交叉相关与DFT相同。实用价值很少或零,因为FFT速度速度速度大约成千上万。
我认为我们确实可以从他们的dfts中获得两个信号的互相关,从而节省时间,你是对的。我的意思是通过任何手段获得互相关应该是这里的主要方法,因为它可以直接告诉我们两个信号之间的时间差。或不?如果不是,那么我不'T了解FFT方法应该如何工作。  :-//

通过制作剪辑,您将基本上对信号进行非线性失真。进行实验:观察一个升波的光谱,并观察夹在剪裁的正弦波的光谱。现在用两个凸瓦做同样的事情。您应该注意到具有频率W1和W2的峰值已乘以频率,如W1 + W2,2 * W1 + W2等频率达到峰值。
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#27: 2018年5月02日,01:27:35»
交叉相关与DFT相同。实用价值很少或零,因为FFT速度速度速度大约成千上万。
我认为我们确实可以从他们的dfts中获得两个信号的互相关,从而节省时间,你是对的。我的意思是通过任何手段获得互相关应该是这里的主要方法,因为它可以直接告诉我们两个信号之间的时间差。或不?如果不是,那么我不'T了解FFT方法应该如何工作。  :-//
对,交叉相关输出时间差。 FFT输出相位差,但是因为我们知道频率&空气中的声音速度'是一块蛋糕来翻译阶段时间和后退,无论是什么更实用的最终结果。在找到与声源的角度的方向是必须确定的,尽管必须将时间差或阶段转换为角度,基于两个麦克风之间的距离's.
 第二个反对互相关的原因是它'S运行所有带宽的摘要报告。如果有两个和更多的声源(总是在现实世界中)CC提供了无意义的数据。同一时间FFT可以很容易地区分100'声音来源,只要他们不'T在带宽中重叠,或者没有完全重叠。切割0-10 kHz带的78 Hz切片 ,排序噪声源的声音模式,您可以识别特定于每个特定的窄带,并找到正确的方向。
同样适用于站立的波浪,混响,呼应尤其是室内环境,只有FFT能够整理和抛弃一部分数据拉动,即最扭曲/损坏,并且仍在解析三角术方程。
 

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#28 on: 2018年5月02日,01:34:47»
交叉相关与DFT相同。实用价值很少或零,因为FFT速度速度速度大约成千上万。
FFT是一种DFT的形式,可以用FFT加速离散交叉相关性。最好是真正的FFT,所以你不 'T必须将信号组合以获得效率。
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#29开: 2018年5月02日,03:52:53 AM»
最好是真正的FFT,所以你不'T必须将信号组合以获得效率。
这是什么意思,真正的fft?是否存在非真实部分?和"combine signal" is a new 数学术语?对不起我的 有限的词汇表,我知道+ - * /,从未听过结合。
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#30: 2018年5月02日,04:09:10»
是的那个。它们都使用对数螺旋。任何人都知道为什么?

@mastert好事复杂性强化了我所有模拟的决定。
顺便说一下,谈论ADC,在那里均在那里进行大规模转换吗?然后我就不会'T必须在MCU中花时间并反击信号。

无论如何,我得到了FFT运行,有两个核心是甜蜜的,所以我也可以使用编程来制作这个东西。
对数螺旋是给潜在客户留下深刻印象,声音相机确实非常复杂,因此成本高昂的功能。顺便说一句,我应该说最近的一两次听起来是一个声音器/相机,一个带Arduino Leonardo和Arduino到期。
你不'T必须花费120 USEC左右等待ADC转换完成。有两种方法可以节省时间。在8位Atmega控制器上,您可以激活ADC Conv。完全中断,并在样本准备就绪时进入中断子程序。它'大约6-10 USEC,与等候国家进行比较120 USEC。一世'm说ammega328 / Atmega32u4等
Arduino到期有DMA,所以只有在完整的数据阵列准备好一次时,只能进入中断子功能,并采样1 MSPS非常容易进行CPU参与。   

很高兴你有FFT运行,现在你应该检查时间,如果你可以在数据流上运行FFT(4麦克风 - 10k * 4 = 40 ksps等)。 可能需要一些优化。 Arduino由于IIS,能够通过FFT处理数据,即使Hi-Fi 48kHz * 4 =也不会重新定量优化。< 200 ksps sound. 但我确实优化了Arduino Leonardo的处理,左/右上比顶/底麦克风的交织加工,因为Leonardo适用于大约20ksps。

螺旋看起来科学,住房看起来很昂贵。
I'd喜欢在动作中看到你的声音相机,你有项目的链接吗?我没有'知道arduino板可以推动1msps!这个频道是吗?通过Arduino Dev IDE或您直接在寄存器上戳吗?

我不'知道如何计算sps,但也许是你'谈论采样频率。在那种情况下我'm sampling at 10khz.
至于FFT时序,在ESP32上,一个512箱FFT需要14毫秒,捕获需要10ms @ 10kHz,40kHz是使用延迟的Analogread循环的采样限制。
绕过寄存器安全锁定并管理25 MHz输出的人,因此必须快速输入抽样,但我必须说我没有'了解它'完成了,以及对使用第二个核心进行捕获的影响(我是什么'm doing) is.
我没有'使用DMA,但我读过ESP32也有DMA,我不'知道这是否与您的代码相同。
九九九
 

 在线的 哈姆斯特_NZ.

  • 超级贡献者
  • ***
  • 帖子:2397
  • 国家:  NZ.
bodog:制作一个声音相机
« bodog#31开: 2018年5月02日,04:52:36»
螺旋看起来像用作平方公里阵列的核心的螺旋。



//www.skatelescope.org/layout/

引用
科学家们在详细研究后选择了螺旋布局设计,以如何最好地优化配置以获得最佳结果。

这种螺旋配置在天线之间提供了许多不同的长度(基线)和角度,导致非常高分辨率的成像能力。

完美的布局将是一种随机布置,可以最大化不同基线的数量和天线之间的角度。然而,施工的实用性以及将天线与电缆连接意味着螺旋配置是图像分辨率和成本之间的最佳折衷。
凝视不进入深渊,以免让你被认为是深渊领域专家,他们期望你继续凝视该死的事情。
 
以下用户感谢此帖子: 奥格登

 离线 mikeselectricaluff.

  • 超级贡献者
  • ***
  • 帖子:12319
  • 国家:  GB.
    • 麦克风's Electric Stuff
bodog:制作一个声音相机
« bodog#32开启: 2018年5月02日,07:05:31»
有人在这里发布了一段时间,他们已经完成了类似的东西他们使用数字输出MEMS麦克风模块和FPGA,以制作一个非常便宜的系统
我不'T回忆起他们在产生视觉输出时的距离。
Youtube channel:分开奇怪的东西。很宽。
麦克风's Electric Stuff:高压,复古电子等。
一天的工作 :主要是LED
 

 离线 mikeselectricaluff.

  • 超级贡献者
  • ***
  • 帖子:12319
  • 国家:  GB.
    • 麦克风's Electric Stuff
Youtube channel:分开奇怪的东西。很宽。
麦克风's Electric Stuff:高压,复古电子等。
一天的工作 :主要是LED
 

 离线 mikeselectricaluff.

  • 超级贡献者
  • ***
  • 帖子:12319
  • 国家:  GB.
    • 麦克风's Electric Stuff
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#34开: 2018年5月02日,07:25:06»
是的那个。它们都使用对数螺旋。任何人都知道为什么?
我的猜测将与站立波和/或具有大量不同的麦克风距离有关,同时保持灵敏度的对称性

数字输出MEMS MIC与I2S或脉冲调制方案非常便宜,因此可以对MICS数量与处理复杂性进行竞争时可能是有意义的

Youtube channel:分开奇怪的东西。很宽。
麦克风's Electric Stuff:高压,复古电子等。
一天的工作 :主要是LED
 

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#35开启: 2018年5月02日,07:37:45»
这是什么意思,真正的fft?是否存在非真实部分?和"combine signal" is a new 数学术语?对不起我的 有限的词汇表,我知道+ - * /,从未听过结合。
大多数FFT实现都很复杂<->复杂,我们在DSP中一般感兴趣的是一个真实的>复杂的FFT和复杂 - >真正的ifft。您可以使用复杂的FFT来完成两个真实FFT,但它's a headache.
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#36开启: 2018年5月2日,晚上12:48:50»
I'd喜欢在动作中看到你的声音相机,你有项目的链接吗?我没有'知道arduino板可以推动1msps!这个频道是吗?通过Arduino Dev IDE或您直接在寄存器上戳吗?

我不'知道如何计算sps,但也许是你'谈论采样频率。在那种情况下我'm sampling at 10khz.
至于FFT时序,在ESP32上,一个512箱FFT需要14毫秒,捕获需要10ms @ 10kHz,40kHz是使用延迟的Analogread循环的采样限制。
绕过寄存器安全锁定并管理25 MHz输出的人,因此必须快速输入抽样,但我必须说我没有'了解它'完成了,以及对使用第二个核心进行捕获的影响(我是什么'm doing) is.
我没有'使用DMA,但我读过ESP32也有DMA,我不'知道这是否与您的代码相同。
我不't have a video, it'失去了。可视化在Android平板电脑上完成,我使用BT传输加工/过滤和排序数据。 每秒1兆样品通过直接登记编程,Arduino IDE是邋..每个频道1个MSP。

流采样率 当ADC转换发生在后台时,只有真实数据处理才有意义 连续使用DMA或中断。 FFT应该比采样更快地计算, 14 MSEC,512 FFT意味着理论上可以获得36571 Hz采样,而不是计算数据管理的开销。

这是什么意思,真正的fft?是否存在非真实部分?和"combine signal" is a new 数学术语?对不起我的 有限的词汇表,我知道+ - * /,从未听过结合。
大多数FFT实现都很复杂<->复杂,我们在DSP中一般感兴趣的是一个真实的>复杂的FFT和复杂 - >真正的ifft。您可以使用复杂的FFT来完成两个真实FFT,但它's a headache.
It'是一个古老的神话,我们可以节省时间没有在输入数据的空想部分上做数学。我做了一些研究,它'事实证明,CPU时钟节省只有半频分辨率,所以所有这些理论要定义真实>FFT是完整的BS。有许多证明的优化技术,这是一个'T牺牲频率分辨率,如使用更高的基数或分割基数,但都取决于特定的UCPU和它'S指令集,可用性MAC,MULT VS添加性能等。 
 

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#37 on: 2018年5月02日,01:25:34 PM»
It's an old myth
不,乘以0总是浪费时间。
引用
它'事实证明,CPU时钟节省仅具有半频分辨率
如果用0s填充复杂FFT的虚构输入,则输出是对称的......频率箱的索引较高的索引是无关紧要的,一半的信息是完全多余的。

一个真正的fft达到奈奎斯特,就像真正的DFT一样'显然就足够了。
« 上次编辑:2018年5月02,01:29:42由Marco »
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#38 on: 2018年5月02日,01:35:39 PM»
It's an old myth
不,乘以0总是浪费时间。
引用
它'事实证明,CPU时钟节省仅具有半频分辨率
如果用0s填充复杂FFT的虚构输入,则输出是对称的......频率箱的索引较高的索引是无关紧要的,一半的信息是完全多余的。
.
显示您的代码,而不是谈话。
 

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
bodog:制作一个声音相机
« bodog#39开: 2018年5月02日,02:16:56 PM»
努。
 

 离线 奥格登

  • 超级贡献者
  • ***
  • 帖子:3416
  • 国家:  Lv.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#40开启: 2018年5月02日,03:07:21 PM»
如果用0s填充复杂FFT的虚构输入,则输出是对称的......频率箱的索引较高的索引是无关紧要的,一半的信息是完全多余的。
.
显示您的代码,而不是谈话。

代码也可以是第三方 :)

//www.keil.com/pack/doc/CMSIS/DSP/html/group__RealFFT.html

最有可能对DSP包感兴趣:

//github.com/ARM-software/CMSIS_5/releases/tag/5.3.0
 

 离线 发光机

  • 常规贡献者
  • *
  • 帖子:56
  • 国家:  茹
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#41开启: 2018年5月02日,04:00:03»
对,交叉相关输出时间差。 FFT输出相位差,但是因为我们知道频率&空气中的声音速度'是一块蛋糕来翻译阶段时间和后退,无论是什么更实用的最终结果。在找到与声源的角度的方向是必须确定的,尽管必须将时间差或阶段转换为角度,基于两个麦克风之间的距离's.
 第二个反对互相关的原因是它'S运行所有带宽的摘要报告。如果有两个和更多的声源(总是在现实世界中)CC提供了无意义的数据。同一时间FFT可以很容易地区分100'声音来源,只要他们不'T在带宽中重叠,或者没有完全重叠。切割0-10 kHz带的78 Hz切片 ,排序噪声源的声音模式,您可以识别特定于每个特定的窄带,并找到正确的方向。
同样适用于站立的波浪,混响,呼应尤其是室内环境,只有FFT能够整理和抛弃一部分数据拉动,即最扭曲/损坏,并且仍在解析三角术方程。
I'刚刚测试了MATLAB中的互相关,它实际上可以使用具有狭窄的自相关和低互相关的多种噪声样信号来工作。但该方法与人类言论变得糟糕,因为它'由于我最初假设的不那么随机。  :(
DFT确实是这里的选择。
我不喜欢什么'要了解是,如果两个声音源占用完全相同的频率,就像这个线程中的视频中的汽车控制面板一样,系统如何区分它们?
 

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
bodog:制作一个声音相机
« bodog#42开启: 2018年5月02日,04:58:36 PM»
It'好好说"use the DFT", but it doesn'真的意味着什么。给定频率的麦克风之间的一堆相差'T容易转换为延迟,阶段毕竟是2PI。

如果要挑选出频谱的一部分,请刚刚将FFT变换的麦克风信号乘以最小相位带通滤波器的傅里叶域表示,然后在彼此乘以并进行反向FFT。它's仍然交叉相关,仅仅是麦克风信号的带限制版。

PS。大学教师'忘记在执行FFT之前忘记键盘信号。
« 上次编辑:2018年5月02,05:05:57由Marco »
 

 离线 奥格登

  • 超级贡献者
  • ***
  • 帖子:3416
  • 国家:  Lv.
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#43开: 2018年5月02日,05:49:36 PM»
It'S蹩脚的radix-2,对未开发的第三世界有好处  tribes numba-umba.

开始了 8)

引用
对于在维基页面上申请的任何BS的人而不是在这篇线程上发布的人,这是由op启动的,他们在第一条消息中承认他缺乏软件技能。我不'如果我们开始另一个FFT相关的线程,请看到在此继续这一争执的点?

是的,请。分享您的WIZDOM。如果讨论可能导致Cortex-M优化更快和/或更小的Cortex-M,我特别感兴趣 复杂的 FFT代码比CMSIS DSP Lib中的代码。
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
bodog:制作一个声音相机
« bodog#45: 5月4日,2018年,12:05:38»
螺旋看起来像用作平方公里阵列的核心的螺旋。



//www.skatelescope.org/layout/

引用
科学家们在详细研究后选择了螺旋布局设计,以如何最好地优化配置以获得最佳结果。

这种螺旋配置在天线之间提供了许多不同的长度(基线)和角度,导致非常高分辨率的成像能力。

完美的布局将是一种随机布置,可以最大化不同基线的数量和天线之间的角度。然而,施工的实用性以及将天线与电缆连接意味着螺旋配置是图像分辨率和成本之间的最佳折衷。
好好看看有一个非常好的原因。提醒我几年前关于Viktor Schauberger的读物。我想知道我们还可以从他的杰出工作中升起什么。

是的那个。它们都使用对数螺旋。任何人都知道为什么?
我的猜测将与站立波和/或具有大量不同的麦克风距离有关,同时保持灵敏度的对称性

数字输出MEMS MIC与I2S或脉冲调制方案非常便宜,因此可以对MICS数量与处理复杂性进行竞争时可能是有意义的

什么 do you mean it has to do with  standing wave?
还能解释媒体数量的贸易差异与处理复杂性吗?在我看来,更多的麦克风=更多的fft搅动

你们失去了我的东西,直到我看到它的淫荡"base", I'请问为什么在您的其他线程中的原因,它's interesting.

谁能给我一个解释为什么jambalaya与fft会给我麦克风延迟?我理解频域图将给我一种声音的即时签名,但我不'了解它的方式'LL检测到一个声音在这个麦克风上到达了几毫秒VS ...
九九九
 

 离线 奥格登

  • 超级贡献者
  • ***
  • 帖子:3416
  • 国家:  Lv.
bodog:制作一个声音相机
« bodog#46开: 2018年5月4日,上午12:33:19»
谁能给我一个解释为什么jambalaya与fft会给我麦克风延迟?

复杂FFT的输出是数组 复数 这意味着您不仅可以获得FFT的每个频率箱的幅度而是相位信息。使用简单三角学,您可以计算两个FFT的垃圾箱之间的相位角差's。知道箱和相位角差的频率,计算信号延迟时间。这当然不是直接的操作,因为在高频相位角差上最可能超过360度 :)

[编辑]真正的FFT只是频谱分析仪。复杂的FFT不仅仅是这个。

引用
我理解频域图将给我一种声音的即时签名,但我不'了解它的方式'LL检测到一个声音在这个麦克风上到达了几毫秒VS ...

在只有1毫秒的声音期间旅行0.343米。您的麦克风阵列应省略几个MS延迟 :)
« 最后编辑:2018年5月4日,2018年12:46:05 AM由Ogden »
 

 离线 master

  • 频繁的贡献者
  • **
  • 帖子:508
  • 国家:  加利福尼亚州
bodog:制作一个声音相机
« bodog#47开启: 2018年5月4日,01:05:24»

1.也可以解释媒体数量与处理复杂性的权衡吗?在我看来,更多的麦克风=更多的fft搅动

2.你们在基地失去了我,直到我看到了它的淫荡"base", I'请问为什么在您的其他线程中的原因,它's interesting.

3.谁能给我一个解释为什么jambalaya与fft会给我麦克风延迟?我理解频域图将给我一种声音的即时签名,但我不'了解它的方式'LL检测到一个声音在这个麦克风上到达了几毫秒VS ...

1.正确。使用您的分析技能来解决垃圾。
2 &3.采取崩溃课程 http://www.dspguide.com/ch8/8.htm
等式8.6。找到一个阶段的关键。
 
你没有'T提供您正在使用的FFT库的链接,如果输出数据集已重新[] and Im[], 比你知道该怎么做。
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
bodog:制作一个声音相机
« bodog#48开启: 2018年5月4日,01:43:52»
好吧,我bodog了所有的电子gizmos,回到基础知识,我解雇了matlab并得到了这个:

代码: [选择]
x=.5*cos(2*pi*20*t+20*pi/180) +.1*cos(2*pi*54*t+-60*pi/180);
x2=.5*cos(2*pi*30*t+20*pi/180) +.1*cos(2*pi*54*t+-50*pi/180);
X = 1/N*fftshift(fft(x,N));
X2 = 1/N*fftshift(fft(x2,N));
%phase thingy
phase=atan2(imag(X),real(X))*180/pi;
phase2=atan2(imag(X2),real(X2))*180/pi;
plot(f,phase-phase2);
这使得2曲线x和x2偏移偏移10(10个),并且在计算阶段和相位2后,我在减去两个阶段时得到这种质朴的曲线......我期望得到10个阶段,但也许有更多按摩我需要做  :-DD


九九九
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
bodog:制作一个声音相机
« bodog#49: 2018年5月4日,01:53:19»
你没有'T提供您正在使用的FFT库的链接,如果输出数据集已重新[] and Im[], 比你知道该怎么做。
//github.com/kosme/arduinoFFT
九九九
 

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
bodog:制作一个声音相机
« bodog#50开: 5月4日,2018年,02:20:05 AM»
FFT主要用作实现卷积的快速方法,从而互相关。我不'知道为什么互相关没有'在Matlab中为您工作......但应该,看看 这个例子 在他们的文件中。当你注意到时,我说的只是对不同麦克风的一堆不同的阶段没有'T给你很多有用的信息,交叉相关给您在时域中有用的东西。如我所说,当使用FFT实现互相关时,您必须将信号键入到长度的两倍(因为基于FFT的卷积是圆形的)。
« 上次编辑:2018年5月4日,02:21:54由Marco »
 

 在线的 哈姆斯特_NZ.

  • 超级贡献者
  • ***
  • 帖子:2397
  • 国家:  NZ.
bodog:制作一个声音相机
« bodog#51开启: 2018年5月4日,03:02:43»
谁能给我一个解释为什么jambalaya与fft会给我麦克风延迟?我理解频域图将给我一种声音的即时签名,但我不'了解它的方式'LL检测到一个声音在这个麦克风上到达了几毫秒VS ...

一个简短的答案......

如果将样本乘以另一个信号,则集成在数字上
样本您可以衡量如何'alike' to signals are.

如果要匹配不同偏移的信号,则必须在每个偏移量下执行此操作。
结果是一个时间序列,显示信号在不同的对齐时匹配多少。

在每个对齐的一组16K样本中测试16K个样本签名将需要
268,435,456乘以添加操作。这是很多数学。如果您喜欢大o复杂性符号,则O(n ^ 2)。

FFT是这样做的有效方法,但工作较少。

使用FFT将签名和测试数据拆分为其频率和相位组件。

您将另一个签名中的组件乘以另一个签名。如果是频率
只在其中一个,它将被删除(零次,任何=零)。如果频率都在两者中,它们将被增强(并且相位发生变化)。

然后,您将留下一组幅度,该幅度指示两个信号常见的频率,具有一些相位信息(记住阶段信息=定时信息)

通过在此结果上运行逆fft,其中的情况是'in sync'各种组件的大小加起来,在那里它们是'out of sync'平均地分离出来。

结果是一个时间序列,显示信号在不同的对齐时匹配多少
  - 由硬方法发现的,与圆角相同的数字(舍入除外!)。

但是,因为FFT和IFFT都是O(n * logn)复杂性,对于N的大值而言,这更加实用。

因此,对于16K样本,艰难的方式需要268,435,456个单位的工作。 FFT途中需要2 * 16K * 4.2 = 1,101,004单位(但是,两种过程之间的工作单位的大小可能是不同的,所以您可以'只是说这将速度更快256倍)。

这也会带来另一个点。为了从这样的过程中获取良好的时序信息,您的签名必须具有良好的频率混合它 - 因此在它们处于相位时,正弦波将与相同频率的另一个正弦波相匹配,从而提供模糊的结果。签名也必须具有结构 - 纯无随机噪声的一点就像任何其他随机噪声.

这是海豚使用的原因之一'clicks'用于回声机和雷达使用'chirps'。除非您有许多麦克风来准确地确定该令人讨厌的嗡嗡声的位置,允许您允许您允许您删除歧义的较大。
« 上次编辑:2018年5月9日,04:39:01 AM由仓鼠_NZ »
凝视不进入深渊,以免让你被认为是深渊领域专家,他们期望你继续凝视该死的事情。
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
bodog:制作一个声音相机
« bodog#52开启: 2018年5月08日,03:51:58»
好吧@hamster_nz,我明白声音需要谐波的fft做一个匹配,幸运的是,哼得着谐波,这就是困扰(与脑锁定图案的脑袋有关的事情)。由于您的解释,我现在明白,乘以各种麦克风的频谱会给我匹配频率。
我不'要了解IFFT如何让我在信号之间偏移,我认为是我需要三角化源的东西。
我不't理解你对乘法阶段的那些东西都不是所以我尝试在matlab中做到这一点。相位EDLTA在X和X2之间是10度,正弦波在10Hz处,因此X和X2之间的偏移是1/10 * 10/360 = 0.027s(右?)
这个图表显示2,所以我'在某个地方做错了什么。

代码: [选择]
fc=10;
fs=32*fc;
t=0:1/fs:2-1/fs;
x=.5*cos(2*pi*20*t+20*pi/180) +.1*cos(2*pi*54*t+-60*pi/180) ;%time domain signal with phase shift
x2=.5*cos(2*pi*20*t+30*pi/180) +.1*cos(2*pi*54*t+-50*pi/180) ;
N=256; %FFT size
X = 1/N*fftshift(fft(x,N));%N-point complex DFT
X2 = 1/N*fftshift(fft(x2,N));%N-point complex DFT

%phase delta
X3=X.*X2;
phase3=atan2(imag(X3),real(X3))*180/pi; %phase
df=fs/N; %frequency resolution
sampleIndex = -N/2:N/2-1; %ordered index for FFT plot
f=sampleIndex*df; %x-axis index converted to ordered frequencies
plot(f,phase3.*real(X3));

« 上次编辑:2018年5月08日,04:06:37 AM由Daslolo »
九九九
 

 在线的 哈姆斯特_NZ.

  • 超级贡献者
  • ***
  • 帖子:2397
  • 国家:  NZ.
bodog:制作一个声音相机
« bodog#53开启: 2018年5月08日,晚上12:03:18»
对不起的代码,但这是一切(尽管使用DFT而不是FFT)

代码: [选择]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define POINTS   (128)
#define FFT_SIZE (POINTS/2+1)
#define PI       (3.1415926535897932384626433)

double samples1[POINTS],       samples2[POINTS], samples1flipped[POINTS];
double spectrum1_r[FFT_SIZE], spectrum1_i[FFT_SIZE];
double spectrum2_r[FFT_SIZE], spectrum2_i[FFT_SIZE];
double spectrumX_r[FFT_SIZE], spectrumX_i[FFT_SIZE];
double samplesX[POINTS];


/**********************************************************************/
void generate_signature(double *samples) {
   int i;
   for(i = 0; i < POINTS; i++)
      samples[i] = 0;

   for(i =  0; i <  5; i++) samples[i] = -1.0;
   for(i =  5; i < 10; i++) samples[i] = 1.0;
   for(i = 10; i < 15; i++) samples[i] = -1.0;
   for(i = 15; i < 20; i++) samples[i] = 1.0;
}

/**********************************************************************/
void flip_samples(double *s1, double *s2) {
   int i;
   for(i = 0; i < POINTS; i++)
     s2[i] = s1[POINTS-1-i];
}
/**********************************************************************/
void offset_sample(double *samples1, double *samples2, int offset) {
   int i;
   for(i = 0; i < POINTS; i++)
      samples2[i] = samples1[(i-offset)%POINTS];
}

/**********************************************************************/
void complex_mult(double *r1, double *i1,
                  double *r2, double *i2,
                  double *r3, double *i3) {
   int i;
   for(i = 0; i < FFT_SIZE; i++) {
      r3[i] = (r1[i] * r2[i]) - (i1[i] * i2[i]);
      i3[i] = (r1[i] * i2[i]) + (r2[i] * i1[i]);
   }
}

/**********************************************************************/
void add_noise(double *samples, double level) {
   int i;
   for(i = 0; i < POINTS; i++) {
      samples[i] += (rand()*level)/RAND_MAX;
   }
}

/**********************************************************************/
void print_max(double *samples) {
   int    max_i = 0;
   double max = samples[0];
   int i;
   for(i = 1; i < POINTS; i++) {
      if(samples[i] > max) {
        max_i = i;
        max   = samples[i];
      }
   }

   if(max_i >= POINTS/2)
      max_i -= POINTS;
   printf("Max is at %i (%10.4f)\n", max_i, max);
}

/**********************************************************************/
void dft(double *samples, double *r, double *i) {
  int b,p;
  for(b = 0; b < FFT_SIZE; b++)
  {
    r[b] = 0.0;
    i[b] = 0.0;
    for(p = 0; p <POINTS; p++)
    {
      double angle = 2*PI*b*p/POINTS;
      r[b] += samples[p] * cos(angle);
      i[b] -= samples[p] * sin(angle);
    }
  }
}

/******************************************************/
void idft(double *r, double *i, double *samples) {
  int b,p;
  double rs[FFT_SIZE];
  double is[FFT_SIZE];

  for(b = 0; b < FFT_SIZE; b++) {
     rs[b] = r[b]/(POINTS/2);
     is[b] = -i[b]/(POINTS/2);
  }
  rs[0]          = r[0]/POINTS;
  rs[FFT_SIZE-1] = r[FFT_SIZE-1]/POINTS;

  for(p = 0; p < POINTS; p++)
  {
    for(b = 0; b < FFT_SIZE; b++)
    {
      double angle = 2*PI*b*p/POINTS;
      samples[p] += (rs[b] * cos(angle)) + (is[b] * sin(angle));
    }
  }
}
/******************************************************/
int main(int argc, char *argv[]) {
   int i;
   /* Prepare the data */
   generate_signature(samples1);
   offset_sample(samples1,samples2, 50);
   add_noise(samples2, 0.8);

   /* Flip the samples to turn convolution it to correlation */
   flip_samples(samples1,samples1flipped);

   /* Take the DFT */
   dft(samples1flipped,spectrum1_r,spectrum1_i);
   dft(samples2,spectrum2_r,spectrum2_i);

   /* Multiply the spectrums */
   complex_mult(spectrum2_r, spectrum2_i,
                spectrum1_r, spectrum1_i,
                spectrumX_r, spectrumX_i);

   /* Inverse DFT to find how well they match */
   idft(spectrumX_r,spectrumX_i,samplesX);

   /* Output the results */
   for(i = 0; i < POINTS; i++) {
      printf("%4i, %10.7f, %10.7f, %10.7f\n",i, samples1[i], samples2[i], samplesX[i]);
   }
   print_max(samplesX);
   return 0;
}


在下面的图片中。

- 第一个图是'signature' being looked for.

- 第二个是要查找签名的数据

- zhrid图是FFT相关的输出 - 峰值是第二信号的第一峰值。 注意峰值位于您需要对齐的偏移量。

我将是第一个承认这只是一个黑客,你需要开发和测试它......
凝视不进入深渊,以免让你被认为是深渊领域专家,他们期望你继续凝视该死的事情。
 
以下用户感谢此帖子: 达斯洛罗

 离线 马可

  • 超级贡献者
  • ***
  • 帖子:4944
  • 国家:  NL.
bodog:制作一个声音相机
« bodog#54开启: 2018年5月8日,01:36:20 PM»
签名也必须具有结构 - 它 - 纯无随机噪声的一点就像任何其他随机噪声。

It's相反,每位噪音都是唯一的。当您交叉相关两个麦克风接收时,白噪声源将提供一个非常清晰的尖峰。
 

 在线的 eBaster.

  • 超级贡献者
  • ***
  • 帖子:3783
  • 国家:  德
Re:计算麦克风阵列(模拟或数字)的相位Δ和幅度
« bodog#55 on: 2018年5月08日,07:50:25 PM»
无论如何,我得到了FFT运行,有两个核心是甜蜜的,所以我也可以使用编程来制作这个东西。
//github.com/laurentopia/M5-Signal-Multimeter

什么'是那张照片中的硬件? (小屏幕加上左边的处理器设备?)看起来很整洁!
 

 在线的 哈姆斯特_NZ.

  • 超级贡献者
  • ***
  • 帖子:2397
  • 国家:  NZ.
bodog:制作一个声音相机
« bodog#56开启: 2018年5月09日,04:38:10»
签名也必须具有结构 - 它 - 纯无随机噪声的一点就像任何其他随机噪声。

It's相反,每位噪音都是唯一的。当您交叉相关两个麦克风接收时,白噪声源将提供一个非常清晰的尖峰。

是的,你是对的。
凝视不进入深渊,以免让你被认为是深渊领域专家,他们期望你继续凝视该死的事情。
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
bodog:制作一个声音相机
« bodog#57开启: 2018年5月9日,05:31:24»
无论如何,我得到了FFT运行,有两个核心是甜蜜的,所以我也可以使用编程来制作这个东西。
//github.com/laurentopia/M5-Signal-Multimeter

什么'是那张照片中的硬件? (小屏幕加上左边的处理器设备?)看起来很整洁!
m5stack.
九九九
 
以下用户感谢此帖子: eBaster.

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
bodog:制作一个声音相机
« bodog#58开启: 2018年5月9日,晚上11:18:14»
我将是第一个承认这只是一个黑客,你需要开发和测试它......

非常感谢你:它做了我需要的东西。我喜欢你没有'T fft and fft,我从未意识到dft到现在是多么慢 :)
为什么FFT大小的样本大小的一半?
在CPU成本中,计算5个麦克风将需要5!= 120x IFFT + 5X FFT + 5X翻转FFT?
在做复杂的mult之前,翻转x1,这相当于卷积吗?如果是这样,可以通过将NXN内核应用于两个信号来完成整个事情吗?

如果有人想在他们的MCPU上快速尝试它,那么这里是Arduino代码:

代码: [选择]
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "Adafruit_GFX.h"// Hardware-specific library
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;

#define POINTS   (128)
#define FFT_SIZE (POINTS/2+1)
#define PI       (3.1415926535897932384626433)

double samples1[POINTS], samples2[POINTS], samples1flipped[POINTS];
double spectrum1_r[FFT_SIZE], spectrum1_i[FFT_SIZE];
double spectrum2_r[FFT_SIZE], spectrum2_i[FFT_SIZE];
double spectrumX_r[FFT_SIZE], spectrumX_i[FFT_SIZE];
double samplesX[POINTS];


/**********************************************************************/
void generate_signature(double *samples)
{
int i;
为了 (i = 0; i < POINTS; i++)
samples[i] = 0;

为了 (i = 0; i < 5; i++) samples[i] = -1.0;
为了 (i = 5; i < 10; i++) samples[i] = 1.0;
为了 (i = 10; i < 15; i++) samples[i] = -1.0;
为了 (i = 15; i < 20; i++) samples[i] = 1.0;
}

/**********************************************************************/
void flip_samples(double *s1, double *s2)
{
int i;
为了 (i = 0; i < POINTS; i++)
s2[i] = s1[POINTS - 1 - i];
}
/**********************************************************************/
void offset_sample(double *samples1, double *samples2, int offset)
{
int i;
为了 (i = 0; i < POINTS; i++)
samples2[i] = samples1[(i - offset) % POINTS];
}

/**********************************************************************/
void complex_mult(double *r1, double *i1,
double *r2, double *i2,
double *r3, double *i3)
{
int i;
为了 (i = 0; i < FFT_SIZE; i++)
{
r3[i] = (r1[i] * r2[i]) - (i1[i] * i2[i]);
i3[i] = (r1[i] * i2[i]) + (r2[i] * i1[i]);
}
}

/**********************************************************************/
void add_noise(double *samples, double level)
{
int i;
为了 (i = 0; i < POINTS; i++)
{
samples[i] += (rand()*level) / RAND_MAX;
}
}

/**********************************************************************/
void print_max(double *samples)
{
int    max_i = 0;
double max = samples[0];
int i;
为了 (i = 1; i < POINTS; i++)
{
if (samples[i] > max)
{
max_i = i;
max = samples[i];
}
}

if (max_i >= POINTS / 2)
max_i -= POINTS;
printf("Max is at %i (%10.4f)\n", max_i, max);
 tft.drawLine(max_i, 50, max_i,150, 0b111111111100000);
tft.setCursor(0, 170);
tft.print("Offset = ");
 tft.print(max_i);
}

/**********************************************************************/
void dft(double *samples, double *r, double *i)
{
int b, p;
为了 (b = 0; b < FFT_SIZE; b++)
{
r[b] = 0.0;
i[b] = 0.0;
为了 (p = 0; p < POINTS; p++)
{
double angle = 2 * PI*b*p / POINTS;
r[b] += samples[p] * cos(angle);
i[b] -= samples[p] * sin(angle);
}
}
}

/******************************************************/
void idft(double *r, double *i, double *samples)
{
int b, p;
double rs[FFT_SIZE];
double is[FFT_SIZE];

为了 (b = 0; b < FFT_SIZE; b++)
{
rs[b] = r[b] / (POINTS / 2);
is[b] = -i[b] / (POINTS / 2);
}
rs[0] = r[0] / POINTS;
rs[FFT_SIZE - 1] = r[FFT_SIZE - 1] / POINTS;

为了 (p = 0; p < POINTS; p++)
{
为了 (b = 0; b < FFT_SIZE; b++)
{
double angle = 2 * PI*b*p / POINTS;
samples[p] += (rs[b] * cos(angle)) + (is[b] * sin(angle));
}
}
}
/******************************************************/
void setup(void)
{
Serial.begin(115200);
  uint16_t ID = tft.readID();
  tft.begin(ID);
  tft.setRotation(1);
  tft.fillScreen(0x0000);

int i;
/* Prepare the data */
generate_signature(samples1);
offset_sample(samples1, samples2, 50);
add_noise(samples2, 0.8);

 double timer = micros();

/* Flip the samples to turn convolution it to correlation */
翻动_samples(samples1, samples1flipped);

/* Take the DFT */
dft(samples1flipped, spectrum1_r, spectrum1_i);
dft(samples2, spectrum2_r, spectrum2_i);

/* Multiply the spectrums */
复杂的 _mult(spectrum2_r, spectrum2_i,
spectrum1_r, spectrum1_i,
spectrumX_r, spectrumX_i);

/* Inverse DFT to find how well they match */
idft(spectrumX_r, spectrumX_i, samplesX);

tft.setCursor(0,0);
  tft.println(micros()-timer);

为了 (i = 0; i < POINTS; i++)
{
tft.drawLine(i, 100 - 10 * samples1[i - 1], i, 100 - 10 * samples1[i], 0b0000000000011111);
tft.drawLine(i, 100 - 10 * samples2[i - 1], i, 100 - 10 * samples2[i], 0b0000010000011111);
tft.drawLine(i, 100 - 2 * samplesX[i - 1], i, 100 - 2 * samplesX[i],   0b1111100000000000);
}
print_max(samplesX);
}

void loop(void) {}
« 上次编辑:2018年5月10日,12:06:04 AM由Daslolo »
九九九
 

 在线的 哈姆斯特_NZ.

  • 超级贡献者
  • ***
  • 帖子:2397
  • 国家:  NZ.
bodog:制作一个声音相机
« bodog#59开启: 2018年5月10日,04:19:41 AM»
非常感谢你:它做了我需要的东西。我喜欢你没有'T fft and fft,我从未意识到dft到现在是多么慢 :)

您可以通过不调用SIN()和COS()来轻松使其更快地更快,您可以制作查找表,但它会花费您的内存。这样siN()和cos()变得如:

sin = sin_table [(索引*频带)%table_size];
cos = sin_table [(table_size / 4 + index * babry)%table_size];

你必须'flip'(实际上镜像在时间)你在干草堆里寻找的针。 我的代码略有错误,并为您提供一个偏移的峰值,ofter ofet 0不应该移动,但项目[1]&物品[n-1]应该交换等等。

我不确定你是否需要所有120个IFFTS。您可能只需要执行少数才能获得足够的信息,以便您可以找到源。
凝视不进入深渊,以免让你被认为是深渊领域专家,他们期望你继续凝视该死的事情。
 

 离线 达斯洛罗

  • 常规贡献者
  • *
  • 帖子:58
  • 国家:  FR.
  • 我看到了WiFi信号一次
bodog:制作一个声音相机
« bodog#60开启: 2018年5月11日,01:30:52 AM»
哦,是的,只需20倍   ; D.
明天我得到覆盆子pi'll上班,真实。
任何使用裸露的金属的东西 //ultibo.org/?
九九九
 


分享我

 掘客    Facebook    诽谤    可口的    Technorati.    推特    谷歌    雅虎
SMF.