Aesthetically, my favorite architecture in many was is the 14-bit series. The 16-bit PIC18Fxx architecture improves some things, but I find somehow the design less aesthetically pleasing. Which architecture you'll like better probably depends upon your design aesthetic, the extent to which your find yourself wishing things were designed differently, and the extent to which such wishing detracts from your enjoyment working with them.
From a design perspective, there's no particular reason why code addresses and data addresses need to be the same. One thing I like about the 14-bit PICs is that adding a number to an instruction address advances by that many instructions. By contrast, on the PIC18X, each instruction takes two addresses. Consequently, computed jumps using an 8-bit selector are confined to a range of 128 instructions rather than 256. It's a small detail, but having a program counter whose lowest bit is non-functional seems unaesthetic.
Also, the PIC18xx parts add a single-cycle hardware multiply, but unfortunately since it requires one operand to be in W but puts the results in a fixed pair of other registers, it can't be used very effectively for multi-precision operations. If I had my druthers, there would be two types of multiply instructions:
- Simple multiply -- Store W into multiplier register, and store op*W into PRODH:W
- Multply-add --Store PRODH+op*multiplier register into PRODH:W
With such a pattern, a 16x16 operation would be rendered as:
movf OP1L,W
mul OP2L
movwf RESULT0
mula OP2H
movff OP2L,MULTR
mula OP2L
movwf RESULT1
mula OP2H
muvwf RESULT2
movff PRODH,RESULT3
Further, arbitrary-length multiplies could be done with an average cost of a little over two cycles per 8x8 partial product, using the repeated pattern:
mula POSTINC0,c
addwfc POSTINC1,f,c
That pattern would multiply one multi-byte number times an 8-bit value and add the result to another multi-byte number.
As it is, I think the best one can do for an extended multiply is to do the multiply to a destination buffer without doing a built-in add, at a cost of six cycles per 8x8 partial product, and then spend another two-cycles per partial product adding that result to the previous 8xN partial result.
movf multiplier,w
mulwf POSTINC0,c
movf PRODL,w,c
addwfc POSTINC1,w
movff PRODH,INDF1
Four times as long as what could be achieved with a slightly different instruction set. I don't know that I've seen any processor which included a function to compute PRODH+Op1*Op2 but it would be a very simple feature to include in shifter-based multiplies, and it facilitates computing arbitrary product widths with fixed hardware cost. Actually, since the PIC takes four hardware clocks per instruction, the hardware required to allow a 16xN or 32xN multiply would be pretty modest; when computing big products, a 16xN or 32xN multiply with suitable register usage would offer a 2x or 4x speedup.
Most differential RX circuits by their nature require that the amplifiers have CMFB (Common Mode Feedback) indeed, differential amplifiers are mostly useless w/o this. So the chip automatically compensates for this itself. Some chips will have the CMFB pin available for monitoring or external capacitance but that is not strictly necessary. Of course on startup and plug/ un-plug situation this is disturbed, which can mean that the signals hit against the ESD rails. But the higher level protocols of re-transmit deal with this situation.
Additionally, one some advanced differential signalling situations, there is active equalization upon startup, so this packet corruption at this level is understood and handled in this case.
Best Answer
You can certainly use such devices. They are usually a poor choice for anything that has lower power usage requirements as they have high leakage current.
You also have to be careful of the clamping voltage, ESD of ~200V can damage a micro-controller, the device you linked is specced at 500V max. Make sure whatever your trying to protect is actually be protected to the extent it needs.
For digital lines also pay attention to the capacitance of these device/package, they can screw up your signal integrity.
What I usually do if the input is likely to get hit with ESD, like an input that is often connected in the field is use a 2 pronged approach.
First Use a ESD device, or diodes closer to the circuit to protect, which type I would use depends on the signal/circuit in question. This is to protect against lower spikes, say 8kV. More and more you see this type of protection inside devices, especially boundary devices like RS232 drives and line drivers.
Second, when you build the PCB use spark gaps, which is really nothing more than putting 2 pads on the surface of the PCB, 1 being the signal, the other being a good ground and spacing them very close to each other, like 6 thou apart. This will protect against higher voltage hits, like 25kV. Pretty simple concept, the high voltage jumps the gap and goes straight to ground. Just be careful how you place these, as close to the connector as possible with the best possible ground connection.
Also pay attention to the manufacturing process your using, you don't want solder to accidental bridge the gap.
Gaps can be tough to do on digital traces and avoid changing the impedance, usually requires tweaking the signal termination after the prototype run.
There is some argument over the proper shape of the pad, some use half moons, some use pointed triangles with the tips near each other and some use square pads. I've always used square pads, the more area that is close to the other pad the more repeated strikes the gap will survive. The trade off is that the square pads will take the most effort to ensure there is no solder bridging. Best answer is to get your CM to not apply solder to these pads at all, but that can require special effort on their part.