DED Adventures – Part 5 – And we’re expanding!

We’ll after we got the DED and FuelFlow sorted out it’s time to think on how to get everything packed for the real pit installation, in addition, when we have things running we get a better clue on available memory and CPU cycle limit. When I’ve changed the way the DED worked, I suddenly realized I’ve cleared the exact amout of memory to drive a second DED, or to be more precise, to drive the PFL. The PFL is identicle to the DED in size and resolution, the the adaptation was very easy, on the PC side of things, PFL uses exact same structure in the SharedMem. so it’s a matter of reusing the DED code.

    //PFL Lines
    char PFLLines[5][26];  //25 usable chars
    char PFLInvert[5][26]; //25 usable chars
DED, PFL and FuelFlow driven by Arduino Micro
DED, PFL and FuelFlow driven by Arduino Micro

Once we have that done, we can get some more thought into final solution. I’ve decided to start with the small scale, the Indexers.

Continue reading DED Adventures – Part 5 – And we’re expanding!

DED Adventures – Part 4 – And there be light

OK, So we got the DED and FuelFlow sorted out. we got a way to get the data over and drive the screen. Before we go on, let’s talk a bit about Arduino boards.

Arduino Boards are ATMEGA based development board, putting the I/O pins available for quick connections. Basic Arduinos traditionally have 13 available digital I/O pins and 6 ADC 10bit “analog” Inputs.

the “classic” arduino board is the Arduino Uno.
Based on the ATMEGA328P, a 16MHZ, 2K RAM chip that uses an on-board RS232 chip to handle serial communication via 2 of the 13 IO pins. I’ve done my initial prototyping work on this board and it works with comms of up to 96000 baud reliably. you might start catching some errors but YMMV.

on the other side of the scale there is the Arduino Due.
the Duo is ARM based 84MHz chip with 96k RAM, it has 54 IO pins, 12 ADC pins and so on. it’s bigger then the Uno.

in the middle this is the Leonardo, it’s about the same size as the Uno, but uses a different Chip, the ATMEGA32u4. However, it’s his little brother the Arduino Micro, is the one I’ll focus about. the 32u4  is pretty much identical to the 328P with a few exceptions, it has 2.5K of RAM, a bit more I/O pins, but the most important feature on the chip is that it has native USB capability, which means it can do serial communication much faster then the Uno. the added bonus is it’s size, the Micro is TINY, it’s slightly less the 5cm long, and has male headers in two rows, which makes it breadboard compatible, and allows an easier mounting . So I chose it and everything I wrote was Micro Optimized. However I do indend to try and make the code in an Uno version (but with diminished capability) and in  Due version (as Acef already has on – so why not).

And back to the design.. Continue reading DED Adventures – Part 4 – And there be light

DED Adventures – Part 3

now that we covered the basics, and we know how to run our FuelFlow, we can continue our dive into the project. DED screen was chosen as it is the closest I could get to the real thing from the selection of avaiable hardware. I chose the BuyDIsplay 2.8″ OLED Yellow-On-Black another option would be the New Haven 2.8″ OLED Yellow-On-Black they both use the same u8glib constructor and are interchangeable (different wiring is required of course).

Let’s look back at the DED in the “flightData.h” file.

 //DED Lines
    char DEDLines[5][26]; //25 usable chars
    char Invert[5][26]; //25 usable chars

in C a string is a char array ending with null character (ASCII 0)
so we actually have 5 lines of 25 chars ending with a 0 (from now it will be referred as “\0”)
DED is actually 5*24, so I don’t know why the extra \0, so we can safely only transmit the 24 bytes.

in Part 1 you saw a video with an early code, in that code I’ve sent the two arrays and drew them with the arduino, that required multiple passes on both arrays, costing many CPU cycles. I’ve decided to do the manipulation on the computer side, sending only one ANSI array. However that required a special font to be loaded onto the Arduino/Display. The font was drawn as TTF, re-positioned to correct ANSI position, and converted to the Format u8glib can use.
I’ve created the font using fontstruct and it’s available here

I ofcourse had to write the code to normlize the entire thing

        private string NormalizeLine(string Disp, string Inv)
        {
            char[] NormLine = new char[25];
            for (short j = 0; j < Disp.Length; j++)
            {
                if (Inv[j] == 2)
                {
                    if (char.IsLetter(Disp[j]))
                    {
                        NormLine[j] = char.ToLower((Disp[j]));
                    }
                    else if (Disp[j] == 1)
                    {
                        NormLine[j] = (char)192;
                    }
                    else if (Disp[j] == 2)
                    {
                        NormLine[j] = (char)170;
                    }
                    else if (Disp[j] == 3)
                    {
                        NormLine[j] = (char)223;
                    }
                    else if (Disp[j] == '~')
                    {
                        NormLine[j] = (char)252;
                    }
                    else
                    {
                        NormLine[j] = (char)(Disp[j] + 128);
                    }
                }
                else
                {
                    if (Disp[j] == 1)
                    {
                        NormLine[j] = '@';
                    }
                    else if (Disp[j] == 2)
                    {
                        NormLine[j] = '*';
                    }
                    else if (Disp[j] == 3)
                    {
                        NormLine[j] = '_';
                    }
                    else if (Disp[j] == '~')
                    {
                        NormLine[j] = '|';
                    }
                    else
                    {
                        NormLine[j] = Disp[j];
                    }
                }

            }
            return new string(NormLine);
        }

The arduino side is very simple, so I will not elaborate much

char DED[5][26] = {{ 0 }};

void  readDED() {
  for (short i = 0; i < 5; i++) {
    Serial.print("D");
    Serial.print(i);
    Serial.flush();
    Serial.readBytes(DED[i], 25);
  }
}

void drawDED() {
  /// Begin Picture loop ///
  dedDisp.firstPage();
  do {
    for (unsigned short i = 0; i < 5; i++ ) {
      dedDisp.drawStr(DED_H_CONST, i * DED_CHAR_H + DED_V_CONST, DED[i]);
    }
  } while ( dedDisp.nextPage() );
  /// End Picture loop ///
}

Combining this, with the code we saw in the previous part, gives us a DED and an animated FuelFlow. in the video you can also see the indexers modeled by 6 leds, but that code uses a different logic, and will be covered in a later post.

BTW – The code shown here is pretty old, so there is a bug in the FuelFlow code used here, the snippet in Post 2 is already corrected (one of the benefits of starting a blog late)

Enjoy! 🙂

DED Adventures – Part 2 – Tech post

Let’s talk about a bit about the technical stuff. I think that going over the technical aspects will make some sense, and naturally help others in their quest.

I’ll have posts like that from time to time, covering technical aspects of the project. Which means that code examples, circuit schematics and random technical mambo jumbo are all legit in this type of posts.

So lets begin….

Continue reading DED Adventures – Part 2 – Tech post