Helicopter animation using a Raspberry Pi

You could have a loop that runs at the flashing rate.

Each time through the loop decide which LEDs and functions are active or inactive based on the loop count.

Generally only the flashing LED will change each time through the loop, but after a certain number of loops each of the other functions will change state.

The flashing LED may flash between a start count and an end count.

You could have a loop that runs at the flashing rate.

Each time through the loop decide which LEDs and functions are active or inactive based on the loop count.

Generally only the flashing LED will change each time through the loop, but after a certain number of loops each of the other functions will change state.

The flashing LED may flash between a start count and an end count.

Thanks Doug for the reply.

Help me understand you defintion of a loop? I have code that causes flashing. When I insert that code it runs once because my understanding of python is it is sequential. Step 1, step 2, step 3 and so forth. If step 2 is a loop that runs continious and the code advances to step 3 then a loop is what I think will work.

I thought step2 as a function but that didn't work. I thought step2 as a called module but that didn't work. Now forgive me when I say module. I import another python script. I have been trying to understand class objects hoping that might be the solution.

Can you provide a loop reference? When I research loops, i get the basic if then else return or while true.

Here is a description of loops in Python:

https://www.learnpython.org/en/Loops

Assume your whole sequence takes the same time as 100 flashes, you would have a while loop that runs while count < 100

Inside the loop you can turn the flashing LED on if it is off else turn it off

If you want to turn cabin lights on at a count of 10 it is just another if statement inside the loop like if count > 10 turn on cabin led

if statement syntax can be found here:

ttps://www.tutorialspoint.com/python/python_if_else.htm

OK we are both on the same page when it comes to understanding loops. I wanted to make sure your loop and my loop were the same before proceeding with the discussion.

The turning on and then off of all lights is eight events. Four on and four offs. One of those events is a strobe. When the strobe is on, it is flashing. The whole sequence will occur over a specified time period. The whole eight event sequence is a loop.  That timing of the full loop will need to be refined as I integrate rotor animation and the sound. I'm estimating approx 2 minutes.

If the strobe was at the end of the sequence then I can see a loop working. Turn all three lights on, run the another loop to generate the strobe and then proceed to turn all three lights off. Restart sequence. Since the strobe is in the middle of turning on the lights, it needs to be a fire and forget. My thought is to have a start loop routine, then proceed with the other events and during the off sequence a stop loop routine.

I have been unable to separate the strobe to run independent from the other events. While the strobe loop is running the other two lights remain off. At least the way I have developed the code so far.

while True:

   #helicopter lights on sequence,cab_lit,stb_lit,pos_lit,lnd_lit
   GPIO.setup(cab_lit, GPIO.HIGH)

  time.sleep(3)

  objled_test.start() <--- this piece of the puzzle (strobe) needs to continue to run as the sequence of events continues. The code is an example of a failed attempt.

  GPIO.setup(pos_lit, GPIO.HIGH)

  time.sleep(3)

  GPIO.setup(lnd_lit, GPIO.HIGH)

  time.sleep(3)

   # helicopter lights off sequence,lnd_lit,pos_lit,stb_lit,cab_lit
   GPIO.setup(lnd_lit, GPIO.LOW)

  time.sleep(3)

  GPIO.setup(pos_lit, GPIO.LOW)

  time.sleep(3)

  objled_test.stop()

  GPIO.setup(cab_lit, GPIO.LOW)

  time.sleep(3)

Intergrated into this will be sound and motor control. I broke the animation into three components, light sound and motors. I'm working the light part now and add the others after that is equipped.

To calculate the number of loops in your while statement:

Suppose your strobe flashes 2 times per second (when it is flashing). In 2 minutes it would have flashed 240 times.

If it toggles on or off in each loop you would need 480 loops, with a 0.25 second delay at the end of each loop to make the 480 loops last 2 minutes.

Suppose you want the strobe to be flashing for 10 seconds at the 1 minute mark and off the rest of the time.

If the loop count is > 240 and < 280 then toggle the strobe LED on or off on each count else turn the strobe LED off

Suppose you want the cabin lights on after 10 seconds and off after 100 seconds.

If the count is > 40 and < 400 turn the cabin LEDs on else turn them off.

For any of/off event you just choose at which count it needs to happen and use an if statement to make it happen, even the strobe flashing on and off events..

Hi Sean,

I think dougw 's idea is on spot and is the easiest to do without having to use timers, threads or a complex secs/micros/millis calculation. The key here is deciding the delay for each loop (a delay common enough for all actions to be a "factor" of such delay) and be creative on the math of how many loops you want and how you want to handle each action. e.g.:

The "roug" example below will do the following

• Blink ON or OFF a GREEN_LED, 1 second each state
• Blink ON or OFF a RED_LED, 5 seconds each state
• Engine -the following repeats every 100 seconds:
  • Seconds 0 to 19, the ENGINE is OFF
  • Seconds 20 to 34, the ENGINE will start accelerating
  • Seconds 35 to 80, the ENGINE will turn ON at full speed
  • Second 90 to 99, the ENGINE is OFF
• The GREEN_LED and RED_LED sequence will act independently (doesn't matter what the engine sequence is doing)

#Initialization
cycleCounter = 0
totalCycles = 100
#RED_LED OFF
#GREEN_LED OFF
#ENGINE OFF

while True:
     if cycleCounter % 2 == 0:
          #Turn GREEN_LED ON
     else:
          #Turn GREEN_LED OFF

     if (cycleCounter // 5) % 2 == 0:
          #Turn RED_LED ON
     else:
          #Turn RED_LED OFF

     if cycleCounter >= 20:
          #Turn ENGINE ON acceleration
     elif cycleCounter >= 35:
          #Turn ENGINE ON FULL SPEED
     elif cycleCounter >= 90:
          #Turn ENGINE OFF

     cycleCounter = (cycleCounter + 1) % totalCycles
     time.sleep(1)    

Luis

Thank you for chiming in.

I've been struggling to get my head around dougw suggestion. Does my thinking align with this paraphrase of the method: all actions of LEDs, sound and motors are governed by the value of a counter. Each action required tests the value of the counter if true/false of test perform action (on/off, start/stop). The counter just cycles.

How do I get granular control of the strobe light on & off time.  My current line of thinking this code

def flashHZ (GPIO1):

  GPIO.output(GPIO1, GPIO.HIGH)  ## set HIGH (LED ON)
   time.sleep(.05)  ## wait
   GPIO.output(GPIO1, GPIO.LOW)  ## set LOW (LED OFF)
   time.sleep(.8)  ## wait
   return

gives me the optimal flash.

Break.Break...

How did you display you code so cleanly in your post? The numbering and ability to scroll within the message is ideal. Can you share your insight?

Hi Sean,

The granularity of the strobe as you describe will work but it has a flaw. While flashHZ is being executed the rest of the code will be on hold. If you want the program to do something else at the same time it won't work as you expect it (you'll need threading for that). The problem with threading is, it may help you accomplish what you need but eventually the threads may be out of sync as threading is asynchronous (the Pi will be executing other tasks at the same time) so they won't execute precisely on a given amount of time, also threading may be more complex to manage.

Going back to your example, the idea is to find a common factor to all the actions that will easily help you calculate intervals for all your actions. From your example, the shortest action requires 1/20 seconds (0.05), that may be your delay for each iteration, and every other action will be a factor of thas number, see below:

#Initialization  
cycleCounter = 0  
totalCycles = 16 # A factor of 16 (16, 32, 48, 64, etc) so the cycle starts over
GPIO.output(GPIO1, GPIO.LOW)  
  
while True:  
  if cycleCounter % 16 == 0:
    GPIO.output(GPIO1, GPIO.HIGH)
  else:  # 0.05 * 16 = 0.8 (the delay required while off)
    GPIO.output(GPIO1, GPIO.LOW)

  cycleCounter = (cycleCounter + 1) % totalCycles  
  time.sleep(.05)

And, to display the code I used the Syntax Highlight and used Tab to align it (spaces work too)

Luis

G'Day,

I have been concentrating on the threading option following some of glennvanderveer suggestions. I speculating this is not a complicated program so have a thread run for 30secs and then stopping it might be doable. Now if I could just get the thread to stop:)

Thanks for the cut and paste on inserting code. I will definitely use the feature. Making it easy for readers to view code is one step to improving the chances of getting an answer.