1/600 Revell USS Enterprise – Star Trek the Original Series – Build Log

Arduino Microcontrollers

The only thing that remains as far as build thread goes is to talk a little bit about the software on the Arduino…

As you will know if you’ve been following the build so far, the lighting for this kit is controlled by an Arduino Nano Microcontroller.

The Arduino Nano can be had for about £10 on ebay and with the addition of a few external resistors can control a number of LEDs (or for that matter pretty much anything that you’d like to hook up to it). Another great thing (and there are many great things about this microcontroller) is that it is absolutely tiny and can be easily stashed inside a model, or in a small sized base.

It comes with 14 digital I/O (Input/Output) pins, so that gives you 14 different things you can switch on and off at will – more if you connect several things to each channel.

6 of the digital I/O pins can be configured as PWM, which stands for Pulse Width Modulation. Pulse Width Modulation is great because it sounds really technical and is guaranteed to impress anyone that you spout it at, but in fact it’s pretty simple stuff and means that any pin you configure to use PWM will become capable of outputting a variable current which for LEDs will allow you to control their brightness from within your code. PWM itself just means that instead of the digital I/O pin outputting a steady 5 Volts, the pin pulses on and off rapidly many times a second from 0 volts to 5 volts. The width of the pulse determines how much current the pin will deliver, a very narrow (short) pulse delivering very little current, a wide (long) pulse delivering a lot more current.

For the Enterprise lighting I didn’t use PWM, just plain old digital I/O.

The Arduino project is open source and comes with some really good (and free) development software that you can download. Once you install their software, you connect your Arduino to your PC via a USB cable (which also powers the Arduino for development purposes) and your immediately ready to start coding…

[Arduino-1]

There are two main parts to the code (functions as they are known), a setup function and a loop function. You put initialisation code in the setup function, for example here you would setup how you want the various I/O (Input / Output) pins to behave. And in the Loop function you would put your code that actually does things to the pins. The loop function being repeatedly run (called) while the Arduino is powered up.

When you’re done coding you click the Upload button as circled in red below:

[Arduino-21]

…and your program will be uploaded to the Arduino and will start running as soon as it has uploaded.

Once you have uploaded your program to the Arduino it will be stored in non volatile flash RAM in the Arduino, meaning that your program will remain stored even when the Arduino is powered off. As soon as you power up the Arduino it will automatically load your program and start running it.

Other than the actual coding, it really doesn’t get any easier than the Arduino, back in the day you used to have to build a circuit using separate chips, and programming was usually done by means of an EPROM blower which permanently (or semi-permanently) wrote your program to the chips. Programming would have been via Machine Code / Assembler and creating even the simplest of micro-control system was a job for specialists. With systems such as the Arduino, micro controllers have never been more accessible and for £10 you can be up and running in no time. (Assuming you can do a bit of coding) 😉

Arduino Programming

In terms of programming the Arduino, the good news is that you can program it in good old industry standard C. The even better news is that you can also code it in good old industry standard C++ (Pronounced “See Plus Plus”). If you are new to coding then C is a good place to start, if you’re already into coding then C++ is the better place to start.

The difference between C and C++ is that C++ is an “Object Oriented” programming language whereas C is not. C++ is a superset of C, in other words C++ has everything in it that C has plus a load of object oriented extras. I would recommend C to beginners because it will save you from having to learn all about object oriented programming – which is a major task in its own right.

With that said, the lighting control for the Enterprise has been coded to be object oriented in C++ as it makes programming multiple things (multiple LEDs) more easy. With C++ you can write a bit of code that controls a flashing LED, and then easily create multiple copies of that code for every LED that you want to control. This is trickier to do in plain old C – so the trade off with C++ is that it’s harder to learn, but easier to program when you know how.

I’ve pasted the complete source code for my Enterprise lighting at the end of this post, you’re more than welcome to copy it and modify/use it in your own projects.

The beauty of it being object oriented is that you can easily add more flashing lights by tweaking the parts labelled SECTION 1, SECTION 2, SECTION 3. All you need to do is add/remove a few lines of code and the object oriented part will handle the functionality for you – you won’t need to touch that part of it.

Rich’s Enterprise Lighting Controller Code…

For my project I have two separate parts of the kit to animate with light, the navigation lights on the saucer and the engine nacelle lights…
The nav lights are simply 4 LEDs that flash on and off on a regular period. No problem there, just need to turn on the LEDs for 1500mS and then turn them off for 450mS.

The engines are somewhat more complex, for each of these I have a ring of 12 LEDs that will operate on a chaser circuit whereby groups of 3 LEDs will be cycled in sequence to make it appear that they are chasing round in a circle. In the middle of this will be 4 LEDs that randomly blink on and off.

The main problem typically faced when programming multiple things to happen at once on any kind of computer is that computer programs typically tend to only do one thing at a time. So if you turn on an LED and then wait 1500mS before turning it off again by using the built in delay functions, the computer (Arduino in this case) will be busy doing nothing waiting for 1500mS. It won’t be able to do anything else until the 1500mS has elapsed, giving the impression that it has hung. That’s no good here because we want the Arduino to be chasing 24 chaser LEDs, randomly blinking 8 engine LEDs and steadily flashing 4 nav LEDs all at the same time.

What I ended up doing was to create a piece of code (called a “class”) to represent the chaser circuit, and also another class to represent the flashing LEDs. The chaser class handles all the functionality required to chase LEDs in a circle, while the FlashingLED class knows how to handle LED flashing.

To get around the ‘one thing at a time’ limitation what we do is to create a service function within each class. When we call the service function (from the Arduino loop) the object (flashing LED or chaser) works out how much time has elapsed since it last changed state (e.g. from on to off), and if it is time to change again it makes the required change. This means that we don’t have to delay anywhere in our code, we just wizz around calling the service function of each object in rapid succession. This doesn’t actually allow two things to happen at once, but it gives the impression that multiple things are happening at the same time. In effect the objects are serviced in succession so quickly that the human eye would not be able to see that in fact things are happening one after the other.

For the chaser I just create a single chaser object, whereas for the flashing LEDs I create multiple FlashignLED objects, one for each flashing LED. Again this is the beauty of object oriented programming – I wrote the code for a FlashingLED and then when I need flashing LEDs I just create a separate instance or copy of the flashing LED for each one.

All of the information that an object needs is passed to it when it is created, so for a flashing LED we create it and pass it which Arduino channel number it should use, how long it should stay off for, and how long it should stay on for. For example:

navLED12 = new FlashingLED(12, 450, 1500);

The above line creates a new flashing LED object that will flash digital output 12 to be off for 450mS and on for 1500mS. We’ve also got a more advanced method of constructing a flashing LED object as per the following example:

portEngineLED11 = new FlashingLED(11, 600, 2200, 40, 400);

The above line also creates a flashing LED, but this time for digital output 11 to randomly flash. The LED will be off for between 600 and 2200mS, and will be on for between 40 and 400mS.

Here’s the final source code that I ended up using, as I said feel free to grab a copy if it will help you. Also please feel free to post any questions you have here and I’d be happy to try and answer them…

/*
  LEDFlasher
  ==========
  Created 9th December 2013
  by -=Richard Moore=-
  richard@easify.co.uk
  =========================
 
  This code is in the public domain and you are free to copy it, modify it
  and re-distribute it as you see fit. All I ask is that you keep the above
  credits in the header intact.
 
  ============================================================================
  This code consists of two classes that allow you to flash multiple LEDs
  without the need for using the delay() function. The code was originally
  written to control the DIY lights I made for a Revell 1/600 scale Star
  Trek USS Enterprise TOS (The Original Series). The engine nacelle lights
  are driven by the Chaser class which handles stepping a ring of LEDs, and
  an LEDFlasher class handles a few flashing engine lights and also the
  flashing navigation lights on the saucer.
 
  Chaser class
  ============
  When you create this class you pass it the Arduino pin numbers that you
  want to connect your chaser LEDs to, I’ve named them yChannel, rChannel,
  gChannel and bChannel (Yellow, Red, Green, Blue). Also pass in the chaseSpeed
  which is the delay in mS between each step of the chaser.
 
  From the main loop call the Chaser->Service() method on each pass to service
  any pending LED sequence changes.
 
 
  FlashingLED class
  ================= 
  This class allows you to have multiple flashing LEDs that do not depend on
  the delay() function for their timing. This means they can all be processed
  simultaneously and will also work alongside the Chaser class. 
 
  There are two types of LEDs you can create, fixed period and random period.
 
  Call the FlashingLED constructor with Channel number, off time and on time
  to create a fixed period LED which will flash the chosen channel at the fixed
  time period specified.
 
  To create a random flashing LED, call the FlashingLED constructor with channel
  number, minimum off time, maximum off time, minimum on time and maximum on time
  to create a flashing LED with a random time period. The LED will be off for
  between minOffTime and maxOffTime mS, and will be on for between minOnTime and
  maxOnTime mS. 
 
  From the main loop call the FlashingLED->Service() method on each pass to
  service any pending LED state changes.
*/

/* Chaser class */
class Chaser
{
   private:
    int timePeriod;
    int yellowChannel, redChannel, greenChannel, blueChannel;
    int chaserState;
    long lastTimeCount;
  public:
    Chaser(int yChannel, int rChannel, int gChannel, int bChannel, long chaseSpeed){
      yellowChannel = yChannel;
      redChannel = rChannel;
      greenChannel = gChannel;
      blueChannel = bChannel;
     
      pinMode(yellowChannel,OUTPUT);
      pinMode(redChannel,OUTPUT);
      pinMode(greenChannel,OUTPUT);
      pinMode(blueChannel,OUTPUT);
                 
      timePeriod = chaseSpeed;
      chaserState = 0;
      lastTimeCount = millis();
    };
   
    void Service()
    {    
      // See if it is time to step the chaser…
      if (millis() >= lastTimeCount + timePeriod)
      {
        // Chase the LEDs around another step…      
        lastTimeCount = millis();
        switch(chaserState){
          case 0: // Yellow   
            digitalWrite(blueChannel, LOW);
            digitalWrite(yellowChannel, HIGH);           
            chaserState += 1;
            break;
          case 1: // Red                           
            digitalWrite(yellowChannel, LOW);
            digitalWrite(redChannel, HIGH);      
            chaserState += 1;
            break; 
          case 2: // Green                         
            digitalWrite(redChannel, LOW); 
            digitalWrite(greenChannel, HIGH);     
            chaserState += 1;
            break;   
          case 3: // Blue
            digitalWrite(greenChannel, LOW); 
            digitalWrite(blueChannel, HIGH);      
            chaserState = 0;
            break;
        };   
      };    
    };
};

/* FlashingLED Class */
class FlashingLED
{
  private:
    long minOffTime, maxOffTime;
    long minOnTime, maxOnTime;  
    long offTime, onTime;
   
    bool ledIsOn;
    long lastTimeCount;
    int channel;
   
    void RegenerateTimes(){
      // This is called to re-calculate the off and on times for the LED. If the min and max times
      // are the same then the LED will always flash with the same period i.e. not random.
      offTime = random(minOffTime, maxOffTime);      
      onTime = random(minOnTime, maxOnTime);      
    };
  public:
    //TODO: Somehow add ability for delayed start i.e. start flashing sequence after fixed or random delay…
 
    FlashingLED(int channelNo, long offTime, long onTime){
      // Call this constructor to instantiate a simple flashing LED
      channel = channelNo;
      pinMode(channel,OUTPUT);
  
      this->minOffTime = offTime;
      this->maxOffTime = offTime;
      this->minOnTime = onTime;
      this->maxOnTime = onTime;

      RegenerateTimes();
     
      ledIsOn = false;    
      lastTimeCount = millis();   
    }; 
   
    FlashingLED(int channelNo, long minOffTime, long maxOffTime, long minOnTime, long maxOnTime){
      // Call this constructor to instantiate a flashing LED with a random off time and random on time
      channel = channelNo;
      pinMode(channel,OUTPUT);
  
      this->minOffTime = minOffTime;
      this->maxOffTime = maxOffTime;
      this->minOnTime = minOnTime;
      this->maxOnTime = maxOnTime;

      RegenerateTimes();
     
      ledIsOn = false;    
      lastTimeCount = millis();    
    }; 
   
    void Service(){
      // See if it time to turn on/off the LED
      if (ledIsOn)
      {   
        // LED is ON
        if (millis() >= lastTimeCount + onTime){
          lastTimeCount = millis();  
          digitalWrite(channel, LOW);   
          ledIsOn = false;
          RegenerateTimes();         
        };
      }     
      else {
        // LED is OFF
        if (millis() >= lastTimeCount + offTime){
          lastTimeCount = millis();  
          digitalWrite(channel, HIGH);
          ledIsOn = true;
          RegenerateTimes();           
        };         
      };
    };
};

/* SECTION 1 – INSTANCE DECLARATIONS
    For each object (thing) that you want to implement,
    create an instance of it here… */
Chaser *chaser;
FlashingLED *stbdEngineLED4;
FlashingLED *stbdEngineLED5;
FlashingLED *stbdEngineLED6;
FlashingLED *stbdEngineLED7;
FlashingLED *portEngineLED8;
FlashingLED *portEngineLED9;
FlashingLED *portEngineLED10;
FlashingLED *portEngineLED11;
FlashingLED *navLED12;

void setup() {
  // put your setup code here, to run once:
 
  // Make the random number generator be random
  randomSeed(analogRead(0));
 
  /* SECTION 2 – INSTANTIATE THE OBJECTS
      For each object (thing) that you declared in SECTION 1,
      you will need to instantiate it (initialise it) here…*/
 
  // Initialise chaser…
  chaser = new Chaser(2, 3, 1, 0, 22);
 
  // Initialise flashing LEDs…
  stbdEngineLED4 = new FlashingLED(4, 400, 2500, 10, 150);
  stbdEngineLED5 = new FlashingLED(5, 500, 2000, 40, 380);
  stbdEngineLED6 = new FlashingLED(6, 600, 2500, 40, 385);
  stbdEngineLED7 = new FlashingLED(7, 600, 2200, 40, 400);
 
  portEngineLED8 = new FlashingLED(8, 400, 2500, 10, 150);
  portEngineLED9 = new FlashingLED(9, 500, 2000, 40, 380);
  portEngineLED10 = new FlashingLED(10, 600, 2500, 40, 385);
  portEngineLED11 = new FlashingLED(11, 600, 2200, 40, 400); 
 
  // Saucer nav LEDs
  navLED12 = new FlashingLED(12, 450, 1500);   
}

void loop() {
  // put your main code here, to run repeatedly:
 
  /* SECTION 3 – Service your objects…
      For each object that you have declared and instantiated, you
      will need to call its ‘Service()’ method here…*/
  chaser->Service();
  stbdEngineLED4->Service();
  stbdEngineLED5->Service();
  stbdEngineLED6->Service();
  stbdEngineLED7->Service();
  portEngineLED8->Service();
  portEngineLED9->Service();
  portEngineLED10->Service();
  portEngineLED11->Service(); 
  navLED12->Service();
}

 

Thanks for visiting!

I write this blog for fun, to share what I've learned, and to share my builds with you. If you like what you see here please leave a comment, and head over to facebook and like my page!

Cheers - Rich



59 comments on “1/600 Revell USS Enterprise – Star Trek the Original Series – Build Log
  1. Keith says:

    Hi Richard!
    My name is Keith & I live in Louisiana, USA. I have been studying your awesome build of the Original Series Revell Enterprise. Know you have heard this many times, but….WOW! You did such an amazing job on the building AND the documentation of this model project. My hat is off to you, sir!!! I have purchased the same kit & have rounded up most of what I will need to put her together. I am planning on having the engine nacelle fans rotate via some small DC motors. Also will have LEDs in them of course, though I’m probably only going to have about 8 or so in each. Anyway, I’ll get to the point, (if there is one!😁). Do you think I can drive all the LEDs & the motors with a single Arduino Nano or such? Or would it require two? Any thoughts or suggestions would be greatly appreciated!
    Thanks so much for your time!

    • Richard says:

      Hi Keith, thanks for posting here – much appreciated 🙂

      A single Arduino could handle 8 LEDs no problem at all. Regarding the motors it would depend on what current the motors will draw.

      If I were you I wouldn’t drive the motors from the Arduino because AFAIK the motors will just need to run at a constant speed and will either be on or off (it’s the LEDs that will flash on and off). So probably best to just wire the motors onto the main power supply and not through the Arduino.

      If you do decide to connect the motors to the Arduino, I’d recommend not directly connecting them to the Arduino outputs but instead connect them via a driver transistor. 2 reasons for this: 1) The driver transistor will be what provides the current to the motor, so you won’t be limited to the maximum output current of an Arduino pin. 2) Since motors are inductive loads they can induce a reverse current into their source (back EMF) – this might damage a micro controller so better to have the motor isolated from the chip via a driver transistor.

      HTH – Rich

  2. Goran says:

    Hi, Richard. I have a favor to ask if you could help me. I am trying to buy a plastic box for the stand of my Enterprise, but I don’t know what are dimension of this included stand ? I won’t be able to get to my model few more days, and I need that info like yesterday 🙂 If you have your model somewhere around you, could you post dimensions of the stand (only vertical part that has shape on star trek logo) thanks 🙂

    • Richard says:

      Hi Goran, the height of the vertical part of the stand is 100mm from the top of the base plate to the top of the highest part of the vertical part of the stand. Does that help?

  3. Manuele says:

    Thank you Rich, very helpful
    we completed the same model with arduino and leds, we just added a pulsating led light on the tail
    http://www.youtube.com/watch?v=8qbS6Jo9Wrk

  4. Diego says:

    Hello,

    I found your build log amazing! Please can you share your paint chart for this build? I don’t want to use Revell paint so I want to follow your lead by using Tamiya paint instead.

    Please can you share info?

    Thank you very much

  5. Gordon Duquette says:

    I love the work you did on this build. I know you’re not crazy about the tamiya xf12 with 10% white, but I think it looks great. I was wondering though, you never mentioned whether you added thinner or not. Did you? And how much? And what airbrush did you use? Thanks. Keep up the great work.

    • Richard says:

      Hi Gordon,

      I must admit I’m really happy with the end result but would aim to reduce the green tint if I did one again.

      When I spray Tamiya acrylics I always thin it very heavily probably 30% paint to 70% thinners (X-20a). This way I can build up many coats of paint gradually, and the end result is very smooth and free from orange peel effect.

      My airbrush of choice is the Harder & Steenbeck Evo 2 in 1 with a 0.2mm needle. It’s a great all rounder for modelling and very easy to clean.

      Cheers – Rich

  6. Gordon Duquette says:

    Thanks for the info. I really appreciate it.

  7. Diego says:

    Hi Rich,

    Thank you for your explanation about the paint. Much appreciated.

    I have one more question about the painting. What painting did you use for Engine nachelle’s back end/”exhaust cover” (for want of a better word). It looks like you use same paint on it as intercooler interior (stainless steel paint?). If it is not the case, please can you tell us which grey paint (of Tamiya) did you use on Exhaust cover/back end of nachelle.

    Finally, I was reading Page 7 of Build log and I was a bit unclear on 2nd last paragraph on that page. Shouldn’t it be 32 LEDs and 10 wires running into the microprocessor?

    Thank you again
    Diego

    • Richard says:

      Hi Diego,

      The round domed bit at the back of the nacelles was done in a very light grey, could have been XF-80 Royal Light Grey with a bit of added white. The bit that the round domed bit attaches onto was painted with XF-66 Light grey.

      In the photo on Page 7, there are 16 LEDs per side which is 32 pins. The outer ring has 4 groups of 3 LEDs (4 wires since I connect all 3 of a similar colour using the same wire) and there are 4 separate inner LEDs (4 wires) plus 1 wire for common which equals 9 wires in total per side.

      • Diego says:

        Hi Rich,

        Thank you for the reply and clarifications as those are much appreciated.

        I thought for once that it was stainless steel on the bit that the round domed bit attached onto. I looked again at the photo and I could see that it just got shiny because of your camera’s flashing. Thank you again for correcting me.

        As for wiring. I admit that I don’t have great experience in electronics myself so I am learning here and there.

        1.) I assume that your reference to common wire as for that Red wire/negative wire?

        2.) After looking at photos and explanations, I realised that it could be possible to extend the daisy chain wiring of outer rings of LEDs to include inner rings of LEDS. So that way, you would use 7 wires (6 “positive” wires and 1 “negative” wire). Does that make sense?

        I haven’t reached this stage yet but I wonder though. Hence, in your frank opinion, is it feasible or workable? Or not possible?

        Thank you for your feedback and sharing your thoughts.

        Best,
        Diego

        • Diego says:

          Apolgoises, I made a small mistake in my comment.

          Correction: You would use 6 wires (5 “positive” wires and 1 “negative” wire) per side, at the end.

        • Richard says:

          Hi Diego,

          You’re welcome.

          1) Common wire is also known as ground, negative, earth etc…

          2) The inner ring of LEDs – all LEDs in the inner ring have a separate wire so that they can be flickered on and off individually.

          Any more questions just fire away 🙂

          Rich

  8. Diego says:

    Hi Rich,

    I wonder if you have used any Tamiya primer for this model kit or not? Especially when you used Tamiya XF-66 paint?

    The reason I asked this is because when I used XF-66 paint on this model as per your build log, the 1st coat was a bit too runny (as if there is too much thinner in the paint which I never used thinner at all as I used brush-painting for this model (I can’t afford air-brushing kit at the moment)). I left it to be dried for a week (I’m poor time-wise) before I applied 2nd coat of XF-66 which something odd happened – 2nd coat painting was basically removing 1st coat of painting! O_O It seems that the painting was too thinning or too running all along.

    I wonder if I apply primer to the parts of this model where XF-66 paint is on, it may stop this problem happening? But then I don’t see anywhere on this build log that you used primer which made me wondering otherwise.

    Thank you again for your insight and helps.

    Best,
    Diego

    • Richard says:

      Hi Diego, the problem is that Tamiya paint is not good for hand brushing.

      Tamiya is alcohol based acrylic, and when you brush on a second coat, the alcohol in the paint will eat into the first coat and will turn it back into wet paint.

      For hand brushing you should use a water based acrylic such as Vallejo Model Color. This is excellent paint for hand brushing because once a coat is dry, subsequent coats will not affect the dried coats. Also where it is water based it won’t dry as fast as Tamiya paint so you’ll get a smoother finish.

  9. Gordon Duquette says:

    Hi Richard. Well I’m halfway through my model and I love the color. The green tint doesn’t bother me at all. But I made the mistake of painting the model first before putting it together and puttying and sanding the lines out. It was a nightmare to say the least. I ended up with a less perfect paint job because of it. The reason I went this route was because I was worried about messing the windows up. Did you mask your windows before painting? And if so, what did you use? I’ve watched dozens of videos of people building this model and the 1:350 scale from round 2, but none of them explained how they painted it. I still have the saucer to build, and I’ve heard about this stuff called liquid mask. Is that something I could use to cover up the windows before I paint? I’m sorry this is my first model. I’m still learning. lol

    • Richard says:

      Hi Gordon, I opted for painting the kit first, then fitting the glass, and then gluing it together and sorting out the seams last.

      The reason for this is that to fit it all together and then mask the windows before painting would be a huge job, and it would be difficult to get it looking neat.

      There are several approaches you can take with the windows…

      1. Build the whole kit and paint it at the end. Problem is masking the windows. You can use a masking fluid (Humbrol Maskol) but this will tend to flow right into the seams around the windows and be difficult to remove. Also masking fluid tends to crack the paint around it when removed so you’d end up with a poor finish around the windows. Masking using tape would be very fiddly and time consuming.

      2. Build the whole kit without the glass and paint it at the end. Then use PVA glue to create the windows. With this technique you leave out the glass, paint the model and then put a dab of PVA glue in each window hole to create a window. It will dry clear and look like glass. See page 2 of the build where I tried this but wasn’t satisfied with the result – http://www.makingmodels.co.uk/builds-in-progress/1600-revell-uss-enterprise-star-trek-the-original-series-build-log/3/ good thing is this technique doesn’t require masking.

      3. Paint the kit first, then fit the windows and assemble, taking care of the seams afterwards. This is the approach I chose and it worked for me, though sorting out and re-touching the seams is challenging.

      HTH – Rich

  10. Diego says:

    Hello Richard,

    I was reading this build log – particularly page 4 – concerning the petal lense (the one behind the orange/outer nacelle lense.

    I can’t tell from the pictures on this page 4 – whether you actually painted petal lense or not. If you did paint the petal lense, please could you tell us what paint did you use? It looks like silver paint?

    Although the official revell instruction says that the petal lense to be painted as clear orange and those sticking out bits of lense to be painted as silver, your picture suggested the otherwise.

    Thank you very much for letting us know whether you painted petal lense or not.

    Diego

    • Richard says:

      The outer petal lens was sanded on the inside to make it opaque, and then sprayed on the inside with Tamiya Clear Orange. This is so that you can’t see through it to see the LEDs.

      The inner clear lens was left clear.

Leave a Reply

Your email address will not be published. Required fields are marked *

*