差别

这里会显示出您选择的修订版和当前版本之间的差别。

--- rp_web_scope [2021/12/11 20:36]
gongyusu [基于Pi Pico，使用ESP和MicroPython的无线网络服务器]
+++ rp_web_scope [2021/12/11 20:50] (当前版本)
gongyusu [Web display for Pi Pico oscilloscope]
@@ 行 227: / 行 227: @@
 </html>
 So far, I have only presented very simple Web pages; in the next post I’ll show how to fetch high-speed analog samples using DMA, then combine these with a more sophisticated AJAX functionality to create a Web-based oscilloscope.
+### 采用DMA和Micropython使用RP2040的ADC
+{{ :pico_adc_dma.png |}}
+This is the second part of my Web-based Pi Pico oscilloscope project. In the first part I used an Espressif ESP32 to add WiFi connectivity to the Pico, and now I’m writing code to grab analog data from the on-chip Analog-to-Digital Converter (ADC), which can potentially provide up to 500k samples/sec.
+High-speed transfers like this normally require code written in C or assembly-language, but I’ve decided to use MicroPython, which is considerably slower, so I need to use hardware acceleration to handle the data rate, specifically Direct Memory Access (DMA).
+**MicroPython ‘uctypes’**
+MicroPython does not have built-in functions to support DMA, and doesn’t provide any simple way of accessing the registers that control the ADC, DMA and I/O pins. However it does provide a way of defining these registers, using a new mechanism called ‘uctypes’. This is vaguely similar to ‘ctypes’ in standard Python, which is used to define Python interfaces for ‘foreign’ functions, but defines hardware registers, using a very compact (and somewhat obscure) syntax.
+To give a specific example, the DMA controller has multiple channels, and according to the RP2040 datasheet section 2.5.7, each channel has 4 registers, with the following offsets:
+x000 READ_ADDR
+x004 WRITE_ADDR
+x008 TRANS_COUNT
+x00c CTRL_TRIG
+The first three of these require simple 32-bit values, but the fourth has a complex bitfield:
+Bit 31:   AHB_ERROR
+Bit 30:   READ_ERROR
+..and so on until..
+Bits 3-2: DATA_SIZE
+Bit 1:    HIGH_PRIORITY
+Bit 0:    EN
+With MicroPython uctypes, we can define the registers, and individual bitfields within those registers, e.g.
+<code python>
+from uctypes import BF_POS, BF_LEN, UINT32, BFUINT32
+DMA_CHAN_REGS = {
+    "READ_ADDR_REG":       0x00|UINT32,
+    "WRITE_ADDR_REG":      0x04|UINT32,
+    "TRANS_COUNT_REG":     0x08|UINT32,
+    "CTRL_TRIG_REG":       0x0c|UINT32,
+    "CTRL_TRIG":          (0x0c,DMA_CTRL_TRIG_FIELDS)
+}
+DMA_CTRL_TRIG_FIELDS = {
+    "AHB_ERROR":   31<<BF_POS | 1<<BF_LEN | BFUINT32,
+    "READ_ERROR":  30<<BF_POS | 1<<BF_LEN | BFUINT32,
+..and so on until..
+    "DATA_SIZE":    2<<BF_POS | 2<<BF_LEN | BFUINT32,
+    "HIGH_PRIORITY":1<<BF_POS | 1<<BF_LEN | BFUINT32,
+    "EN":           0<<BF_POS | 1<<BF_LEN | BFUINT32
+}
+</code>
+The UINT32, BF_POS and BF_LEN entries may look strange, but they are just a way of encapsulating the data type, bit position & bit count into a single variable, and once that has been defined, you can easily read or write any element of the bitfield, e.g.
+<code python>
+# Set DMA data source to be ADC FIFO
+dma_chan.READ_ADDR_REG = ADC_FIFO_ADDR
+# Set transfer size as 16-bit words
+dma_chan.CTRL_TRIG.DATA_SIZE = 1
+</code>
+You may wonder why there are 2 definitions for one register: CTRL_TRIG and CTRL_TRIG_REG. Although it is useful to be able to manipulate individual bitfields (as in the above code) sometimes you need to write the whole register at one time, for example to clear all fields to zero:
+<code python>
+# Clear the CTRL_TRIG register
+dma_chan.CTRL_TRIG_REG = 0
+</code>
+An additional complication is that there are 12 DMA channels, so we need to define all 12, then select one of them to work on:
+<code python>
+DMA_CHAN_WIDTH  = 0x40
+DMA_CHAN_COUNT  = 12
+DMA_CHANS = [struct(DMA_BASE + n*DMA_CHAN_WIDTH, DMA_CHAN_REGS)
+    for n in range(0,DMA_CHAN_COUNT)]
+DMA_CHAN = 0
+dma_chan = DMA_CHANS[DMA_CHAN]
+</code>
+To add even more complication, the DMA controller also has a single block of registers that are not channel specific, e.g.
+<code python>
+DMA_REGS = {
+    "INTR":               0x400|UINT32,
+    "INTE0":              0x404|UINT32,
+    "INTF0":              0x408|UINT32,
+    "INTS0":              0x40c|UINT32,
+    "INTE1":              0x414|UINT32,
+..and so on until..
+    "FIFO_LEVELS":        0x440|UINT32,
+    "CHAN_ABORT":         0x444|UINT32
+}
+</code>
+So to cancel all DMA transactions on all channels:
+<code python>
+DMA_DEVICE = struct(DMA_BASE, DMA_REGS)
+dma = DMA_DEVICE
+dma.CHAN_ABORT = 0xffff
+</code>
+**Single ADC sample**
+MicroPython has a function for reading the ADC, but we’ll be using DMA to grab multiple samples very quickly, so this function can’t be used; we need to program the hardware from scratch. A useful first step is to check that we can produce sensible values for a single ADC sample. Firstly the I/O pin needs to be set as an analog input, using the uctype definitions. There are 3 analog input channels, numbered from 0 to 2:
+<code python>
+import rp_devices as devs
+ADC_CHAN = 0
+ADC_PIN  = 26 + ADC_CHAN
+adc = devs.ADC_DEVICE
+pin = devs.GPIO_PINS[ADC_PIN]
+pad = devs.PAD_PINS[ADC_PIN]
+pin.GPIO_CTRL_REG = devs.GPIO_FUNC_NULL
+pad.PAD_REG = 0
+</code>
+Then we clear down the control & status register, and the FIFO control & status register; this is only necessary if they have previously been programmed:
+<code python>
+adc.CS_REG = adc.FCS_REG = 0
+</code>
+Then enable the ADC, and select the channel to be converted:
+<code python>
+adc.CS.EN = 1
+adc.CS.AINSEL = ADC_CHAN
+</code>
+Now trigger the ADC for one capture cycle, and read the result:
+<code python>
+adc.CS.START_ONCE = 1
+print(adc.RESULT_REG)
+</code>
+These two lines can be repeated to get multiple samples.
+If the input pin is floating (not connected to anything) then the value returned is impossible to predict, but generally it seems to be around 50 to 80 units. The important point is that the value fluctuates between samples; if several samples have exactly the same value, then there is a problem.
+**Multiple ADC samples**
+Since MicroPython isn’t fast enough to handle the incoming data, I’m using DMA, so that the ADC values are copied directly into memory without any software intervention.
+However, we don’t always want the ADC to run at maximum speed (500k samples/sec) so need some way of triggering it to fetch the next sample after a programmable delay. The RP2040 designers have anticipated this requirement, and have equipped it with a programmable timer, driven from a 48 MHz clock. There is also a mechanism that allows the ADC to automatically sample 2 or 3 inputs in turn; refer to the RP2040 datasheet for details.
+Assuming the ADC has been set up as described above, the additional code is required. First we define the DMA channel, the number of samples, and the rate (samples per second).
+<code python>
+DMA_CHAN = 0
+NSAMPLES = 10
+RATE = 100000
+dma_chan = devs.DMA_CHANS[DMA_CHAN]
+dma = devs.DMA_DEVICE
+</code>
+We now have to enable the ADC FIFO, create a 16-bit buffer to hold the samples, and set the sample rate:
+<code python>
+adc.FCS.EN = adc.FCS.DREQ_EN = 1
+adc_buff = array.array('H', (0 for _ in range(NSAMPLES)))
+adc.DIV_REG = (48000000 // RATE - 1) << 8
+adc.FCS.THRESH = adc.FCS.OVER = adc.FCS.UNDER = 1
+</code>
+The DMA controller is configured with the source & destination addresses, and sample count:
+<code python>
+dma_chan.READ_ADDR_REG = devs.ADC_FIFO_ADDR
+dma_chan.WRITE_ADDR_REG = uctypes.addressof(adc_buff)
+dma_chan.TRANS_COUNT_REG = NSAMPLES
+</code>
+The DMA destination is set to auto-increment, with a data size of 16 bits; the data request comes from the ADC. Then DMA is enabled, waiting for the first request.
+<code python>
+dma_chan.CTRL_TRIG_REG = 0
+dma_chan.CTRL_TRIG.CHAIN_TO = DMA_CHAN
+dma_chan.CTRL_TRIG.INCR_WRITE = dma_chan.CTRL_TRIG.IRQ_QUIET = 1
+dma_chan.CTRL_TRIG.TREQ_SEL = devs.DREQ_ADC
+dma_chan.CTRL_TRIG.DATA_SIZE = 1
+dma_chan.CTRL_TRIG.EN = 1
+</code>
+Before starting the sampling, it is important to clear down the ADC FIFO, by reading out any existing samples – if this step is omitted, the data you get will be a mix of old & new, which can be very confusing.
+<code python>
+while adc.FCS.LEVEL:
+    x = adc.FIFO_REG
+</code>
+We can now set the START_MANY bit, and the ADC will start generating samples, which will be loaded into its FIFO, then transferred by DMA to the RAM buffer. Once the buffer is full (i.e. the DMA transfer count has been reached, and its BUSY bit is cleared) the DMA transfers will stop, but the ADC will keep trying to put samples in the FIFO until the START_MANY bit is cleared.
+<code python>
+adc.CS.START_MANY = 1
+while dma_chan.CTRL_TRIG.BUSY:
+    time.sleep_ms(10)
+adc.CS.START_MANY = 0
+dma_chan.CTRL_TRIG.EN = 0
+</code>
+We can now print the results, converted into a voltage reading:
+<code python>
+vals = [("%1.3f" % (val*3.3/4096)) for val in adc_buff]
+print(vals)
+</code>
+As with the single-value test, the displayed values should show some dithering; if the input is floating, you might see something like:
+['0.045', '0.045', '0.047', '0.046', '0.045', '0.046', '0.045', '0.046', '0.046', '0.041']
+**Running the code**
+If you are unfamiliar with the process of loading MicroPython onto the Pico, or loading files into the MicroPython filesystem, I suggest you read my previous post.
+The source files are available on [[https://github.com/jbentham/pico|Github here]]; you need to load the library file rp_devices.py onto the MicroPython filesystem, then run rp_adc_test.py; I normally run this using Thonny, as it simplifies the process of editing, running and debugging the code.
+In the next part I combine the ADC sampling and the network interface to create a networked oscilloscope with a browser interface.
+### Web display for Pi Pico oscilloscope
+参见原文：[[https://iosoft.blog/2021/11/10/oscilloscope-display-pi-pico/|Web display for Pi Pico oscilloscope]]
+### Creating real-time Web graphics with Python
+[[https://iosoft.blog/2019/02/26/python-graphics-svg/|Creating real-time Web graphics with Python]]