, where I experimented with Markov chains—an old ancestor to current machine learning. 

It's fascinating to see how these simple stochastic models have laid the groundwork for modern AI. Markov chains, named after the mathematician Andrey Markov, are mathematical systems that hop from one "state" (a situation or set of values) to another. They are based on the assumption that future states depend only on the current state, not on the sequence of events that preceded it. 

Markov chains predict the next state of a system based solely on its current state, not the sequence of events that preceded it. They're particularly fascinating when you dive into the mathematics, which involves predicting state changes using matrix multiplication.

For example, consider a simple scenario using the words "this" and "that". Each letter represents a state, and the transitions between letters can be modeled with probabilities. Given "t" starts a word, the next letter will be "h" with certainty, followed by a split chance between "i" and "a". By counting these outcomes, we establish a predictive model: starting with "th", the following letter could be 'a' or 'i', each with equal probability, based on our dataset.

On my old website there was an input where you could enter a seed word and it would spit out a sentence.

This dataset helps our model output variations like "this", "that", "thit", and "thas". This simple yet powerful method of matrix multiplication underlies much of the predictive capability in more complex systems today.

Fast forward to today, and the landscape of AI has transformed with the introduction of models like GPT-4, developed by OpenAI. Unlike Markov chains, which use a simple state transition system, transformers use a sophisticated mechanism called 'attention' to weigh the relevance of different parts of the input data. This allows them to generate human-like text that understands context at a much deeper level.

Transformers changed machine learning by focusing on this 'attention' mechanism rather than simply predicting the next element. They assess the entire input sequence and determine which parts are most relevant for generating accurate and contextually appropriate outputs. This approach is vastly more effective for tasks that require understanding of complex patterns, like natural language processing or image recognition.

Here’s a an example of how a modern transformer model operates:

# Initialize a simple text generation model
generator = pipeline('text-generation', model='gpt-2')

# Generate text
generated_text = generator("Today, the weather is", max_length=30)
print(generated_text[0]['generated_text'])

While they are simplistic, their underlying principle—that the future is dependent only on the present—paved the way for the evolution of predictive models in AI. This idea, expanded and refined, eventually contributed to the development of neural networks, which mimic the way human brains operate. 

Today's AI  is dominated by models known as transformers, which, unlike their predecessors, focus on the mechanism of 'attention'—deciding which parts of input data are most relevant. This concept is crucial for tasks that involve understanding or generating human-like text. GPT-4, a model developed by OpenAI, is a prime example of this technology. It utilizes a very complex architecture based on transformers to generate text that can be astonishingly human-like.

Markov Chains 

Using a Dual H Bridge DC Stepper Motor Drive

 (Skip if you want to just get things connected) The curiosity rover I am building requires the use of larger than usual motors. This means I can’t use small 1-inch motors that you find in most RC cars. This also means that the power requirements for each motor is far more than a motor shield can handle.

You have a properly sized motor-to-power-supply ratio

Basic understanding electronics and polarity

The specs for each of these motor drives:

Dual H bridge drive
Chip: L298N
Logical voltage: 5V
Drive voltage: 5V-35V
Logical current: 0mA-36mA
Drive current: 2A(MAX single bridge)
Storage temperature: -20 to +135
Max power: 25W



The motor driver I’m using is the L298N Dual H Bridge Driver driver.

For reference I have labeled the pins on this board.

The jumper that connects motor voltage to logic allows you to power the chip with the motor voltage. If you’re using 7-volts or less to power your motors you don’t to wire+5 volt terminal, just leave the jumper in place.

The enable pin jumpers put each respective motor in a “ready to run” state. Whenever voltage is applied to a motor’s enable pin, the motor will run. Use this option if you don’t want to control the speed of the motors.

I’m using a 6-volt battery, so I leave the jumper in place to power both the motor and logic from the same source. Connect the positive power source to the left power terminal, and the negative to the middle ground terminal.

In DC circuits, red typically indicates positive and black for negative

Connect the wires to the power source too. I use terminal blocks as I tend to have many wires.

Connect wires to Motor A IN1 and Motor a IN2

Connect those wires to the GPIO pins on the Pi. The physical pin numbers are 16 and 18.

I’ll be referencing the pins according to their physical numbering. In other places the pins might be referred to by their software number (e.g. physical pin 16 is GPIO23)

Then connect the motor to the Motor A terminals. It does not matter which of the Motor A terminals red or black are connected to, the beauty of the H Bridge is that it will reverse motor direction depending on which IN pin has power.

That’s it for wiring and hardware! Now we have to get the software connected.

If you haven’t used python on your pi yet, you should install it now by running this command in your terminal

Then run this command to install GPIO itself:



You will probably be prompted to confirm that you want to install, type 

Once Rpi GPIO is installed you can import it into an IDLE script or a python script.

# We're using the physical board pin numbers

GPIO.setmode(GPIO.BOARD)

# define which pins we are driving the L298N with

DirectionOnePin = 16

DirectionTwoPin = 18

# Define how we are using these pins

GPIO.setup(DirectionOnePin, GPIO.OUT)

GPIO.setup(DirectionTwoPin, GPIO.OUT)



 doesn’t run the motors, it only configures the GPIO interface to use those pins as output pins.

To run the motors add these lines to your script

print "Motor A Direction one"
GPIO.output(DirectionOnePin, GPIO.HIGH)

time.sleep(2)

GPIO.output(DirectionOnePin, GPIO.LOW)

print "Motor A Direction two"
GPIO.output(DirectionTwoPin, GPIO.HIGH)

time.sleep(2)

GPIO.output(DirectionTwoPin, GPIO.LOW)

# This command clears the configuration from the GPIO interface
GPIO.cleanup()



That’s it! Now you should be able to run the script via the command `sudo python myscript.py`, with `myscript` being whatever you named the file. If you wrote the program in IDLE you can click the run button.

In the next tutorial I’ll explain how to use PWM To control the speed of a motor connected to this driver.

DRIVING A DC MOTOR WITH RASPBERRY PI AND DUAL H BRIDGE L298N 

I thought it would be fun to build a rover for myself. Naturally there are significant limitations on what I have the time and resources to build, so it will have to be a bit smaller.

I’ve learned over the years that planning ahead is the best path to getting results. Whether it’s taking 10 minutes to draw a sketch on a napkin, or a complete 3D cad prototype, you can solve some problems pretty quickly in the virtual space that you would have run into later. A good example of that is the “knees” on the real curiosty rover. You can see there is what appears to be a motor and a large-diameter joint.

After mocking up my planned rover I couldn’t find an effective way to put an actual motor inside something that looked similar, at the scale I would be building. So I decided that wasn’t going to be part of my rover. Here’s a draft of the rover I made before I did anything:

At this point I’ve put together a basic prototype, written a primitive python application to control the rover from the command line. Here are some pics of the current progress to the rover.

Axles articulate independently so the rover can drive in parallel, sideways, or crab-walk mode.

I may have gone too large with the 6v battery, but I loath short battery life.

The brains are a simple Raspberry Pi 3, a 16-servo Adafruit hat drives the servos, and the wheels are powered by the motor driver.

Stay tuned for updates. I plan to add walk-through’s showing how to spin-up a quick HTTP server for the rover, and how I wrote the python libraries to easily control the rover.

Please leave any comments or questions below. I’d love to hear what you’re interested in learning more about.

Chad Linden - Blog

CURIOSITY ROVER GARAGE BUILD

More Stories

Markov Chains

DRIVING A DC MOTOR WITH RASPBERRY PI AND DUAL H BRIDGE L298N