Ethernet | Ethernet Library for Arduino

I found the solution and now Kubuntu starts up normally as expected.

First, I purged all drivers and libraries

The simple fix for this issue is to replace rect by fillRect and remove the subsequent fill. rect adds a rectangle onto the current subpath, whereas fillRect is a self-contained operation that creates its own path and fills it.

This is also explained in HTML5 Canvas - fillRect() vs rect().

Now, why do your ports look the way they do? The code actually always leaves the last port correctly filled in — this is always true, even in the middle of program execution, at the end of any iteration. But as soon as the next green rectangle is filled in, the previous port also gets filled green. The reason is: they’re part of the same path!

The following table and graphic are a few prerequisites to understanding path creation in the Canvas API.

You can group some of the methods you used into two categories: those that pertain to the entire current path, and those that pertain to the current subpath. A path can be comprised of multiple subpaths. Let’s see how they relate to one another:

This graphic should summarize all these actions:

rect, like its related methods, adds to the current subpath.

The distinction between (entire) path and subpath is important, but easily missed: beginPath creates an entirely new path, and moveTo creates a subpath, but fill fills entire paths. Furthermore, what is filled once, stays filled. This is like paint: when you paint the canvas once, and are told to fill an overlapping region, you’ll have to paint over your older paint.

This helps explain why these black outlines exist: your port shapes are filled black, but then the same shape — plus a rectangle — are filled green; the green overlays the black. Note that division by 6 doesn’t always result in an integer, so each fill has some transparency towards the edge. That’s why the green doesn’t completely cover the black at the edges.

It is important to note that closePath is not the “opposite” of beginPath. closePath only closes and opens subpaths; it does not change what the current path is as beginPath does. This is further complicated by the fact that beginPath and closePath are sometimes optional: for instance, a moveTo is only supposed to create a subpath, but if it’s called at the very beginning, when no path exists, a path is automatically created as well, making a beginPath before moveTo redundant.

Let’s go through the script step by step, by considering two iterations one after the other:

1. First iteration
   1. ctx.fillStyle = "green"; sets the fill color for the next fill call to "green".
   2. ctx.rect(x, y, portWidth, portWidth); requires a subpath to exist. Since no paths exist at the beginning, a new path is automatically created, and a subpath is created as part of it. Then, a rectangle is added to the current subpath.
   3. ctx.fill(); fills the interior of the entire current path (i.e. all of its subpaths: the rectangle) green.
   4. ctx.fillStyle = "black"; sets the fill color for the next fill call to "black".
   5. ctx.beginPath(); discards the previous path and creates a new path. This is now the current path, and the previous rectangle path is no longer accessible.
   6. ctx.moveTo(x + portSixth, y + 2 * portSixth); creates a new subpath with the specified position as its first vertex.
   7. The seven ctx.lineTo(…); calls add vertices to the current subpath.
   8. ctx.closePath(); is like a lineTo back to the start of the current subpath; the subpath is closed and a new subpath is created.
   9. ctx.fill(); fills the interior of the entire current path (i.e. all of its subpaths: the port shape) black.
2. Second iteration (Steps 1 and 4 are no different than in the first iteration)
   1. (ctx.fillStyle = "green";)
   2. ctx.rect(x, y, portWidth, portWidth); adds a rectangle to the current subpath, which already exists: it starts at the end of the port shape of the previous iteration.
   3. ctx.fill(); fills the interior of the entire current path (i.e. each subpath: the rectangle plus the port shape of the previous iteration) green.
   4. (ctx.fillStyle = "black";)
   5. ctx.beginPath(); discards the previous path and creates a new path. Now the rectangle plus port shape are no longer accessible.
   6. Etc.

The second iteration is where the bug happens. In its third step, fill fills a path that has been opened in the previous iteration using beginPath.

As you found out, you can fix it without fillRect, by simply placing ctx.beginPath(); before ctx.rect(); — or, equivalently, at the start of the iteration. Now you should understand why.

¹: The phrase “ensure there is a subpath” has its own algorithm steps: “When the user agent is to ‘ensure there is a subpath’ for a coordinate (x, y) on a path, the user agent must check to see if the path has its ‘need new subpath’ flag set. If it does, then the user agent must create a new subpath with the point (x, y) as its first (and only) point, as if the moveTo method had been called, and must then unset the path’s ‘need new subpath’ flag.”.

²: fill does indeed accept a specific Path2D as an argument. Without an argument, it fills the current path of the provided rendering context.

Apparently you are trying to create a tunnel. Instead of trying to hijack an existing interface, the proper way to create a tunnel is to create a new interface, using a kernel module or TUN/TAP. However, tunnels are normally intended to receive traffic generated on the machine which runs the tunnel software, or at least routed through it. That means you will also have to set up the kernel to route the traffic to your tunnel.

You can create a new interface as a TUN/TAP interface. It is like a virtual ethernet driver except you don't need to write a new kernel module. It is designed for tunnels (hence the name).

The difference between TUN and TAP is that a TUN interface is an IP interface that receives IP packets from the kernel's IP routing system, and a TAP interface receives Ethernet packets (which may contain IP packets) so it can alternatively be part of a bridge (a virtual Ethernet switch - which only looks at the Ethernet header, not the IP header).

I think for your scenario, you will find it easiest to create a TAP interface, then create a bridge (virtual Ethernet switch) between the TAP interface, and the interface which the other host is connected to. Neither one needs an IP address - the kernel will happily pass Ethernet-layer traffic without attempting to process the IP information in the packet. Your tunnel software can then emulate a host - or tunnel to an actual host - or whatever you want it to do.

Or in visual form:

If you want the host to also be able to talk to the machine running the tunnel software - without going through the tunnel software - then you may choose to put an IP address on the bridge.

finally found a workaround: running

Ugh! Found it.

It looks like echo adds a trailing newline to the string, whereas printf does NOT, and this trailing newline character is interfering with the device's ability to parse the command. If I forcefully add it (a newline char, \n) to the end of the printf cmd, then it fails too--meaning the device will not respond to the command as expected:

244.244.244.1 is not a valid multicast address.

Multicast address are in the range of 224.0.0.1 - 239.255.255.255. The address you're sending to is not in that range. So the outgoing MAC address is not a multicast MAC.

Change the destination IP to be in the range of multicast IP addresses and you'll see a proper multicast MAC address.

For the first database schema, you need a pipeline that will first filter the translation array using the $filter operator. This will return an array with just the document that satisfies the filtering condition. So the expression:

If the keys are not unique create a list. For example, there are two keys with the same name ASR1001-X

What you need is to hold onto the state in some Listenable, such as ValueNotifier and use ValueListenableBuilder to build your ListView. I put together this demo to show you what I mean: