All memory cells have their level, either 0
or 1
. The CPU tells the memory device which cells it needs the binary values of, and supplies this address to the memory device. Inside the memory device the address is decoded in a row and column address, and the cell at that position in the matrix is allowed to gets its data to the databus, i.e. the data pin.
Let's say we have an 8-bit address 01100101
. This will be split up in a row address 0110
(the high order nibble) and a column address 0101
(the low order nibble). The row address selects row #06, so all cells connected to this row will have their data ready. The column address selects the cell at column #05 of this row, so that finally only one single cell is allowed to place its data to the output pin.
Storing data follows the same pattern: only one row is selected, and the cell at the given column in that row will get the data present on the pin stored.
This is for 1 bit. The operation occurs for the full data word width simultaneously, so if you have a byte-wide memory, 8 bits are retrieved and their value placed on 8 databus pins.
edit
This picture should help you seeing things better:
This is a representation of a DRAM array, where data is stored in the charge of the capacitors, each capacitor is one bit. The row part of the address (here A1..A0) selects a row, which means they activate all FETs on that row, so that the levels of the capacitors for that row become available on their corresponding column. Then the column address selection block, controlled by the other part of the address, A3..A2, selects the one bit which we want the data from.
DRAM is easy to build, but has a nasty disadvantage: reading the data discharges the capacitor, so the data is lost. To counter this DRAM has sense amplifiers, which detect the current memory cell status and refresh it when read. In addition this refresh has to be done periodically because the capacitors' charge will leak away even when the memory isn't read. The need for refresh circuitry is easily compensated for thanks to the DRAM's cells' compactness.
SRAM uses a couple of transistors to store the data, and it isn't volatile in the way DRAM is (though the data is still gone when you switch the power off). With EEPROM and Flash the data is stored in the (insulated) floating gate of a FET, and therefore it won't lose its data when power is switched off.
Further reading:
This answer about data retention in Flash memory.
A oscilloscope plots voltage as a function of time, so your display is reasonable as you show it. However, the term "time base" is meaningless to indicate the X axis scale. What you want is "s/div" (or ms/div or µs/div). This is independent of the sample rate, although there is little point using more than a few pixels per sample.
The sample times you mention are very slow for ordinary oscilloscopes. Some signals will be reasonably visible at those rates, but most things you encounter will not be.
I would probably figure out what the fastest sample rate is that you can support, then always sample at that rate. If the application indicates it does not need samples that fast, then you can merge multiple samples into one before sending over the network. In that case you don't want to do traditional decimation, which seeks to eliminate frequencies that alias. Instead, for each data point send the min and max A/D samples covered by that data point. Each data point should then be shown to vertically cover that min/max range. If the user selects a slow sample rate and a faster signal is being sampled but it is still within the capability of the A/D and the underlying fast sample rate, then the display will be a horizontal bar with vertical width showing the signal peaks. That is a much better display than something that aliases.
Best Answer
You can't sample continuously.
However, this isn't too much of an issue usually with scopes as most don't do this (at least at the higher speeds) Even an analogue scope does not display continuous information as you have the beam sweep back period.
A typical digital storage scope waits for a trigger, fills it's buffer at high speed, then sends the data at a lower speed to the microcontroller (or android in your case) for display. As Photon mentions, this happens fast enough (e.g. above 15 frames of data a second) for it to look continuous to the user.
Obviously the larger RAM buffer, the more samples(time) can be captured. This is why you will see DSOs advertising large capture buffers. At high speed this can make a big difference - at 2 Gigasamples per second and a 10KB capture buffer you are only going to get 5us of information. Some with larger buffers can only use part of it at the highest speed - for instance my DSO has 10MB of buffer up to 1 Gsps, but can only use 10KB at 2Gsps.
In your case you could switch to continuous capture at speeds the USB is capable of (e.g. < 1 Msps) You could maybe look at using compression also.
Either that or look at using high/super speed USB.