0x00 | Infosec x86 x64 | Machine Learning library

Started to develop a wiresless 'cable' solution (with websockets) between two ESPs, a wireless serial 'cable' between computer and a serial device to mimick a direct wired connection. Was working great however just accidentally fried one of the ESPs (short a serial cable connection to higher voltage - sigh) when testing. Replaced one of the ESP32s with an ESP8266. Suspect this should work however it did not.

The problem is the ESP8266 (client) cannot find the network of the ESP32 (server). Why it doesn't work? My computer can see the server and can connect. Fried ESP32 the same, no problem.

Tried the WiFiScan demo on the ESP8266 and can detect all other WiFi SSIDs/MACs in neighborhood however cannot detect the ESP32 server it's SSID/MAC.

Why it doesn't work? What is the difference and how can I solve this?

ESP32 - code of the server

I have a microcontroller which I communicate with my windows pc, through FT232RL. On the computer side, I am making a C-library to send and receive data, using windows API.

I have managed to:

1. Receive data (or multiple receives),
2. Transmit data (or multiple transmits),
3. First transmit (or multiple transmits) and then receive data (or multiple receives)

But I have not managed to:

1. Transmit Data and then receive.

If I receive anything, and then try to transmit, I get error. So, I guess when I receive data, there is a change in configuration of the HANDLE hComm, which I cannot find.

So the question is, what changes to my HANDLE hComm configuration when I receive data, which does not allow me to transmit after that?

Here is my code/functions and the main() that give me the error. If I run this, I get this "error 6" -screenshot of the error down below-:

I am using a 3.5: TFT LCD display with an Arduino Uno and the library from the manufacturer, the KeDei TFT library. The library came with a bitmap font table that is huge for the small amount of memory of an Arduino Uno so I've been looking for alternatives.

What I am running into is that there doesn't seem to be a standard representation and some of the bitmap font tables I've found work fine and others display as strange doodles and marks or they display upside down or they display with letters flipped. After writing a simple application to display some of the characters, I finally realized that different bitmaps use different character orientations.

What are the rules or standards or expected representations for the bit data for bitmap fonts? Why do there seem to be several different text character orientations used with bitmap fonts?

Are these due to different target devices such as a Windows display driver or a Linux display driver versus a bare metal Arduino TFT LCD display driver?

What is the criteria used to determine a particular bitmap font representation as a series of unsigned char values? Are different types of raster devices such as a TFT LCD display and its controller have a different sequence of bits when drawing on the display surface by setting pixel colors?

What other possible bitmap font representations requiring a transformation which my version of the library currently doesn't offer, are there?

Is there some method other than the approach I'm using to determine what transformation is needed? I currently plug the bitmap font table into a test program and print out a set of characters to see how it looks and then fine tune the transformation by testing with the Arduino and the TFT LCD screen.

The KeDei TFT library came with an a bitmap font table that was defined as

I am learning how to control P10 Led matrix 64x32 with NodeModule MCU ESP8266, I google and found this library https://github.com/2dom/PxMatrix and this tutorial https://www.instructables.com/RGB-LED-Matrix-With-an-ESP8266/. I believed that I wire between P10 and ESP8266 in true way in the tutorial, but that P10 led does not display as the example:

The true result will be:

This is my wire diagram:

This is my code:

I have a

ITU T.81 states the following:

B.1.1.2 Markers Markers serve to identify the various structural parts of the compressed data formats. Most markers start marker segments containing a related group of parameters; some markers stand alone. All markers are assigned two-byte codes: an X’FF’ byte followed by a byte which is not equal to 0 or X’FF’ (see Table B.1). Any marker may optionally be preceded by any number of fill bytes, which are bytes assigned code X’FF’. NOTE – Because of this special code-assignment structure, markers make it possible for a decoder to parse the compressed data and locate its various parts without having to decode other segments of image data. "

B.1.1.5 Entropy-coded data segments An entropy-coded data segment contains the output of an entropy-coding procedure. It consists of an integer number of bytes, whether the entropy-coding procedure used is Huffman or arithmetic.

NOTES

(1) Making entropy-coded segments an integer number of bytes is performed as follows: for Huffman coding, 1-bits are used, if necessary, to pad the end of the compressed data to complete the final byte of a segment. For arithmetic coding, byte alignment is performed in the procedure which terminates the entropy-coded segment (see D.1.8).

(2) In order to ensure that a marker does not occur within an entropy-coded segment, any X’FF’ byte generated by either a Huffman or arithmetic encoder, or an X’FF’ byte that was generated by the padding of 1-bits described in NOTE 1 above, is followed by a “stuffed” zero byte (see D.1.6 and F.1.2.3).

And in many other places where well known Stuff_0() function is also named.

Not sure where standard ITU T.87 stands in regard to the encoding escape sequence 0xFF 0x00 specified by standard ITU T.81:

• Standard ITU T.87 it self that do not specify this but expects it. Where Standard test samples are incorrectly formed, clearly do not have encoding escape sequence 0xFF 0x00 in encoded streams. For example 0xFF 0x7F, 0xFF 0x2F, and other sequences can be found in encoded streams of .jsl test samples : namelly "T8C0E3.JLS". And no one saw it all these years;
• Or if Standard ITU T.87 actually overrides the ITU T.81 regarding this rule for encoded streams and doesn't allow encoding of escape sequence;

In decoder we could make logic to detect decoder errors when 0xFF and !0x00 is to actually use that byte and not skip it if component is not fully decoded. But what if jls file do not have escape sequence and we encounter 0xFF 0x00 sequence should we skip 0x00 byte or not?

Would like some clarification on subject of standard ITU T.87 JPEG-LS encoding, and what is the correct procedure. Should we, or shouldn't we, encode escape sequnce 0xFF 0x00 in encoded streams?

I have a procedure which reads a register from a specified address: "rd_addr $jtag_master 0x00"

I'd like to remove the "$jtag_master" input, and instead use a global variable declared at the beginning of the script, which I can then use in other procedures. The initial declaration is currently implemented through use of another procedure, "set_dev".

In TTN they are no longer supporting large decoders.

I know what the decoder needs to be in TTN, it is in my DECODER function, but dont know how to execute it in the function node.

If you use inject Payload [1,2,3] RAW, it injects the raw payload that is msg.payload.payload.uplink_message.frm_payload into the decoder.

The DECODER needs to decode the raw payload and output it in msg.payload.uplink_message.decoded_payload

If you use inject Payload [1,2,3] Decoded in the flow you see how the end result needs to look like and the decoded msg.payload.uplink_message.decoded_payload

I am still learning JavaScript.

The code in the function node

I am implementing a MQTT communication. I want to send CAN frames over MQTT through a graphical interfaces (realized in python). I am able to send messages from the GUI to one topic and I am able to see messages arrived on the same topic (using paho library) when I use the board. The function is below and the topic is diagnostic_request/topic: