The mbed can handle it but you do have to structure the code well. Use something like MODSERIAL to buffer the serial port. Have the incoming data handled by an interrupt and put into a buffer with minimal processing and then the main loop of the code reads from the buffer, does any processing needed and sends it out on the serial.
PC speed up serial
I want to align 90 EM-serial sections (each measuring about 10 000 x 10 000) using Fiji/ TrakEM2. I already aligned other datasets with similar dimensions using a combination of least square alignment (first rigid, then affine) and elastic alignment (resolution 80, test maximally 10 layers). The result was really nice.
Can someone recommend an improved workflow to speed up the process and still have a nice alignment?I already tried a ramdisk (only with my slow PC), but there was no big difference to the HDD. On my workstation, I use windows 10, 128 GB RAM, 16 fast Xeon Cores.Is it possible, that black edges on the individual images slow down the process?
Intuitively, you would think that parallel data transmission should be faster than serial data transmission; in parallel you are transferring many bits at the same time, whereas in serial you are doing one bit at a time.
Serial transmission is slower than parallel transmission given the same signal frequency. With a parallel transmission you can transfer one word per cycle (e.g. 1 byte = 8 bits) but with a serial transmission only a fraction of it (e.g. 1 bit).
By sending in serial you no longer need to worry about all of the lines stabilizing, just one line. And it is more cost efficient to make one line stabilize 10 times faster than to add 10 lines at the same speed.
Some things like PCI Express do the best of both worlds, they do a parallel set of serial connections (the 16x port on your motherboard has 16 serial connections). By doing that each line does not need to be in perfect sync with the other lines, just as long as the controller at the other end can reorder the "packets" of data as they come in using the correct order.
The most pronounced challenge introduced by parallelism is "crosstalk": when signal current starts or stops, it momentarily induces a small current on the wires next to it. The faster the signal, the more often this happens, and the more difficult it gets to filter out. Parallel IDE attempted to minimize this problem by doubling the amount of wires in the ribbon cable, and connecting every other wire to ground. But that solution only gets you so far. Long cables, folds and loops, and proximity to other ribbon cables all make this an unreliable solution for very high-speed signals.
Serial data transmission isn't faster than parallel. It's more convenient and so development has gone into making fast external serial interfacing between equipment units. Nobody wants to deal with ribbon cables that have 50 or more conductors.
Parallel was the obvious way to increase speed when logic gates were slow enough that you could use similar electrical techniques for buses/cables and on-chip transmission. If you're already toggling the wire as fast as your transistor allows, so the only way to scale is using more wires.
With time, Moore's law outpaced the electromagnetic constrains so transmissions over cables, or even on-board buses, became a bottleneck compared to on-chip speeds. OTOH, the speed disparity allows sophisticated processing at the ends to use the channel more effectively.
At higher speeds you have multiple bits in flight at any given moment along the wire => you need to use pipelined protocols (which is why Intel's FSB protocols became frightfully complicated; I think packetized protocols like PCIe were a reaction to this complexity).
Induced noise, aka crosstalk, goes up with frequency. The single biggest advance in speeds came from adoption of differential signalling which dramatically reduced crosstalk (mathematically, an unbalanced charge's field goes down as R^2, but a dipole's field goes down as R^3).
The solution was to have tunable delays at every receiver, and tune them at startup and/or continually from the data itself. Encoding the data to avoid streaks of 0s or 1s incurs a small overhead but has electric benefits (avoids DC drift, controls spectrum) and most importantly allows dropping the clock wire(s) altogether (which isn't a big deal on top of 40 signals but is a huge deal for a serial cable to have 1 or 2 pairs instead of 2 or 3).
Most of the above techniques became indispensable for both parallel and serial transmission. It's just that the longer the wires, the more attractive it becomes to push higher rates through fewer wires.
where t(1) is the computational time for running the software using one processor, and t(N) is the computational time running the same software with N processors. Ideally, we would like software to have a linear speedup that is equal to the number of processors (speedup = N), as that would mean that every processor would be contributing 100% of its computational power. Unfortunately, this is a very challenging goal for real world applications to attain.
Applications can generally be divided into strong scaling and weak scaling applications. Please note that the terms strong and weak themselves do not give any information whatsoever on how well an application actually scales. We restate the definitions mentioned in Scaling tests of both strong/weak scaling and elaborate more details for calculating the efficiency and speedup for them below.
In case of strong scaling, the number of processors is increased while the problem size remains constant. This also results in a reduced workload per processor. Strong scaling is mostly used for long-running CPU-bound applications to find a setup which results in a reasonable runtime with moderate resource costs. The individual workload must be kept high enough to keep all processors fully occupied. The speedup achieved by increasing the number of processes usually decreases more or less continuously.
If the amount of time needed to complete a serial task t(1), and the amount of time to complete the same unit of work with N processing elements (parallel task) is t(N), than Speedup is given as:
Note:In table below T(1) is the time needed to complete a serial task t(1) (here it is 1 processor).T(Np) is the amount of time to complete the same unit of work with Np processing elements (parallel task) (here it is Np no of different processors).N1 is no of processors needed to complete a serial task (here it is 1 processor).Np is no of processors needed to complete a parallel task.
2) For real speedup the speedup after 4 nodes gets worse. Because of increasing data traffic between the compute nodes, adding another node can be a disadvantage and will even slow down the application. It can also be so said that the compute time also cannot be reduced further as the problem size cannot be further divided to improve it for a effective reduction in time for data traffic and I/O.
Note:In table below T(1) is the time needed to complete a serial task t(1) (here it is 1 processor).T(Np) is the amount of time to complete the same unit of work with Np processing elements (parallel task) (here it is Np no of different processors).
The Raspberry Pi serial port consists of two signals (a 'transmit' signal, TxD and a 'receive' signal RxD) made available on the GPIO header. To connect to another serial device, you connect the 'transmit' of one to the 'receive' of the other, and vice versa. You will also need to connect the Ground pins of the two devices together.
The Broadcom chip at the heart of the Raspberry Pi has low power serial ports with limitations of voltage and protocol compatibility. The ports use 0V and 3.3 V logic levels, not 0 & +5V TTL levels or the +/-12 V used by RS-232 serial ports found on some older PCs. If you wish to connect one of these, you need a board or adapter to convert the signal levels. See this tutorial for one example on how to build a 3.3 V to RS-232 level converter with a breadboard, a MAX3232CPE IC and five 0.1 µF capacitors. If your Raspberry Pi has bluetooth/wireless capability, then the on-chip UART connected to the header pins is the less capable mini-UART with no break detection, no framing errors detection, no parity bit, no receive timeout interrupt and no DCD, DSR, DTR or RI signals (See RPi UART info for more details.)
If you wish to connect your Raspberry Pi to a PC with a USB port, the simplest option is to use a USB-to-serial cable which uses 3.3 V logic levels (e.g. the Adafruit 954 cable, the FTDI TTL-232R-RPI cable, or the Debug Buddy ultimate serial port). These can be simply plugged in directly to the GPIO header (see illustration).
If you wish to connect to a peripheral which has 0/5 V signals, you should ideally have a circuit to convert between the voltage levels. See this tutorial for an example using a ready-made level shifter module. Other circuits for level shifting are shown at RPi_GPIO_Interface_Circuits#Level_Shifters. The Debug Buddy ultimate serial port can also be configured for 0/5 V signals.
You can connect the Raspberry Pi to a PC using a USB-serial cable, or (if it has an RS-232 port) a level-converter circuit - see above for details. When this is done, you will need to set up a terminal emulator program on your PC as described below.
The easiest way to set up a network connection between your Raspberry Pi and another computer is with an Ethernet cable. If this is not possible, as is the case for the Raspberry Pi Model A, you can set up a connection over the serial cable. This uses the Point-to-point Protocol (PPP). A network connection running over a serial cable can be very useful for copying files onto the Raspberry Pi.
replacing /dev/tty.usbserial-FTGCC2MV with the name of your serial port. In the above line, 115200 is the baud rate of the connection, 10.0.0.1 is the local internet protocol (IP) address, the address you want your computer to have. 10.0.0.2 is the remote IP address, it is the address that the Raspberry Pi will have. 2ff7e9595c
Comments