Friday, August 28, 2015

Esp8266 Esp-13 to DIP Adaptor

UPDATE:
Added Links and Details

I recently received my homebrew Esp8266 Esp-13 to DIP Adaptors from OSHPark.com. With only a little sanding of the edges they were ready to assemble.

I made the adaptor available as a free "shared project" on OSHPark.com site. They are inexpensive at $4.20 for a set of three. Note: I suggest you order 9 or 12 (or more) to make the free shipping more tolerable for the good folks a OSHPark.

Let me know if you find this adaptor board useful.

The Adaptor and Parts
Soldering the two Castellated Edge Connections was much easier than I thought, with a little rosin on each edge, solder wicked into half-round-holes to form a nice solder bridges between the two boards.

SMT Headers Installed
The SMT Headers were easily soldered on the back. They are inexpensive and available on ebay, for example: here.

Ready to Use
The results can be plugged into a Solder-Less Protoboard, or into a 18 Pin DIP socket. For production, this adaptor would not be appropriate, but for experiments and prototypes, it works great.

Inserted into a Solder-Less Protoboard
The Esp8266 Esp-13 has 4M Bytes of Flash, compared to 512K Bytes on the typical lower numbered modules. Esp-13's are available from several suppliers on ebay. for example: here.

Note: Currently, Esp-13 information is a little sparse on the Internet.

Esp8266 Esp-13 Face Plate
(18 x 20mm)
Esp8266 Esp-13 Pinouts


UPDATE:

An another Esp-13 Resource link


-- Home Page: https://WA0UWH.blogspot.com

Friday, August 21, 2015

More Esp8266 Web Server Farm

I have my Experimental Esp8266 Web Server Farm up and running (see photo on original post), for your continued review, it is even faster, and will support many more browse connections.

With "AutoUpdate" set to 60 seconds, I have had as many as 25 browser tabs connected to one of my Esp servers. It normally eventually fails, that is, when more than 4 connections are requesting updates simultaneously. But it was fun to watch the mayhem. Sometimes the ESP even recovers on its own.

I have now included a "Visitor Map", so I can see where connections are coming from, see below.

There are three Esp8266's in this "farm", all using the identical source code. And because of that; the displayed Visitor Map will appear Identical on each, that is because they all contain the same "map registration key" which is used by http://www.revolvermaps.com.

As indicated on a previous post, access to my farm is via a generic IPA:Port connection, which is: http://dc02.ebcon.com:8160, which I had previously changed in my router as necessary to externally connect to a particular Esp (local IPA:80).

For the other devices in my Esp Farm (and bench), use PORT: 8162, 8168, 8169 and/or 8172 (note: one of these will also be also connected to the generic 8160 port). Note: one or more may not be working at any point in time, try one of the others.

With only my local tests and a little WIFI activity, so far the small and simple power supply has survived, and actually worked well. I may need to add "more power" with more concurrent user accesses.

An Interesting Idea: If other Esp Programmers with similar Experimental Public Accessible Esp Servers include the same "map registration key" (a short line line of Html code) we could create a "pseudo reverse beacon" that would display to the "world" our intense shared interest in the Esp. On each configured Esp Web Servers, the "Visitor Map" will display all web connections to our "Esp Web Collective". How fun is that!!??

Let me know if you are interested, I will share details (or you can extract the keys from my Esp web Home Page source list).

It's all fun, . . . with the ESP's !!! :-)

For more Esp8266 information on this blog use this Search.


-- Home Page: https://WA0UWH.blogspot.com

Wednesday, August 19, 2015

My WIFI Transfer Improvement - 160 Times

UPDATE: Aug 25, 2015

I was using an older revision of the Arduino IDE (old 1.6.4) and an old set of Exp Extensions.

With current IDE 1.6.5 and current Esp Ext's the "server.send()", "server.sendContent()", and "server.client().print()" functions all have about the same performance - fast.

The moral of the story, make sure your environment is up-to-date.



I use, and like, the Arduino IDE for ESP8266 software development and have used the "example code" for my initial efforts, but now, my interest expand beyond trivial examples.

My Experimental Web Server Farm
Above is My Experimental Web Server Farm :-)  (a little under powered, but it works)

Like many of the published ESP examples, I used a form of "server.send()" to transfer data via WIFI, but then I found "that" function is somewhat limited (or at least the way I understand it) and therefore I explored the available documentation and source code for other capabilities.

I found "server.sendContent()" which appeared more flexible and more to my desires for a transfer function. I have used "it" for several months for building my apps. My typical transfers are about 5K to 15K bytes, but can be as large as 100K bytes.

My dynamically created WEB Pages typically take about "6.5 seconds" to transfer to a browser, for a small device like the ESP's, I thought that was a little slow, but still usable.

Actually, for my application, I started considering abandoning the ESP's, due to lack of WIFI transfer speed.

BUT THEN, in some obscure recesses of some online web page, I found the "server.client().print()" function - A BIG SPEED IMPROVEMENT. Now the same dynamic WEB Page transfers in only "0.043 seconds" !!!!

For my application, that is a BIG speed improvement of 160 times faster. From my perspective, the little ESP is now a WIFI "screamer" !!

I really like it, . . . when something WORKS !!

This note is published here in hope that someone else finds this information useful. If previously known, it would have save me a lot of time and anguish.

I only wished I understood or knew this earlier, but then I am still learning the ESP (there is much to know). I am sure there are other ESP improvements or coding strategies that I have yet to discover. I plan to publish my "example" application code for others to review, use, and/or abuse.

For your review, my experimental ESP Web Server is (sometimes) running at:



-- Home Page: https://WA0UWH.blogspot.com

Thursday, August 13, 2015

DipTrace 2.9 Beta

DipTrace has just made available Update 2.9 Beta, which includes several new capabilities or functions. The most interesting/useful to me is "Configurable HotKeys".

I have assigned:
  •       "]" to Object -> "Update All Copper Pours"
  • "Ctl-]" to Object -> "Unpour All Copper Pours"

During the last stages of a PCB edit, my productivity will now jump 1000%.

Previously making small trace-edits to (ensure connections or adjust) of the pours was an extremely tedious task.

Also, I have assigned:
  • "[" to View -> "Mirror"
Now a quick tap of "B" then "[", shows the the bottom side in "normal" flip-the-board-over view, which is very useful when adding Text Silkscreen to the bottom side.

And then, "T" and "[" reverts back to the normal top side view.

Note: A little Silkscreen text on each side helps orient yourself for each side.

And Yes I know "Mirror" has always been there, but it was always a "Pain-in-the-butt" to find it in the drop down menus, and therefore I seldom used it.


Thanks, DipTrace Team !!!


-- Home Page: https://WA0UWH.blogspot.com

Saturday, August 8, 2015

Enigma - Revisited

UPDATE:
See Below

I have watched and read several more articles regarding cryptography. Each suggest that any method that uses "reused keys" or "reused sheets" is doomed to be deciphered, especial with very fast computers available today. The Enigma Machine had a very large Key, one of 158,962,555,217,826,360,000 settings. Which is computed as:

5 * 4 * 3 * 26^3 * ( 26! / (6! * 10! * 2^10) ) = 158,962,555,217,826,360,000

Note: I did NOT verify the above expression :-)

It has been suggested that the use of the Enigma, which did NOT use a "reused key", had its own downfalls. The most fatal where the facts that any single character would never encrypt to itself, and the "day key" was transmitted twice, or read from a code book.  History may have been recorded very differently without these two flaws.

The mechanics of the Enigma changed the running "key" with each character as the message is encoded, which is good. But, the starting "day key" was normally transmitted in a predictable formant twice at the beginning of each day.

I have played with my software implementation of the Enigma Machine, and have recently realised that software does not have-to-have the "limitation" imposed on the original Enigma Hardware, which had only 26 letters, 3 or 4 mechanical wheels, and jumper wires to implement the cypher.

My software implementation "could" easily use all of the ASCII codes (256, or maybe even more), as many "wheels" as desired, and with coded jumpers (in wheels and plug-boards) that "could" encode to themselves.

I think, flaws could be removed, as  the "published" problems with the Enigma. And, it is easy to do, it is just a mater of some easy to implement software! A very long "day key" could be created with Diffie-Hellman key exchange that could be easily transmitted via the Internet. The Software Enigma could instantly encode and transmit a message the same way.

It was suggested that even with the knowledge of the internal working of the Enigma. it would have been a lot harder to break the code (if the flaws had been eliminated). The same is true with a software solution, the algorithm could be published without much fear.

I wonder: How long would it take to decipher text from my Greatly Expanded Software Enigma Implementation? With just 256 Letter Codes, 256 Wheels, and 1 plug-board?

The German Enigma Key would appear to be a VERY SMALL fraction of the size of the possible Keys with 256 Letter Codes and 256 Wheels.

Actually, I do not think that would/could ever be answered, the problem is just too big.

For now, Software algorithms are always fun to think about  :-)



UPDATE:

Maybe "it", the number of keys for a 256 Letter Codes and 256 Wheels would NOT too big to calculate, I think it would be about:

256! * 256^256 =
27722102253833147750378752929772591901157254707422810843994850662178\
68509346387893431488607772479277687787895866917592862787498012527341\
20202941212930977432442839904764004089399268000448724122711559911607\
60779312819264238191417519113442331359269075602333340924686925409483\
99343102411050829848501735482622253522121728830342877764078525005364\
11706629786567706584325065474995318449040370842738828586810575264794\
12348783633571725165157131881436322357402582839932654806407271765546\
89263529741167130237617046563306987828896526138415818160291921177505\
94348668287596740843119974305008513344652339955774268612605659633484\
22635140831895266181475491155749645385538913890911142141920032414770\
49936109897934583258064087400757197847628192792690203621377980075882\
62413792355253854197130918506290943714329430352099968868502454316347\
64297297921292809713502427667689713905790084360261562757916556588568\
03869079651490956618284957160374601554692062042172725556744686295735\
57378616587083471686842123962257930714832014899651587649367849037445\
00798192771870940669313631808910069334016000000000000000000000000000\
000000000000000000000000000000000000

Or, about: 2.77221 x 10^1140 Keys

This number is not as big as a "googolplex", but it is very large.

This was computed with the following on a Linux machine:

$ echo "`echo 256 | factorial` * `echo '256^256'`" | bc


-- Home Page: https://WA0UWH.blogspot.com

Tuesday, August 4, 2015

Another ESP Adaptor

UPDATE: Here is some important info, watch this thread for progress:

Yes, this is yet another Esp8266 Adaptor, but this one will support an Esp-12E with its extra six pins. The side pins match the Castellated pins on the Esp-12E. Note: this Diptrace 3D rendering does not know how to correctly represent Castellated connectors.

Top Side - Esp8266 Esp-12E Adaptor
I just sent the design into OshPark.com for manufacture, the boards should be returned in about 2 weeks. The cost is $1.50 each. If all goes well, I will share the design as a Project on OshPark.

Bottom Side - Esp8266 Esp-12E Adaptor
"If", I did everything right (with no mistakes),  this should fit a 22 pin DIP socket, or a normal Protoboard with lots of available holes for jumper wires. The underside used two single row SMT 0.1 inch Headers which are available on Ebay, for example: here.

While designing this adaptor, I considered adding a few Pullup Resistors, Program and Reset switches. But, for the boards size that would require a four layer board, and would decreases Pin flexibility.

I think this adaptor will be my favourite, for small Esp8266 Protoboard development projects. The Esp-12E provides lots of I/O and is still very small (I like that).

Note: this design is the result of experimenting with a "Back-to-Back Configuration" as suggested in a previous post.


-- Home Page: https://WA0UWH.blogspot.com

Monday, August 3, 2015

Kolban’s book on the ESP8266

I found a wonderful new published ebook and/or PDF for the Esp8266, the link saved here for future reference:

Also, see:



Thanks, Kolban for your efforts !


-- Home Page: https://WA0UWH.blogspot.com