I am using Omron NJ50 with touch screen to Ethernet/IP communication protocol.
Class Object: 0x6d and 0xb8 that are not described in the packet capture discovery manual and Service:0x55 and 0x56 that are described in some bits
enter image description here
Is it clear what these Class objects and services mean?
I did a lot of research and looked through a lot of the official Omron documents
Packet capture is performed
Related
I am wishing to use the Sync FIFO interface of a FT232H on a custom board from python on a RaspberryPi. I would use PyFTDI, but PyFTDI doesn't implement the Sync FIFO interface mode. The constant for the Sync FIFO mode is defined in PyFTDI but never used. I plan on accessing Sync FIFO by using PyUSB directly with PyFTDI as a reference. However as PyFTDI doesn't ever use the Sync FIFO mode, I don't know what FTDI commands are used for the mode on the USB endpoints. The documentation I have been able to find from FTDI tell how to use the proprietary library as opposed to the low level command structure actually sent to the chip. I have done a bit of searching, but FTDI provides many documents and it is a bit of information overload.
Does anyone know where the documentation is which covers the low level command codes and arguments which are sent to the FTDI USB end points? I am assuming the authors of PyFTDI were referencing something besides wire sniffing.
According to their knowledge base FTDI provides an API document under an NDA for some circumstances.
In some circumstances, it may be desirable to develop a custom driver for an exotic operating system or an embedded system. In these circumstances, an API document may be obtained from FTDI under NDA to allow driver development for FTDI devices. To request a copy of the API document, please contact FTDI Support support1#ftdichip.com.
I am just curious about the LoRa technology and exploring about that I got stuck where LoRaWAN class (A, B and C) have been defined. My doubt is, if I want to design a LoRa Node with any LoRa enabled modules available in the market (By vendors like Ai-Thinker, Heltech, pycom etc) do I need to care about Class while programming the node for transmissions and receptions? Do they handled by the LoRa transceivers or we need to handle it by writing the code?
You should consider what LoRaWAN class you want to use for the applications you want to develop. These three classes all have different behaviour:
A: only accepts downlink messages in 2 timeslots after an uplink message. The other time the node is unavailable to the network.
B: does all the A functionality but also allows for receiving of downlink messages on set moments.
C: this class can always receive downlink messages. No waiting for a timeslot or uplink is needed to communicate with the node.
Different tranceivers/mcus need different levels of care.
If I take the example of the RN2483, this node handles all the LoRaWAN interactions internally, you only need to configure what you want. (AFAIK it doesn't support class B/C at the moment but plans are made to support it.)
If I take the CMWX1ZZABZ, this processor is programmed directly and you need to make sure the code works for the class you want to use (A/B/C). The CMWX1ZZABZ comes with a LoRaWAN stack but you need to make sure it actually works as needed, the RN2483 handles everything for you.
In Internet of things one of the important factor is battery life. That is, how long can a device be left in production without maintenance.
For a low power device the most important aspect is optimizing the usage of battery. For every communication device energy is required to transmit or receive data. Also if the MCU and the peripherals of a HW is always awake then the battery will get drained very fast.
Therefore to increase the device life and support various use cases there are theree device classes.
Explanation about each class is given here: https://www.thethingsnetwork.org/docs/lorawan/classes/
The answer to your real question ending with question marks are the below.
do I need to care about Class while programming the node for transmissions and receptions? Do they handled by the LoRa transceivers or we need to handle it by writing the code?
You usually don't need to care about the class when your application layer code is using the LoRaWAN protocol stack through its API.
However,
when you define what kind of application layer messages your application server and your end device exchange, you need to be aware of what the actual LoRaWAN Device Class is and you need to know what latency of downlink messages may have.
For example, if your device is operating in Class A mode, (that accepts downlink messages only as responses to uplink messages), you may write into your application code that the device sends regular heartbeat messages that allow the application server to send downlinks as a response to one of those heartbeats.
I want to build a microcontroller-based CAN node card that has interfaces like UART, SPI and I²C, to which connect different peripherals and interfaces, like say a EIA-485 counter or a SPI digital I/O expander. I'd like to define a profile for the card that's flexible enough to adapt to any possible configuration and include any device that can be connected to such node card. Since CANopen profiles seem to be pretty rigid, I researched CANopen virtual devices but that seems not the answer either.
Is there a standard for such functionality or I'm sailing unknown waters?
You are sailing unknown waters unless you consider a CANopen bootloader a possible solution. There is no existing device profile that fits your criteria. CANopen is remarkably flexible but arbitrary extensibility is beyond it.
You could export the registers of your microcontroller 1:1 through the object dictionary and issue interrupts through PDOs. It would certainly be a fun exercise if just a bit impractical.
From the CAN in Automation website:
CANopen generic I/O modules are standardized in the CiA 401 device
profile specification. The profile supports a granularity of 1-, 8-,
16-, and 32-bit for digital I/Os and a resolution of 1-, 2-, and
4-byte for analog I/Os.
However, it may be easier to implement a custom device, based on the general CiA 301 CANopen application layer and communication profile standard. You could implement a set of general purpose IOCTL functions using Manucturer objects (2000h to 5FFFh) and possibly use SDO Block Transfer to 'stream' data to specific OD objects representing connected device end points.
You will need to consider that, even with a bitrate of 1 Mbps at the physical layer, the CANopen protocol is never going to be able to keep up with a USB2 HS device when it comes to streaming data! Also bear in mind that if you use PDOs for 'real-time' exchange of OD values there will be a significant lag and that the time quantum for PDO exchange is in the order of 25 ms or greater.
The final consideration is what CANopen master are you going to use? If the product is to be commercially available then you will need to specify and document your EDS very carefully (maybe even providing an OPC or similar API).
Is it possible to read the bits directly off the physical ethernet connection interface from a standard computer ethernet interface?
e.g., suppose I want to use the ethernet jack of a laptop as a differential logic probe(using a standard ethernet cable). Could I just potentially write a driver to get at the bits or is there a limit to how low a driver can go?
Essentially does the physical layer just send the bit stream to the device driver or does it do any decoding which will effect the interpretation of the bits or cause the device to malfunction(such using a different encoding scheme).
I guess what it boils down to, is, can we use the ethernet port as any standard digital differential communications link by writing a suitable driver or are we limited to the the ieee spec(8b/10b, etc...).
To answer shortly, probably not.
Here are some of the reason why:
On a hardware link layer, there is actually no electrical connection between the computer and the ethernet cable, it is electrically isolated by small transformer and is current and not voltage driven signal, so this will be the first problem to overcome, as you would have to send a fairly precise current over two lines rather than a voltage on a single line.
Ethernet transformers
PHY Hardware Interface: Then the next step, is that this is simply not controlled by the CPU where your code is being executed but by an ethernet PHY Chip interface, and there you have no (easy) way of flashing and controlling it. Some different PHY chip allows you different level of access, but I doubt you would find any that would allow you direct control over the transmission interface and even if it did, it would have to be implemented into the driver which is as well unlikely.
Ethernet PHY Controller
Perhaps some other solutions
as the comments above, if you want to have direct IO control on a computer, the best solution is over a serial or parallel port, perhaps you can find ethernet to serial or usb to serial port and then play with that but this would be digital signals.
Another thing you may want to use is the microphone input, as this accepts analog signals and you can have direct control over it, though be careful not burning your computer. (I've seen some bank card magnetic band using that on cellphones).
You can use libpcap/WinPcap to do this. Nevertheless you are not completely free in the choise of what you write/read on the wire. e.g. preamble and SFD must stil be there. This is so fundamental (because of noise resistance), that typical hardware just does not support anything different.
If you want to control completely everything, go to embedded hardware, find a board that uses a PHY that can give you that information and a processor that is capable of handling the data rates.
I need to implement a CAN protocol which is used in Automobile Industry.I wanted to know if it is possible to get the CAN data packets through WiFi using NSNetService/NSNetServiceBrowser class. In Apple's Documentation, everytime they are about to describe about NSNetService/NSNetServiceBrowser
class they say "Bonjour network services" where Bonjour is a protocol implemented by apple itself.
So, I think of course it will detect those i.e Bonjour Data Packets.But now, I am not sure if it will do the same in case of CAN data packets.Hence my question is : Is CAN data packet compatible with NSNetService class so that I can use it directly? If not, is there a way to detect CAN data packets coming from a WiFi network?
Further I got a reply on Apple Developer Forum that if CAN data packets were wrapped up in some High Level Protocol like UDP then NSNetServiceBrowser class MIGHT read it. Now my question is if my CAN data packet was in UDP packet(lets say), is NSNetServiceBrowser class capable of detecting those data packets since NSNetServiceBrowser asks for input on service domain Name and service domain type?
Thanks in Advance.
iParag