RE: L298 and Interfacing w/ the BBB/Trying!

On Fri, 4 May 2018 13:09:42 -0700 (PDT), Mala Dies
<functt@gmail.com> declaimed the following:

Hello Sir,

Seth here. Please view this photo of my L298 Board:

<https://lh3.googleusercontent.com/-onhva_QOKrI/Wuy9QwO6QnI/AAAAAAAAJ6k/ip5cNEuXMeMjSIlxKovrNnVpKw6EYPcjgCLcBGAs/s1600/L298%2BBoard.jpg>

Sir,

Hello...this is the board. I read over the ideas you prompted me to
understand. I will read the spec. sheet again (over and over). I realize I
was missing ideas relating to this board. Thank you for bringing it to my
attention.

  Looking at that (some labels are covered by the wires -- I can't read
the labels of the three ports on the left; I'm presuming those are power
source for the motors). I think I can safely say there are not enough
control wires to do anything!

  For the middle jumper posts...

  I don't know about the 5V posts, and for the time being, take out the
ENB lead.

  For the motor connected to OUT1/OUT2 you need to have leads on ENA, AND
you need connections to both IN1 and IN2 (you may need to jumper the 5V pin
to a source of 5V). IN1 and IN2 are the forward (High/Low)/stop (High/High
or Low/Low)/reverse (Low/High) control, which is only active if ENA is High

On Fri, 4 May 2018 18:49:43 -0700 (PDT), Mala Dies
<functt@gmail.com> declaimed the following:

P.S. Three wires! Okay. I will set up three GPIO pins for this specific
motor driver. I would have not figured out that I would have needed three
wires for this specific board. Thank you, sir.

  Three wires PER MOTOR (though you /could/ use one for both ENA and ENB
if you will always be controlling both at the same time -- using separate
controls for them would let you "idle" a motor rather than locking it in a
hard stop).

Okay Sir,

I am going to set up one motor first, get that one motor working, and then use similar software to run both motors. Thank you for the pointers. I was unaware of each motor needing three wires from the BBB to the motor driver for forward, reverse, and backwards.

Seth

P.S. I will keep you updated w/ what happens on the first motor software. I will post it in here once completed. Yea boy!

Hello Sir,

Seth here. You have got a good set of shoulders on your head. This was my issue and you walked me through it. Thank you sir. See this software:

`

import Adafruit_BBIO.GPIO as GPIO
import time

MotorOne = “P9_21”, “P9_22”, “P9_12”

GPIO.setup(“P9_21”, GPIO.OUT)
GPIO.setup(“P9_22”, GPIO.OUT)
GPIO.setup(“P9_12”, GPIO.OUT)

EnA = GPIO.output(“P9_21”, GPIO.HIGH)
ln1 = GPIO.output(“P9_22”, GPIO.LOW)
ln2 = GPIO.output(“P9_12”, GPIO.LOW)

EnA = GPIO.output(“P9_21”, GPIO.HIGH)
ln1 = GPIO.output(“P9_22”, GPIO.LOW)
ln2 = GPIO.output(“P9_12”, GPIO.HIGH)

while True:

try:
for i in range (0, 9):
motorOne = (“P9_21”, “P9_22”, “P9_12”)
time.sleep(3)
print “EnA”, “\tln1”, “\tln2”
#for move in range (0, 9):
#ln1 = (“P9_22”)
#ln2 = (“P9_12”)
#time.sleep(3)
#print “ln1”, “\tln2”

except(KeyboardInterrupt):

print “You have just ended your camping trip!”
GPIO.cleanup()
quit()

`

This software makes one motor go in one direction so far. I am sure I can figure out more but this is “as-is” for now. I listened to your commands and your intentions. You have helped.

Seth

P.S. I guess I should make this motor understand what it needs to do from the BBB more and more until the motor can get commanded via control, e.g. PS2 controller or small remote, application online, or via just one random, completed set of software instructions.

On Fri, 4 May 2018 22:01:02 -0700 (PDT), Mala Dies
<functt@gmail.com> declaimed the following:

Okay Sir,

I am going to set up one motor first, get that one motor working, and then
use similar software to run both motors. Thank you for the pointers. I was
unaware of each motor needing three wires from the BBB to the motor driver
for forward, reverse, and backwards.

  The three wires are one for enable, and two together that control
direction (it is not one wire for forward and one for reverse -- High/Low
is one direction, Low/High is the other direction, and when High/High OR
Low/Low it is STOP).

  Consider if you connected the motor directly to a battery -- one wire
is + the other is -; to reverse the motor direction you have to swap the +
and - leads... That's what the High/Low vs Low/High combination is doing --
telling the controller to swap the power through the driver transistors.
The Enable acts like a power switch in-line with one of the wires.

https://en.wikipedia.org/wiki/H_bridge (the controller IC is smart enough
to prevent the short-circuit condition)

Hello Sir,

Seth here, again. Thank you very much for your words. The ideas you have shared have helped thus far. I have been able to make my motor turn. Here is some software that may make no sense but I will keep on trying:

`

import Adafruit_BBIO.GPIO as GPIO
import time
from time import sleep

EnA = “P9_21”
ln1 = “P9_22”
ln2 = “P9_12”

print “Initialize”

GPIO.setup(“P9_21”, GPIO.OUT)
GPIO.setup(“P9_22”, GPIO.OUT)
GPIO.setup(“P9_12”, GPIO.OUT)

GPIO.output(“P9_21”, GPIO.LOW)
GPIO.output(“P9_22”, GPIO.LOW)
GPIO.output(“P9_12”, GPIO.LOW)

while True:

for i in range(10):
EnA = GPIO.output(“P9_21”, GPIO.HIGH)
for i in range(3):
ln1 = GPIO.output(“P9_22”, GPIO.HIGH)
for i in range(5):
ln2 = GPIO.output(“P9_12”, GPIO.HIGH)
for i in range(4):
ln1 = GPIO.output(“P9_22”, GPIO.LOW)
for i in range(10):
EnA = GPIO.output(“P9_21”, GPIO.LOW)
print “Go, Go Bananas!”

try:

except KeyboardInterrupt:
print “I got it over w/!”
GPIO.cleanup()
quit(sleep)

`

I think this may just make the motor turn at a very slow pace. I stop the software and the motor turns at a regular pace. W/ this software, I have not been able to turn the motor in reverse yet. I will change up the software soon.

Seth

P.S. If you see where the software is defaulting to an error, please let me know. It runs but it does not do what I would have expected it to do (thus far).

Hello Sir,

I am starting to understand more of what you were describing to me. Look here:

`

import Adafruit_BBIO.GPIO as GPIO
import time

Master_Pin = “P9_21”
ln1 = “P9_22”
ln2 = “P9_12”

if name==“main”:

GPIO.setup(Master_Pin, GPIO.OUT)
GPIO.output(Master_Pin, GPIO.LOW)

GPIO.setup(ln1, GPIO.OUT)
GPIO.setup(ln2, GPIO.OUT)

GPIO.output(Master_Pin, GPIO.HIGH)
GPIO.output(ln1, GPIO.HIGH)
GPIO.output(ln2, GPIO.LOW)
time.sleep(5)

GPIO.output(Master_Pin, GPIO.HIGH)
GPIO.output(ln1, GPIO.LOW)
GPIO.output(ln2, GPIO.HIGH)
time.sleep(5)
print “I love your body Larry!”

GPIO.output(Master_Pin, GPIO.LOW)

GPIO.output(Master_Pin, GPIO.LOW)
GPIO.cleanup()

`

Thank you again for your help.

Seth

On Sun, 6 May 2018 14:20:17 -0700 (PDT), Mala Dies
<functt@gmail.com> declaimed the following:

while True:

   for i in range(10):
       EnA = GPIO.output("P9_21", GPIO.HIGH)

  1) the variable names on the left of useless as they are never
referenced anywhere else in the code.

  2) this loop just sets the pin to the SAME VALUE 10 times in a row.

   for i in range(3):
       ln1 = GPIO.output("P9_22", GPIO.HIGH)

  3 times, same value

   for i in range(5):
       ln2 = GPIO.output("P9_12", GPIO.HIGH)

  5 times...

   for i in range(4):
       ln1 = GPIO.output("P9_22", GPIO.LOW)

  4 times...

   for i in range(10):
       EnA = GPIO.output("P9_21", GPIO.LOW)
       print "Go, Go Bananas!"

  10 times, with a repeated print statement.

  The total effect condenses down to (and to make it more clear, I'm
going to set up "constants" for the pins):

ENA = "P9_21"
IN1 = "P9_22"
IN2 = "P9_12"
# I'm presuming the default startup state is all GPIO's LOW, but one
#should check the documentation for the BBB to confirm
while True:
  GPIO.output(ENA, GPIO.HIGH) #enable motor control, motor in STOP
  time.sleep(0.1) #or however long 10 calls to GPIO_output consume
  GPIO.output(IN1, GPIO.HIGH) #motor running FORWARD
  time.sleep(0.03) #or however long 3 calls takes to execute
  GPIO.output(IN2, GPIO.HIGH) #motor in STOP
  time.sleep(0.05) #or whatever 5 calls takes
  GPIO.outputIN1, GPIO.LOW) #motor running REVERSE
  time.sleep(0.04) #or whatever 4 calls takes
  GPIO.output(ENA, GPIO.LOW) #motor coasting to stop
  time.sleep(0.2) #assumes 10 calls and 10 prints

  Note that, since the state was REVERSE when you disabled control, the
next pass of the loop will START in REVERSE when you enable control. THEN
when you set IN1 to HIGH, the motor will go to hard stop (since IN2 is
still HIGH from the first time through the loop). It will stay in STOP
until you set IN1 to LOW, when it again will run in REVERSE until the ENA
is turned off.

All worked out now as part of https://www.hackster.io/silver2row/beaglebone-black-and-l298-motor-driver-in-python-2156be ?

Good timing as BeagleBoard.org Motor Cape (https://github.com/beagleboard/capes/blob/master/beaglebone/designs/Motor/Motor_Cape_sch.pdf, https://beagleboard.org/capes) is about to start shipping to distributors. It’ll likely go out in about 2 weeks, depending on when I get https://github.com/jadonk/beagle-tester updated for it.

Yes Sir,

I got a fellow zmatt, Mr. Dennis, and a fellow on Adafruit-Forums all to give advice. Although I ended up taking another route, they all had supportive advice I could follow and adhere to.

Seth

P.S. Thank you for the ideas and new Capes. I got two on backorder as I type this message out. I got the LoadCape and RelayCape. I will get the MotorCape later. I even signed up for your presentation you plan on making in the form of a webinar on Element14.

Hello Mr. Dennis,

Seth here. I made some other software that I want to try to describe to you. Here goes it:

`

import Adafruit_BBIO.GPIO as GPIO
import time
from time import sleep

EnA = “P9_21”
ln1 = “P9_22”
ln2 = “P9_12”

print “Initialize”

GPIO.setup(“P9_21”, GPIO.OUT)
GPIO.setup(“P9_22”, GPIO.OUT)
GPIO.setup(“P9_12”, GPIO.OUT)

GPIO.output(“P9_21”, GPIO.LOW)
GPIO.output(“P9_22”, GPIO.LOW)
GPIO.output(“P9_12”, GPIO.LOW)

while True:

for i in range(1):
EnA = GPIO.output(“P9_21”, GPIO.HIGH)
time.sleep(2)
for i in range(1, 9):
ln1 = GPIO.output(“P9_22”, GPIO.HIGH)
ln2 = GPIO.output(“P9_12”, GPIO.LOW)
time.sleep(2)
for i in range(1, 7):
ln1 = GPIO.output(“P9_22”, GPIO.LOW)
ln2 = GPIO.output(“P9_12”, GPIO.HIGH)
time.sleep(2)
for i in range(1):
EnA = GPIO.output(“P9_21”, GPIO.LOW)
time.sleep(2)
print “Go, Go Bananas!”
for i in range(1):
EnA = GPIO.output(“P9_21”, GPIO.HIGH)
time.sleep(1)
for i in range(1):
ln1 = GPIO.output(“P9_22”, GPIO.HIGH)
ln2 = GPIO.output(“P9_12”, GPIO.LOW)
time.sleep(2)
for i in range(1):
EnA = GPIO.output(“P9_21”, GPIO.LOW)
ln1 = GPIO.output(“P9_22”, GPIO.LOW)
ln2 = GPIO.output(“P9_12”, GPIO.LOW)
time.sleep(2)

try:
print “Um…what is happening?”
time.sleep(2)

except(KeyboardInterrupt):
print “I got it over w/!”
GPIO.cleanup()
quit()

`

Okay…

This software imports a library. Got this fact. I then import time and sleep “If I choose to use it later” from time.

Then, I label my pins for future software.

Then, I set up my GPIO and then I set those pins as outputs (all LOW for initialization). Then, I a set up a while loop and while those facts are true, it runs.

The software states…

The EnA pin starts, w/ a HIGH, the motor and turns it on.

Then, the software sleeps (pauses) and I run one motor one direction and then the software goes into hibernation. Then…

The software runs the motor the opposite direction and then pauses. The EnA pin runs LOW and halts the motor from going any direction.

Then, the EnA pin runs HIGH once more. This creates the motor to initialize. Then, I run the motors one more time in one direction.

Then, I run all pins LOW to halt the motor and create all leads to understand that it is in stop mode.

Seth

P.S. Although this is a ton of “then…then…then,” I think I am starting to understand more. You have helped greatly. If this is not such an annoyance, do not hesitate to reply. If you are done w/ me and this conversation, please just kindly let me know. Thank you, sir.

On Tue, 8 May 2018 11:43:56 -0700 (PDT), Mala Dies
<functt@gmail.com> declaimed the following:

Hello Mr. Dennis,

Seth here. I made some other software that I want to try to describe to
you. Here goes it:

   for i in range(1):
       EnA = GPIO.output("P9_21", GPIO.HIGH)
       time.sleep(2)
   for i in range(1, 9):
       ln1 = GPIO.output("P9_22", GPIO.HIGH)
       ln2 = GPIO.output("P9_12", GPIO.LOW)
       time.sleep(2)

  You still seem to think FOR loops do something magical -- but there is
no data changing state inside these loops, so nothing changes during the
looping. And you still have the meaningless assignments -- you aren't using
the "labels" you created for the pins.

  Everything inside the WHILE loop condenses down to:

  GPIO.output(ENA, GPIO.HIGH) #motor enabled, stopped
  time.sleep(2)
  GPIO.output(IN1, GPIO.HIGH) #motor running, forward
  GPIO.output(IN2, GPIO.LOW) #NOP
  time.sleep(2*8) #range(1,9) is 1, 2, 3, 4, 5, 6, 7, 8
  GPIO.output(IN1, GPIO.LOW) #motor stopped, hard
  GPIO.output(IN2, GPIO.HIGH) #motor running, reverse
  time.sleep(2*6)
  GPIO.output(ENA, GPIO.LOW) #motor stopped, coasting
  time.sleep(2)
  print ...
  GPIO.output(ENA, GPIO.HIGH) #motor enabled, running, reverse
  time.sleep(1)
  GPIO.output(IN1, GPIO.HIGH) #motor stopped, hard
  GPIO.output(IN2, GPIO.LOW) #motor running, forward
  time.sleep(2)
  GPIO.output(ENA, GPIO.LOW) #motor stopped, coasting
  GPIO.output(IN1, GPIO.LOW) #motor still stopped
  GPIO.output(IN2, GPIO.LOW) #motor still stopped, all pins OFF
  time.sleep(2)

  Oh, and since you did "from time import sleep" you could replace all
those "time.sleep" with just "sleep".

Hello Sir,

Seth here. Okay, I am getting it more slowly than I planned. You are correct, the for loops do not hold some secret crest (they are not magical). I understand. I came from a small background in another library where similar software was typed up to fit the small library I was using. In this case, no biggie.

Anyway, I used an if-else statement for programming this time. I am starting to see, while this motor turns, what the different types of software will do and how the changed set up will sit well or go against the motor revolutions.

I am using sleep now instead of time.sleep, esp. since you let me know about my import of sleep from time. If you want to look over this software and reply, by all means, please do. If not, I understand. This software created the motor to turn after initializing and then went into a rough stop. Afterwards, the motor turned in the opposite direction. The program ended and the motor stopped, i.e. unlike w/ the while loop and the for loop. Oh, here is that odd software from my side:

`

import Adafruit_BBIO.GPIO as GPIO
from time import sleep

EnA = “P9_21”
ln1 = “P9_22”
ln2 = “P9_12”

print “Initialize”

GPIO.setup(“P9_21”, GPIO.OUT)
GPIO.setup(“P9_22”, GPIO.OUT)
GPIO.setup(“P9_12”, GPIO.OUT)

if EnA != GPIO.output(“P9_21”, GPIO.HIGH):
ln1 = GPIO.output(“P9_22”, GPIO.HIGH)
ln2 = GPIO.output(“P9_12”, GPIO.LOW)
sleep(2)

ln1 = GPIO.output(“P9_22”, GPIO.LOW)
ln2 = GPIO.output(“P9_12”, GPIO.HIGH)
sleep(2)

ln1 = GPIO.output(“P9_22”, GPIO.LOW)
ln2 = GPIO.output(“P9_12”, GPIO.LOW)
sleep(2)
print “I am here now!”

else:

for i in range(1, 9):
EnA = GPIO.output(“P9_21”, GPIO.HIGH)
ln1 = GPIO.output(“P9_22”, GPIO.LOW)
ln2 = GPIO.output(“P9_12”, GPIO.HIGH)

EnA = GPIO.output(“P9_21”, GPIO.HIGH)
ln1 = GPIO.output(“P9_22”, GPIO.HIGH)
ln2 = GPIO.output(“P9_12”, GPIO.LOW)
sleep(0.2)

EnA = GPIO.output(“P9_21”, GPIO.LOW)
ln1 = GPIO.output(“P9_22”, GPIO.HIGH)
ln2 = GPIO.output(“P9_12”, GPIO.HIGH)
sleep(0.2)
print “I am still almost there!”

try:
EnA = GPIO.output(“P9_21”, GPIO.OUT)
print “time.sleep(3)”

except(KeyboardInterrupt):
print “I got it over w/!”
GPIO.cleanup()
quit()

`

If you get tired of extra software correction, let me know. I can stop sending over all this software and my lack of knowledge on Python, embedded applications, and the BBB. But, if this still interests you, please reply. I can always use more lessons and ideas.

Seth

P.S. Thank you for your time so far.

On Wed, 9 May 2018 16:17:36 -0700 (PDT), Mala Dies
<functt@gmail.com> declaimed the following:

  Your biggest admission "my lack of knowledge on Python," is probably
critical... I strongly suggest you study the Python Language Reference
Manual (unless things have changed, the standard Python documentation set
should have been included with the installer -- ActiveState Windows builds
them as regular help files; "man python" on Linux provides links to the
online version including a download page). The Beagleboard forum is not
really an appropriate venue for teaching one the basics of Python
programming.

  Actually -- read the standard documentation Tutorial (same place you
find the reference manual). You may also want to consider the tutor list:
https://mail.python.org/mailman/listinfo/tutor (NOTE: I do not follow the
tutor list). The tutor list would not be a place to ask BBB-specific
questions -- so, as I show at the end of this post, if you can dummy up
your problem code using print-statements and describe what you expect vs
what you are actually seeing, the tutor list could be most suited. Once the
logic flow reflects what you want the program to do, then plug in the BBB
specific stuff, and if the hardware doesn't follow the expectations, then
come here...

I am using sleep now instead of time.sleep, esp. since you let me know
about my import of sleep from time. If you want to look over this software
and reply, by all means, please do. If not, I understand. This software
created the motor to turn after initializing and then went into a rough
stop. Afterwards, the motor turned in the opposite direction. The program
ended and the motor stopped, i.e. unlike w/ the while loop and the for
loop. Oh, here is that odd software from my side:

  The "while" loop was useful -- to repeat the entire program. But the
"for" loops were meaningless.

  You could replace the "while" with a "for" which would mean you don't
need to use <ctrl-c> to exit -- you don't loop "forever" but for a specific
number of times.

for jnk in range(10):
  #rest of program

will run 10 times and then exit.

import Adafruit_BBIO.GPIO as GPIO
from time import sleep

EnA = "P9_21"
ln1 = "P9_22"
ln2 = "P9_12"

  The purpose of these is to provide named constants -- to be used where
ever the cryptic "Px_yy" notation appears later. A convention is to make
"named constants" all upper-case, as a hint that one should never put them
on the left side of an "=" later in the code.

  ENA = "P9_21"

print "Initialize"

GPIO.setup("P9_21", GPIO.OUT)
GPIO.setup("P9_22", GPIO.OUT)
GPIO.setup("P9_12", GPIO.OUT)

  Like here...

  GPIO.setup(ENA, GPIO.OUT)

etc. Using the named constant lets someone reading the code later
understand just what function is being affected, without having to note
where they are and look up elsewhere what the value ("P9_21") is associated
with.

  It is easy to mistype "P9_21" as "P9_12" and not notice (both are valid
values for a GPIO pin), but much harder to type "IN2" when it is supposed
to be "ENA".

if EnA != GPIO.output("P9_21", GPIO.HIGH):

  Third time: GPIO.output() does NOT RETURN A VALUE! This comparison is
comparing a string to Python's default function value of None

    "P9_21" != None

is always True.

   ln1 = GPIO.output("P9_22", GPIO.HIGH)
   ln2 = GPIO.output("P9_12", GPIO.LOW)
   sleep(2)

  Two seconds running in "forward"

   ln1 = GPIO.output("P9_22", GPIO.LOW)
   ln2 = GPIO.output("P9_12", GPIO.HIGH)
   sleep(2)

  Two seconds running in "reverse" (you don't buffer the motor by
stopping first)

   ln1 = GPIO.output("P9_22", GPIO.LOW)
   ln2 = GPIO.output("P9_12", GPIO.LOW)
   sleep(2)

  Two seconds hard stop before the print statement.

   print "I am here now!"

else:

  Never reached, all of the "else" block is dead code.

   for i in range(1, 9):
       EnA = GPIO.output("P9_21", GPIO.HIGH)
       ln1 = GPIO.output("P9_22", GPIO.LOW)
       ln2 = GPIO.output("P9_12", GPIO.HIGH)

       EnA = GPIO.output("P9_21", GPIO.HIGH)
       ln1 = GPIO.output("P9_22", GPIO.HIGH)
       ln2 = GPIO.output("P9_12", GPIO.LOW)
       sleep(0.2)

       EnA = GPIO.output("P9_21", GPIO.LOW)
       ln1 = GPIO.output("P9_22", GPIO.HIGH)
       ln2 = GPIO.output("P9_12", GPIO.HIGH)
       sleep(0.2)
       print "I am still almost there!"

try:
   EnA = GPIO.output("P9_21", GPIO.OUT)

  Pardon -- that should be LOW or HIGH, not OUT

   print "time.sleep(3)"

  And that statement does not sleep, it just prints a statement saying it
is sleeping

except(KeyboardInterrupt):
       print "I got it over w/!"
       GPIO.cleanup()
       quit()

  If you are using the try/except just to exit a non-exiting program, you
should really put the "try" at the start, around the rest of the main
program. Given where it is now, it will only be active while Python
executes the two statements inside the "try" block. Hitting <ctrl-c>
anywhere else in the program will just dump a traceback and do no cleanup.

  Also, your cleanup is ONLY called if the program is killed by <ctrl-c>
while IN the "try", it is not called if the program exits on its own from
lack of any statements to execute.

  Suggest you leave out all the GPIO manipulation and experiment with
just using "print" statements to get a program that pretends to do
something with the motor. When you get it to display what you want, then
start plugging in the GPIO and confirm that the motor behaves as you said
it should.

  Compare using "while":

On Thu, 10 May 2018 11:51:02 -0400, Dennis Lee Bieber
<wlfraed@ix.netcom.com> declaimed the following:

except (KeyboardInterrupt):
print "BREAK"
except:
print "Something unexpected happened"

  FYI: using a bare "except" is also frowned upon... especially as used
in this example -- it doesn't tell you WHAT happened. Better to just leave
it out of the code and let the regular traceback explain what happened (and
then add an except (xxx) to handle that specific problem).

Hello Sir,

Seth here. I will check out the Python language in more detail. I got caught up reading other material while trying to find fun in motors w/ Python.

Seth

P.S. I really appreciate all the confidence and examples. I will look into the python tutorials and try to understand your way of computing w/ the BBB, L298, and Python. Also, you are right, I should not be asking about Python oriented questions in our forum for the BBB. I will divert future questions of Python related material to other forums. Thank you, again.

Hello Sir,

Seth here. I wrote some new software for the item that was in question. The idea you told me earlier in this post did not click right away for me, e.g. pins are either High or Low. W/ my new software, I am running two motors now but the motors were not acting as expected and it was b/c of the some of P9 header pins not all being low/high when I was using them in a particular manner in the software, i.e. the same w/ the P8 header pins.

Seth

P.S. I found, instead of changing the pins to all High or to all Low, some available pins, six of them, on the P8 header that would suffice. Like I said, it did not click for me right away until today. So, I guess in the future, I will need a couple of weeks. Ha! Thank you again, sir.