# RSA Encryption

woE7ewVfwoAzbwXCgC5iMyRvBTvCgGBiOy4=
public key: e=5, n=133
```import random
import base64

'''
Euclid's algorithm to determine the greatest common divisor
'''
def gcd(a,b):
while b != 0:
c = a % b
a = b
b = c
return a

def egcd(a, b):
if a == 0:
return (b, 0, 1)
g, y, x = egcd(b%a,a)
return (g, x - (b//a) * y, y)

def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('No modular inverse')
return x%m

def encrypt(plaintext,keypair):
e,n = keypair

# Encrypt the plaintext
cipher = ''.join([chr(pow(ord(char),e,n)) for char in plaintext])
# Encode the ciphertext so it's more readable/sharable
encoded = base64.b64encode(cipher.encode('utf-8'))
return str(encoded,'utf-8')

def decrypt(ciphertext,keypair):
d,n = keypair

# Decode the text to the original format
decoded = base64.b64decode(ciphertext).decode('utf-8')
# Decrypt it
plain = (str(chr(pow(ord(char),d,n))) for char in decoded)
return ''.join(plain)

def generate_keypair(p,q,e=None):
n = p * q

#Phi is the totient of n
phi = (p-1)*(q-1)

#Choose an integer e such that e and phi(n) are coprime
if e is None:
e = random.randrange(1, phi)

#Use Euclid's Algorithm to verify that e and phi(n) are comprime
g = gcd(e, phi)
while g != 1:
e = random.randrange(1, phi)
g = gcd(e, phi)

#Now find the multiplicative inverse of e and phi to generate the private key
d = modinv(e, phi)

return ((e,n),(d,n))

#Only run this part if we're not running as an imported module
if __name__ == '__main__':
p = int(input("Enter prime number p: "))
q = int(input("Enter prime number q: "))

public, private = generate_keypair(p,q)

print("Your public key is the number pair of (e=" +  str(public[0]) + ", n=" + str(public[1]) +").\n")
print("Your private key is the number pair of (d=" +  str(private[0]) + ", n=" + str(private[1]) +").\n")

s = input("Enter your message: ")
encrypted = encrypt(s,public)

print("Encrypted message: " + encrypted)
decrypted = decrypt(encrypted,private)
print("Decrypt: " + decrypted)

```

# Python Computer Wiring

Since there’s dozens of Linux computers/boards you can use we will show wiring for Raspberry Pi. For other platforms, please visit the guide for CircuitPython on Linux to see whether your platform is supported.

Here’s the Raspberry Pi wired with I2C:

 Pi 3V3 to sensor VIN Pi GND to sensor GND Pi SCL to sensor SCK Pi SDA to sensor SDI

And an example on the Raspberry Pi 3 Model B wired with SPI:

 Pi 3V3 to sensor VIN Pi GND to sensor GND Pi MOSI to sensor SDI Pi MISO to sensor SDO Pi SCLK to sensor SCK Pi #5 to sensor CS (or use any other free GPIO pin)

# CircuitPython Installation of BMP280 Library

You’ll need to install the Adafruit CircuitPython BMP280 library on your CircuitPython board.

Next you’ll need to install the necessary libraries to use the hardware–carefully follow the steps to find and install these libraries from Adafruit’s CircuitPython library bundle.  Our CircuitPython starter guide has a great page on how to install the library bundle.

For non-express boards like the Trinket M0 or Gemma M0, you’ll need to manually install the necessary libraries from the bundle:

Before continuing make sure your board’s lib folder or root filesystem has the adafruit_bmp280.mpy, and adafruit_bus_device files and folders copied over.

Next connect to the board’s serial REPL so you are at the CircuitPython >>> prompt.

# Python Installation of BMP280 Library

You’ll need to install the Adafruit_Blinka library that provides the CircuitPython support in Python. This may also require enabling I2C on your platform and verifying you are running Python 3. Since each platform is a little different, and Linux changes often, please visit the CircuitPython on Linux guide to get your computer ready!

Once that’s done, from your command line run the following command:

• `sudo pip3 install adafruit-circuitpython-bmp280`

If your default Python is version 3 you may need to run ‘pip’ instead. Just make sure you aren’t trying to use CircuitPython on Python 2.x, it isn’t supported!

# CircuitPython & Python Usage

To demonstrate the usage of the sensor we’ll initialize it and read the temperature, humidity, and more from the board’s Python REPL.

If you’re using an I2C connection run the following code to import the necessary modules and initialize the I2C connection with the sensor:

1. import board
2. import busio
4. i2c = busio.I2C(board.SCL, board.SDA)

Or if you’re using a SPI connection run this code instead to setup the SPI connection and sensor:

1. import board
2. import busio
3. import digitalio
5. spi = busio.SPI(board.SCK, MOSI=board.MOSI, MISO=board.MISO)
6. cs = digitalio.DigitalInOut(board.D5)

Now you’re ready to read values from the sensor using any of these properties:

• temperature – The sensor temperature in degrees Celsius.
• pressure – The pressure in hPa.
• altitude – The altitude in meters.

For example to print temperature and pressure:

1. print(‘Temperature: {} degrees C’.format(sensor.temperature))
2. print(‘Pressure: {}hPa’.format(sensor.pressure))

For altitude you’ll want to set the pressure at sea level for your location to get the most accurate measure (remember these sensors can only infer altitude based on pressure and need a set calibration point).  Look at your local weather report for a pressure at sea level reading and set the seaLevelhPA property:

1. sensor.sea_level_pressure = 1013.25

Then read the altitude property for a more accurate altitude reading (but remember this altitude will fluctuate based on atmospheric pressure changes!):

1. print(‘Altitude: {} meters’.format(sensor.altitude))

That’s all there is to using the BMP280 sensor with CircuitPython!

Here’s a starting example that will print out the temperature, pressure and altitude every 2 seconds:

1. import time
2.
3. import board
4. # import digitalio # For use with SPI
5. import busio
6.
8.
9. # Create library object using our Bus I2C port
10. i2c = busio.I2C(board.SCL, board.SDA)
12.
13. # OR create library object using our Bus SPI port
14. #spi = busio.SPI(board.SCK, board.MOSI, board.MISO)
15. #bmp_cs = digitalio.DigitalInOut(board.D10)
17.
18. # change this to match the location’s pressure (hPa) at sea level
19. bmp280.sea_level_pressure = 1013.25
20.
21. while True:
22. print(“\nTemperature: %0.1f C” % bmp280.temperature)
23. print(“Pressure: %0.1f hPa” % bmp280.pressure)
24. print(“Altitude = %0.2f meters” % bmp280.altitude)
25. time.sleep(2)

# Chatroom Source

```import socket

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('0.0.0.0',25565))
s.listen(10)

while True:
print('waiting for new connection')

motd = "Welcome to PolyChat!"

char = ''
message = ''
while char != None and char != 'q':
char,temp = conn.recvfrom(1024)
char = char.decode('utf-8')
message += char
print(message)

conn.close()

```

# Platformer Python Code

```
import turtle, random,time
map = input('Select a map from 1-8 or press 9 for random map')
max = 8
map = int(map)
if map == max:
map = random.randint(1,max-1)
if map == 1:
mapName = "v"
if map == 2:
mapName = "d"
if map == 3:
mapName = "m"
if map == 4:
mapName = "a"
if map == 5:
mapName = "j"
if map == 6:
mapName = "e (1)"
if map == 7:
mapName = "t"
if map == 8:
mapName = "l"

charlist = ['rainbowbob','Kataniguana','yurp','REEE','Zhane','america','lightning','Goku','Symmetra','Dva','Junkrat2','Mercy','soldier']
print(charlist)
char1 = int(input('Player 1 Choose a character from the list.'))
char2 = int(input('Player 2 Choose a character from the list.'))
char1 = charlist[char1-1]
char2 = charlist[char2-1]

you = turtle.Turtle()
you.penup()
them = turtle.Turtle()
them.penup()
ball = turtle.Turtle()
screen = turtle.Screen()
screen.setup(400, 400)
direction = "up"
screen.bgpic(mapName+".png")
you.shape(char1+".png")
them.shape(char2+".png")
move_speed = 10

##MOVEMENT CODE FOR SPRITE 1 (YOU)
def up():
xold = you.xcor()
yold = you.ycor()
you.sety(you.ycor()+move_speed)
if you.ycor()> 200:
you.sety(-200)
print(str(you.xcor())+','+str(you.ycor()))
findbox(xold,yold)
def down():
xold = you.xcor()
yold = you.ycor()
you.sety(you.ycor()-move_speed)
if you.ycor()< -200:
you.sety(200)
print(str(you.xcor())+','+str(you.ycor()))
findbox(xold,yold)
def left():
xold = you.xcor()
yold = you.ycor()
you.setx(you.xcor()-move_speed)
if you.xcor()< -200:
you.setx(200)
print(str(you.xcor())+','+str(you.ycor()))
findbox(xold,yold)
def right():
xold = you.xcor()
yold = you.ycor()
you.setx(you.xcor()+move_speed)
if you.xcor()> 200:
you.setx(-200)
print(str(you.xcor())+','+str(you.ycor()))
findbox(xold,yold)
def jump():
up()
up()
up()
time.sleep(0.1)
down()
down()
down()

##MOVEMENT CODE FOR SPRITE 2 (THEM)
def up2():
xold2 = them.xcor()
yold2 = them.ycor()
them.sety(them.ycor()+move_speed)
if them.ycor()> 200:
them.sety(-200)
print(str(them.xcor())+','+str(them.ycor()))
findbox(xold2,yold2)
def down2():
xold2 = them.xcor()
yold2 = them.ycor()
them.sety(them.ycor()-move_speed)
if them.ycor()< -200:
them.sety(200)
print(str(them.xcor())+','+str(them.ycor()))
findbox(xold2,yold2)
def left2():
xold2 = them.xcor()
yold2 = them.ycor()
them.setx(them.xcor()-move_speed)
if them.xcor()< -200:
them.setx(200)
print(str(them.xcor())+','+str(them.ycor()))
findbox(xold2,yold2)
def right2():
xold2 = them.xcor()
yold2 = them.ycor()
them.setx(them.xcor()+move_speed)
if them.xcor()> 200:
them.setx(-200)
print(str(them.xcor())+','+str(them.ycor()))
findbox(xold2,yold2)
def jump2():
up2()
up2()
up2()
time.sleep(0.1)
down2()
down2()
down2()

def findbox(xold, yold):
if map == 1:
coords = [
[30,90,90,180],
[10,120,30,70],
[160,200,-10,70],
[-160,-20,20,70],
[-200,-180,20,80],
[-80,-10,100,180],
[-170,-120,100,200],
[-190,-100,-80,-30],
[-40,10,-90,-40]]
if map == 7:
coords = [
[10,180,-110,-70],
[10,180,-160,-120],
[10,180,-180,-160],
[-80,0,-180,-60],
[-190,-90,-170,-60],
[120,200,70,200],
[20,70,80,190],
[-160,-20,120,190],
[-170,-120,70,100],
[-120,-80,70,100],
[-70,-30,70,100]]

sprites = [you, them]
for i in sprites:
for j in coords:
if i.xcor() > j[0] and i.xcor() < j[1]:
if i.ycor() > j[2] and i.ycor() < j[3]:
print('you are in the box')
i.setx(xold)
i.sety(yold)

def fly(ball):
global direction
ball.hideturtle()
ball.setx(you.xcor())
ball.sety(you.ycor())
ball.pendown()
if direction == "up":
ball.sety(200)
if direction == "down":
ball.sety(-200)
if direction == "left":
ball.setx(-200)
if direction == "right":
ball.setx(200)
ball.penup()
ball.showturtle()

you.penup()
you.speed(0)
you.home()
you.left(90)

them.penup()
them.speed(0)
them.home()
them.left(90)

screen.onkey(up, "Up")
screen.onkey(down, "Down")
screen.onkey(left, "Left")
screen.onkey(right, "Right")
screen.onkey(jump,"Space")

screen.onkey(up2, "w")
screen.onkey(down2, "s")
screen.onkey(left2, "a")
screen.onkey(right2, "d")
screen.onkey(jump2,"x")
screen.listen()

```

# GPS Code for USB Receiver

```import serial
gpsPort = "/dev/ttyACM0"
gpsSerial = serial.Serial(gpsPort, baudrate = 9600, timeout = 0.5)

def parseGPS(data):
gps = data

try:
if gps[2:8] == "\$GNGGA":
gps = gps.split(",")

timeHour = (int(gps[1][0:2]) - 4) % 24
timeMin = int(gps[1][2:4])
timeSec = int(gps[1][4:6])
print("Time: " + str(timeHour) + ":" + str(timeMin) + ":" + str(timeSec))

latDeg = int(gps[2][0:2])
latMin = int(gps[2][2:4])
latSec = float(gps[2][5:9]) * (3/500)
latNS = gps[3]
print("Latitude:  " + str(latDeg) + "°" + str(latMin) + "'" + str(latSec) + '" ' + latNS)

longDeg = int(gps[4][0:3])
longMin = int(gps[4][3:5])
longSec = float(gps[4][6:10]) * (3/500)
longEW = gps[5]
print("Longitude:  " + str(longDeg) + "°" + str(longMin) + "'" + str(longSec) + '" ' + longEW)

alt = float(gps[9])
print("Altitude: " + str(alt) + " m")

sat = int(gps[7])
print("Satellites: " + str(sat))
if gps[2:8] == "\$GNRMC":
gps = gps.split(",")

speed = float(gps[7]) * 1.852
print("Speed: " + str(speed) + " km/h")

else:
gps = ""
except Exception as error:
print(error)

return gps
while True:
```

# Current Combined Code

```
import os
import picamera
import sense_hat
import time
import yagmail

camera = picamera.PiCamera()
camera.resolution = (1280, 720)
framerate = 5
camera.framerate = framerate
camera.annotate_text_size = 18

senseHat = sense_hat.SenseHat()

gps = "GPS Data"

def annotate():
timeNow = "Time: " + str(time.strftime("%a %d %b %Y %H:%M:%S", time.localtime()))
temperatureNow = "Temperature: " + str(round(senseHat.get_temperature())) + " C"
humidityNow = "Humidity: " + str(round(senseHat.get_humidity())) + "%"
locationNow = "Location: " +gps

annotation = timeNow + "\n" + temperatureNow + "\n" + humidityNow + "\n" + locationNow
return annotation

def getPicture(annotation):
filename = "/home/pi/Pictures/" + str(time.strftime("%Y-%m-%d@%H:%M:%S", time.localtime())) + ".jpg"

try:
camera.start_preview()
time.sleep(5)
camera.annotate_text = annotation
camera.capture(filename)
camera.stop_preview()
except Exception as error:
print(error)

return filename

def getVideo(length):
filename = "/home/pi/Videos/" + str(time.strftime("%Y-%m-%d@%H:%M:%S", time.localtime())) + ".mp4"

try:
camera.start_recording("/home/pi/testVideo.h264")

for index in range(length):
camera.annotate_text = (annotate())
time.sleep(1)

camera.stop_recording()
except Exception as error:
print(error)

os.system("ffmpeg -r " + str(framerate) + " -i /home/pi/testVideo.h264 -vcodec copy " + filename)

return filename

def sendMail(filename):
body = "Sent at " + str(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) + "."

try:

gmail.send(
subject = "Paul's Balloon",
contents = body,
attachments = filename
)
except Exception as error:
print(error)

print("Message sent.")

sendMail(getPicture(annotate()))
```

# Sending Emails in Python

Sending an email in Python with no attachments.

```import smtplib, ssl

smtp_server = "smtp.gmail.com"
port = 587  # For starttls
sender_email = "my@gmail.com"

# Create a secure SSL context
context = ssl.create_default_context()

try:
server = smtplib.SMTP(smtp_server,port)
server.ehlo() # Can be omitted
server.starttls(context=context) # Secure the connection
server.ehlo() # Can be omitted
# TODO: Send email here
except Exception as e:
# Print any error messages to stdout
print(e)
finally:
server.quit()
```

Snapping a still image in Python

```from picamera import PiCamera
camera = PiCamera()
camera.capture('/home/pi/Desktop/snapshot.jpg')
```

Raspberry Pi Camera Source

SENDING AN EMAIL WITH AN ATTACHMENT

```import email, smtplib, ssl

from email import encoders
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

subject = "An email with attachment from Python"
body = "This is an email with attachment sent from Python"
sender_email = "my@gmail.com"

# Create a multipart message and set headers
message = MIMEMultipart()
message["From"] = sender_email
message["Subject"] = subject
message["Bcc"] = receiver_email  # Recommended for mass emails

message.attach(MIMEText(body, "plain"))

filename = "document.pdf"  # In same directory as script

# Open PDF file in binary mode
with open(filename, "rb") as attachment:
part = MIMEBase("application", "octet-stream")

# Encode file in ASCII characters to send by email
encoders.encode_base64(part)

"Content-Disposition",
f"attachment; filename= {filename}",
)

# Add attachment to message and convert message to string
message.attach(part)
text = message.as_string()

context = ssl.create_default_context()
with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=context) as server:
```

USING YAGMAIL

```import yagmail

body = "Hello there from Yagmail"
filename = "document.pdf"

yag.send(
subject="Yagmail test with attachment",
contents=body,
attachments=filename,
)
```

pip3 install yagmail 🙂
Source

# Scheduling Scripts in CRON

## Setting up the Pi to run Python scripts

All right, your Pi is up and running, now you just need to configure it to run Python scripts.
The good news is: there’s not much to do if you are using Raspbian, as it has Python installed out of the box
One thing you can do is download the latest version, probably because Raspbian does not have the latest release. Head over to python.org, and upgrade if necessary.But other than this you are good to go. You can copy your existing .py files and start using them with the built in IDE or Terminal straight away. Speaking of which: if you are copying over files you used on Windows or OS X, remember that on Linux you’ll need a different shebang line. You probably know where to look this up, but here it is for reference:

• On Windows, the shebang line is `#! python3`.
• On OS X, the shebang line is `#! /usr/bin/env python3`.
• On Linux, the shebang line is `#! /usr/bin/python3`.
(shebang lines are the first lines in python script files that tells the system where to locate the interpreter)

Also, if you want to start scripts from the terminal there are a few extra steps to do:

• Place them .py files in your home folder
• Make them executable with the following command: `chmod +x script.py`
Now you can start a script by typing in `./script.py` to the terminal
(If you place them somewhere else than your home folder you will have to describe the whole path to start them)

## Automating scripts on the Pi with CRON

Now to the interesting part. So far we set up our Pi and started to run python scripts on it. But logging in through RealVNC or SSH every time we want a script to run is not really convenient (with the exception if we want to trigger scripts via SSH coming from another device or service automatically, but this will be detailed in another post).
If we have a web-scraping script that looks for some info on the web every day and returns some information (like the food notifier explained in my previous post), then what we want is total automation. The script should start all by it self, do it’s job, and return the information.
Luckily we can do that with a built in tool in Linux called CRON.

### How to setup CRON

• In the Terminal, enter `crontab -e`. If you want a command to run with system permissions, use the `sudo crontab -e` command to open the root account’s crontab file.
• You might be asked to select an editor. If this happens choose Nano (for me this was the default)
• You will be presented with the following screen:

Every line that starts with a `#` is just a comment and will be not executed.
• Use the arrows or Page Down to scroll down to the bottom of the page
• Each line you add here will be executed.

The format for the parameters is the following:
Minutes Hours Day of month Month Weekday Command
If you want to skip a parameter, just add `*` as input.

From the Raspberry Pi Official API:

Cron is a tool for configuring scheduled tasks on Unix systems. It is used to schedule commands or scripts to run periodically and at fixed intervals. Tasks range from backing up the user’s home folders every day at midnight, to logging CPU information every hour.

The command `crontab` (cron table) is used to edit the list of scheduled tasks in operation, and is done on a per-user basis; each user (including `root`) has their own `crontab`.

## Cron GUI

A graphical application for Cron is available by installing the `gnome-schedule`package:

``sudo apt-get install gnome-schedule``

You can then launch the program Scheduled Tasks from the main menu.

## Editing crontab

Run `crontab` with the `-e` flag to edit the cron table:

``crontab -e``

### Select an editor

The first time you run `crontab` you’ll be prompted to select an editor; if you are not sure which one to use, choose `nano` by pressing `Enter`.

The layout for a cron entry is made up of six components: minute, hour, day of month, month of year, day of week, and the command to be executed.

``# m h  dom mon dow   command``
``````# * * * * *  command to execute
# ┬ ┬ ┬ ┬ ┬
# │ │ │ │ │
# │ │ │ │ │
# │ │ │ │ └───── day of week (0 - 7) (0 to 6 are Sunday to Saturday, or use names; 7 is Sunday, the same as 0)
# │ │ │ └────────── month (1 - 12)
# │ │ └─────────────── day of month (1 - 31)
# │ └──────────────────── hour (0 - 23)
# └───────────────────────── min (0 - 59)``````

For example:

``0 0 * * *  /home/pi/backup.sh``

This cron entry would run the `backup.sh` script every day at midnight.

``crontab -l``

### Run a task on reboot

To run a command every time the Raspberry Pi starts up, write `@reboot` instead of the time and date. For example:

``@reboot python /home/pi/myscript.py``

This will run your Python script every time the Raspberry Pi reboots. If you want your command to be run in the background while the Raspberry Pi continues starting up, add a space and `&` at the end of the line, like this:

``@reboot python /home/pi/myscript.py &``

Raspbian API

Source

# KML Tutorial

 KML is a file format used to display geographic data in an Earth browser such as Google Earth. KML uses a tag-based structure with nested elements and attributes and is based on the XML standard. All tags are case-sensitive and must appear exactly as they are listed in the KML Reference. The Reference indicates which tags are optional. Within a given element, tags must appear in the order shown in the Reference. If you’re new to KML, explore this document and the accompanying samples files (SamplesInEarth) to begin learning about the basic structure of a KML file and the most commonly used tags. The first section describes features that can be created with the Google Earth user interface. These features include placemarks, descriptions, ground overlays, paths, and polygons. The second section describes features that require authoring KML with a text editor. When a text file is saved with a .kml or .kmz extension, Earth browsers know how to display it.

Tip: To see the KML “code” for a feature in Google Earth, you can simply right-click the feature in the 3D Viewer of Google Earth and select Copy. Then Paste the contents of the clipboard into any text editor. The visual feature displayed in Google Earth is converted into its KML text equivalent. Be sure to experiment with this feature.

All of the examples described here are in the KML Samples file. Begin by downloading that file to view the examples in Google Earth.

The KML 2.2 Reference provides details about the KML file format. If you’re familiar with XML, you will also be interested in the KML 2.2 Schema.

For a discussion of how to use some of the key features in KML, see the Developer’s Guide.

# Basic KML Documents

The simplest kind of KML documents are those that can be authored directly in Google Earth—that is, you don’t need to edit or create any KML in a text editor. Placemarks, ground overlays, paths, and polygons can all be authored directly in Google Earth.

## Placemarks

A Placemark is one of the most commonly used features in Google Earth. It marks a position on the Earth’s surface, using a yellow pushpin as the icon. The simplest Placemark includes only a <Point> element, which specifies the location of the Placemark. You can specify a name and a custom icon for the Placemark, and you can also add other geometry elements to it.

Open the KML Samples file in Google Earth and expand the Placemarks subfolder. This folder includes three different types of placemark: simplefloating, and extruded. The KML code for the simple placemark looks like this:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Placemark>
<name>Simple placemark</name>
<description>Attached to the ground. Intelligently places itself
at the height of the underlying terrain.</description>
<Point>
<coordinates>-122.0822035425683,37.42228990140251,0</coordinates>
</Point>
</Placemark>
</kml>```

The structure of this file breaks down as follows:

• An XML header. This is line 1 in every KML file. No spaces or other characters can appear before this line.
• A KML namespace declaration. This is line 2 in every KML 2.2 file.
• A Placemark object that contains the following elements:
• name that is used as the label for the Placemark
• description that appears in the “balloon” attached to the Placemark
• Point that specifies the position of the Placemark on the Earth’s surface (longitude, latitude, and optional altitude)

If you were wondering where the Placemark is, it’s right over Google’s Building 41, where we developed Google Earth!

What users commonly think of as a “placemark” in Google Earth is actually a <Placemark> element with a <Point> child in KML. A Point Placemark is the only way to draw an icon and label in the 3D Viewer of Google Earth. By default, the icon is the familiar yellow pushpin. In KML, a <Placemark> can contain one or more geometry elements, such as a LineString, Polygon, or Model. But only a <Placemark> with a Point can have an icon and label. The Point is used to place the icon, but there is no graphical representation of the Point itself.

## Descriptive HTML in Placemarks

The KML Samples file has an example of almost everything you can do with Placemark text. You can add links, font sizes, styles, and colors, and specify text alignment and tables. If you’d like to see the full list, copy and paste the “Descriptive HTML” Placemark example (in the Styles and Markup folder) into a text editor.

### Auto-Markup in Google Earth (Release 4.0 and later)

Google Earth 4.0 has an auto-markup feature that automatically converts text such as www.google.com into active hyperlinks that the user can click. Text inside the <description> tag, the <Snippet> tag, and the <text> element of <BalloonStyle> are all automatically transformed into standard HTTP hyperlinks. You don’t need to add the <a href= …> tags yourself.

### Using the CDATA Element

If you want to write standard HTML inside a <description> tag, you can put it inside a CDATA tag. If you don’t, the angle brackets need to be written as entity references to prevent Google Earth from parsing the HTML incorrectly (for example, the symbol > is written as &gt; and the symbol < is written as &lt;). This is a standard feature of XML and is not unique to Google Earth.

Consider the difference between HTML markup with CDATA tags and without CDATA. First, here’s the <description> with CDATA tags:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<Placemark>
<name>CDATA example</name>
<description>
<![CDATA[
<h1>CDATA Tags are useful!</h1>
<p><font color="red">Text is <i>more readable</i> and
<b>easier to write</b> when you can avoid using entity
references.</font></p>
]]>
</description>
<Point>
<coordinates>102.595626,14.996729</coordinates>
</Point>
</Placemark>
</Document>
</kml>
```

And here’s the <description> without CDATA tags, so that special characters must use entity references:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<Placemark>
<name>Entity references example</name>
<description>
&lt;h1&gt;Entity references are hard to type!&lt;/h1&gt;
&lt;p&gt;&lt;font color="green"&gt;Text is
and &lt;b&gt;easier to write&lt;/b&gt;
when you can avoid using entity references.&lt;/font&gt;&lt;/p&gt;
</description>
<Point>
<coordinates>102.594411,14.998518</coordinates>
</Point>
</Placemark>
</Document>
</kml>```

## Ground Overlays

Ground overlays enable you to “drape” an image onto the Earth’s terrain. The <Icon> element contains the link to the .jpgfile with the overlay image. Here is the example ground overlay in the KML Samples file, which shows Mount Etna erupting in 2001:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Folder>
<name>Ground Overlays</name>
<description>Examples of ground overlays</description>
<GroundOverlay>
<name>Large-scale overlay on terrain</name>
<description>Overlay shows Mount Etna erupting
on July 13th, 2001.</description>
<Icon>
</Icon>
<LatLonBox>
<north>37.91904192681665</north>
<south>37.46543388598137</south>
<east>15.35832653742206</east>
<west>14.60128369746704</west>
<rotation>-0.1556640799496235</rotation>
</LatLonBox>
</GroundOverlay>
</Folder>
</kml>
```

Notice that the file begins with the same two lines as the first example: the XML header and KML namespace declaration.

This example uses a Folder (titled “Ground Overlays”) as a mechanism to group and label its contents. Notice how the Folder appears in the Places panel when you load the KML Samples file into Google Earth.

The positioning of a ground overlay is controlled by the <LatLonBox> tag. Bounding values are given for the north and south latitudes, and east and west longitudes. In addition, rotation values are given for images whose y-axis doesn’t coincide with grid north. This example uses a JPEG image for the overlay. Google Earth also supports BMP, GIF, TIFF, TGA, and PNG formats.

## Paths

Many different types of paths can be created in Google Earth, and it is easy to be very creative with your data. In KML, a path is created by a <LineString> element. Take a look at the “Absolute Extruded” example in the Paths folder and you can see how the shape has been generated by the following code:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<name>Paths</name>
<description>Examples of paths. Note that the tessellate tag is by default
set to 0. If you want to create tessellated lines, they must be authored
(or edited) directly in KML.</description>
<Style id="yellowLineGreenPoly">
<LineStyle>
<color>7f00ffff</color>
<width>4</width>
</LineStyle>
<PolyStyle>
<color>7f00ff00</color>
</PolyStyle>
</Style>
<Placemark>
<name>Absolute Extruded</name>
<description>Transparent green wall with yellow outlines</description>
<styleUrl>#yellowLineGreenPoly</styleUrl>
<LineString>
<extrude>1</extrude>
<tessellate>1</tessellate>
<altitudeMode>absolute</altitudeMode>
<coordinates> -112.2550785337791,36.07954952145647,2357
-112.2549277039738,36.08117083492122,2357
-112.2552505069063,36.08260761307279,2357
-112.2564540158376,36.08395660588506,2357
-112.2580238976449,36.08511401044813,2357
-112.2595218489022,36.08584355239394,2357
-112.2608216347552,36.08612634548589,2357
-112.262073428656,36.08626019085147,2357
-112.2633204928495,36.08621519860091,2357
-112.2644963846444,36.08627897945274,2357
-112.2656969554589,36.08649599090644,2357
</coordinates>
</LineString>
</Placemark>
</Document>
</kml>```

Notice how it is really just one line drawn at altitude above the ground. The <tessellate> tag breaks the line up into smaller chunks, and the <extrude> tag extends the line down to the ground.

## Polygons

You can use Polygons to create simple buildings and other shapes. Check out the Polygons folder in the KML Samplesfile for examples.

The Pentagon example is generated by drawing simple inner and outer shells and then extruding them down to the ground. Here is the code :

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Placemark>
<name>The Pentagon</name>
<Polygon>
<extrude>1</extrude>
<altitudeMode>relativeToGround</altitudeMode>
<outerBoundaryIs>
<LinearRing>
<coordinates>
-77.05788457660967,38.87253259892824,100
-77.05465973756702,38.87291016281703,100
-77.05315536854791,38.87053267794386,100
-77.05552622493516,38.868757801256,100
-77.05844056290393,38.86996206506943,100
-77.05788457660967,38.87253259892824,100
</coordinates>
</LinearRing>
</outerBoundaryIs>
<innerBoundaryIs>
<LinearRing>
<coordinates>
-77.05668055019126,38.87154239798456,100
-77.05542625960818,38.87167890344077,100
-77.05485125901024,38.87076535397792,100
-77.05577677433152,38.87008686581446,100
-77.05691162017543,38.87054446963351,100
-77.05668055019126,38.87154239798456,100
</coordinates>
</LinearRing>
</innerBoundaryIs>
</Polygon>
</Placemark>
</kml>
```

This section describes some of the KML elements that must be authored using a text editor, such as shared styles for geometry, highlighted icons for Placemarks, and screen overlays. Authoring KML “by hand” is a bit more advanced than using the Google Earth interface to create and modify features, but with a small amount of practice, most users are comfortable editing KML files to add these effects.

## Styles for Geometry

Once you’ve created features within Google Earth and examined the KML code Google Earth generates, you’ll notice how styles are an important part of how your data is displayed. Power users will want to learn how to define their own styles.

If you define a Style at the beginning of a KML Document and also define an ID for it, you can use this style in Geometry, Placemarks, and Overlays that are defined elsewhere in the Document. Because more than one element can use the same Style, styles defined and used in this way are referred to as shared styles. You define a given Style once, and then you can reference it multiple times, using the <styleUrl> element. If the Style definition is within the same file, precede the Style ID with a # sign. If the Style definition is in an external file, include the complete URL in the <styleUrl> element.

The KML Samples file contains a number of shared styles, each defined with an ID at the beginning of the file. Note that it’s easiest if your IDs are descriptive strings so that you can easily tell what their effect is. Here’s an example of a style (“transBluePoly”) that defines a transparent blue color for the polygon faces and a line width of 1.5 (and default color of white) for the edges of the polygon. This style is used by Building 41 in the Google Campus example (in the Polygons folder):

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<Style id="transBluePoly">
<LineStyle>
<width>1.5</width>
</LineStyle>
<PolyStyle>
<color>7dff0000</color>
</PolyStyle>
</Style>
<Placemark>
<name>Building 41</name>
<styleUrl>#transBluePoly</styleUrl>
<Polygon>
<extrude>1</extrude>
<altitudeMode>relativeToGround</altitudeMode>
<outerBoundaryIs>
<LinearRing>
<coordinates> -122.0857412771483,37.42227033155257,17
-122.0858169768481,37.42231408832346,17
-122.085852582875,37.42230337469744,17
-122.0858799945639,37.42225686138789,17
-122.0858860101409,37.4222311076138,17
-122.0858069157288,37.42220250173855,17
-122.0858379542653,37.42214027058678,17
-122.0856732640519,37.42208690214408,17
-122.0856022926407,37.42214885429042,17
-122.0855902778436,37.422128290487,17
-122.0855841672237,37.42208171967246,17
-122.0854852065741,37.42210455874995,17
-122.0855067264352,37.42214267949824,17
-122.0854430712915,37.42212783846172,17
-122.0850990714904,37.42251282407603,17
-122.0856769818632,37.42281815323651,17
-122.0860162273783,37.42244918858722,17
-122.0857260327004,37.42229239604253,17
-122.0857412771483,37.42227033155257,17
</coordinates>
</LinearRing>
</outerBoundaryIs>
</Polygon>
</Placemark>
</Document>
</kml>```

Note that the <styleUrl> element is a child of <Placemark> (not of the Geometry it affects).

## Styles for Highlighted Icons

The “Highlighted Icon ” in the Styles and Markup folder shows you how to create a roll-over effect with KML. The Document defines two styles, one for the “normalPlacemark” and one for the “highlightPlacemark” (shown when the cursor rolls over the Icon). The <StyleMap> element has two key/value pairs that map each icon style to an icon state. There are two icon states: normal and highlight.

The basic steps shown here are as follows:

1. Define a <Style> for the Placemark’s normal icon, and assign an ID to it (here, “normal Placemark”). The <Style> includes an <Icon> with an <href> to the actual image to use, as shown below.
2. Define a <Style> for the Placemark’s highlight icon and assign an ID to it (here, “highlightPlacemark”).
3. Create the <StyleMap> element and assign an ID to it (“exampleStyleMap”). The Placemark will refer to this ID.
4. In the <StyleMap> element, specify “#normalPlacemark” for the normal state.
5. In the <StyleMap> element, specify “#highlightPlacemark” for the highlight state.
6. In the Placemark, add a <styleUrl> element that refers to “#exampleStyleMap.”
```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Document>
<name>Highlighted Icon</name>
<description>Place your mouse over the icon to see it display the new icon</description>
<Style id="highlightPlacemark">
<IconStyle>
<Icon>
</Icon>
</IconStyle>
</Style>
<Style id="normalPlacemark">
<IconStyle>
<Icon>
</Icon>
</IconStyle>
</Style>
<StyleMap id="exampleStyleMap">
<Pair>
<key>normal</key>
<styleUrl>#normalPlacemark</styleUrl>
</Pair>
<Pair>
<key>highlight</key>
<styleUrl>#highlightPlacemark</styleUrl>
</Pair>
</StyleMap>
<Placemark>
<name>Roll over this icon</name>
<styleUrl>#exampleStyleMap</styleUrl>
<Point>
<coordinates>-122.0856545755255,37.42243077405461,0</coordinates>
</Point>
</Placemark>
</Document>
</kml>```

## Screen Overlays

Screen overlays cannot be authored directly within Google Earth and are thus more difficult to create than ground overlays. A comprehensive collection of samples is included in the Screen Overlays folder in the KML Samples file.

As an example, enable the “Absolute Positioning: Top left” folder in the KML Samples file and you will see a screen overlay at the top left of the view window. This was created with the following KML code:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<ScreenOverlay>
<name>Absolute Positioning: Top left</name>
<Icon>
</Icon>
<overlayXY x="0" y="1" xunits="fraction" yunits="fraction"/>
<screenXY x="0" y="1" xunits="fraction" yunits="fraction"/>
<rotationXY x="0" y="0" xunits="fraction" yunits="fraction"/>
<size x="0" y="0" xunits="fraction" yunits="fraction"/>
</ScreenOverlay>
</kml>```

Positioning is controlled by mapping a point in the image specified by <overlayXY> to a point on the screen specified by <screenXY>. In this case, the top-left corner of the image (0,1) has been made coincident with the same point on the screen.

Check the other examples in the folder to see how it is possible to obtain other fixed positions, and to create images that size dynamically with screen size. (Note that xunits and yunits can also be specified as “pixels” for precision control.) For further detail, see the KML 2.2 Reference.

A network link contains a <Link> element with an <href> (a hypertext reference) that loads a file. The <href> can be a local file specification or an absolute URL. Despite the name, a <NetworkLink> does not necessarily load files from the network.

The <href> in a link specifies the location of any of the following:

• An image file used by icons in icon styles, ground overlays, and screen overlays
• A model file used in the <Model> element

The specified file can be either a local file or a file on a remote server. In their simplest form, network links are a useful way to split one large KML file into smaller, more manageable files on the same computer.

So far, all of our examples have required that the KML code be delivered to Google Earth from the local machine. Network links give you the power to serve content from a remote location and are commonly used to distribute data to large numbers of users. In this way, if the data needs to be amended, it has to be changed only at the source location, and all users receive the updated data automatically.

### CGI Scripting for KML

In addition to pointing to files containing static data, a network link’s <href> can point to data that is dynamically generated—for example, by a CGI script located on a network server. With some knowledge of a scripting language such as PHP, Python, or Perl, you can create a script that delivers a stream (or file) of KML data to each network link.

Two things are necessary for delivering KML through a network CGI:

When a call is made from the client (Google Earth) to the server, the server must (1) return a response code of HTTP 200 and (2) set the response’s content type to `text/plain` or `application/vnd.google-earth.kml+xml.`

The response must be valid KML. For complex applications, proper error handling is very important.

Tip: A simple way to handle errors is to parse the server’s error as the text for a folder name. For example, you could have the server return `<Folder><name>database inaccessible</name></Folder>` as a string. This is more informative (and more user-friendly) than letting the connection drop.

The following examples use Python, but they are equally valid in any other scripting language.

### Generating a Random Placemark

The following Python script generates random integer values for latitude and longitude and then inserts those values into the <coordinates> element of a <Point>. Whenever the network link is refreshed, the Python script runs again and generates KML with new latitude and longitude values.

```#!/usr/bin/python

import random

latitude = random.randrange(-90, 90)
longitude = random.randrange(-180, 180)
kml = (
'<?xml version="1.0" encoding="UTF-8"?>\n'
'<kml xmlns="http://www.opengis.net/kml/2.2">\n'
'<Placemark>\n'
'<name>Random Placemark</name>\n'
'<Point>\n'
'<coordinates>%d,%d</coordinates>\n'
'</Point>\n'
'</Placemark>\n'
'</kml>'
) %(longitude, latitude)
print kml```

Here is an example of a KML file containing a Network Link that loads this Python script:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Folder>
<visibility>0</visibility>
<open>0</open>
<name>Random Placemark</name>
<visibility>0</visibility>
<open>0</open>
<description>A simple server-side script that generates a new random
placemark on each call</description>
<refreshVisibility>0</refreshVisibility>
<flyToView>0</flyToView>
<href>http://yourserver.com/cgi-bin/randomPlacemark.py</href>
</Folder>
</kml>```

### View-Based Refresh Queries

A standard network link is a uni-directional link: data flows only from the server to Google Earth. The view-based refresh enables bi-directional communication. When the view-based refresh is active, Google Earth returns the view coordinates to the server at a specified time. This may be every n seconds, minutes, or hours, or once a certain amount of time has elapsed since the view stopped moving. See <viewRefreshMode> in the KML 2.2 Reference.

The coordinates are returned to the server by means of an HTTP GET that appends the coordinates as follows (this is the default bounding box information):

```GET /path/to/sever/script/query?BBOX=[longitude_west, latitude_south, longitude_east, latitude_north] HTTP/1.1
```

If the request were made while the user was looking down on San Francisco, the coordinates might look as follows:

```GET /path/to/server/script/query?BBOX=-122.497790,37.730385,-122.380087,37.812331 HTTP/1.1
```

This feature can be used for some very creative applications, but to get you started, a simple example is presented below.

### Tracking a Point Directly Under Your View

The following server-side Python script parses the return message sent by Google Earth and responds with a Placemark at the center of the screen. Each time the Network Link is refreshed, a new Placemark is generated.

```#!/usr/bin/python

import cgi

url = cgi.FieldStorage()
bbox = url['BBOX'].value
bbox = bbox.split(',')
west = float(bbox[0])
south = float(bbox[1])
east = float(bbox[2])
north = float(bbox[3])

center_lng = ((east - west) / 2) + west
center_lat = ((north - south) / 2) + south

kml = (
'<?xml version="1.0" encoding="UTF-8"?>\n'
'<kml xmlns="http://www.opengis.net/kml/2.2">\n'
'<Placemark>\n'
'<name>View-centered placemark</name>\n'
'<Point>\n'
'<coordinates>%.6f,%.6f</coordinates>\n'
'</Point>\n'
'</Placemark>\n'
'</kml>'
) %(center_lng, center_lat)

print kml```

And here is the KML for the Network Link that loads the Python script:

```<?xml version="1.0" encoding="UTF-8"?>
<kml xmlns="http://www.opengis.net/kml/2.2">
<Folder>
<visibility>0</visibility>
<open>0</open>
<name>View Centered Placemark</name>
<visibility>0</visibility>
<open>0</open>
<description>The view-based refresh allows the remote server to calculate
the center of your screen and return a placemark.</description>
<refreshVisibility>0</refreshVisibility>
<flyToView>0</flyToView>
<href>http://yourserver.com/cgi-bin/viewCenteredPlacemark.py</href>
<refreshInterval>2</refreshInterval>
<viewRefreshMode>onStop</viewRefreshMode>
<viewRefreshTime>1</viewRefreshTime>
</Folder>
</kml>```

The principle illustrated in this example can be used for some very complex applications. For example, if you have a database of geographic information, you can extract the coordinates of the viewer, make a call to the database for the data specific to the view, and return it to Google Earth as KML.

# 3 KML MIME Types

When responding to a request from Google Earth (or any Earth browser), a KML server must follow a certain set of rules so that Google Earth can correctly interpret its responses.

Upon success, the server must return a response code of HTTP 200 and set the response’s content-type to a suitable MIME type, as described here.

Google Earth reads KML and KMZ files. The MIME type for KML files is

• `application/vnd.google-earth.kml+xml`

The MIME type for KMZ files is

• `application/vnd.google-earth.kmz`

For Apache, add these lines to the httpd.conf file:

• `AddType application/vnd.google-earth.kml+xml .kml`
• `AddType application/vnd.google-earth.kmz .kmz`

See the Microsoft documentation for details on setting up MIME types on Microsoft’s IIS.

The body of the response must contain valid KML data, including the XML declaration (`<?xml version="1.0" encoding="UTF-8"?>`). If the server returns invalid KML, the Network Link will stop, deactivate, and output an error message.

# What’s Next?

Ready for more? Check out the Developer’s Guide, which describes key KML features. Also, browse the KML Reference for information on specific elements.

Source

# Python GPS NMEA Statement Parsing Code in Need of Serious Debugging

```import serial

port = "/dev/ttyS0"

def parseGPS(data):
#    print "raw:", data #prints raw data
if data[0:6] == "\$GPRMC":
sdata = data.split(",")
if sdata[2] == 'V':
print("no satellite data available")
return
print( "---Parsing GPRMC---",
time = sdata[1][0:2] + ":" + sdata[1][2:4] + ":" + sdata[1][4:6]
lat = decode(sdata[3]) #latitude
dirLat = sdata[4]      #latitude direction N/S
lon = decode(sdata[5]) #longitute
dirLon = sdata[6]      #longitude direction E/W
speed = sdata[7]       #Speed in knots
trCourse = sdata[8]    #True course
date = sdata[9][0:2] + "/" + sdata[9][2:4] + "/" + sdata[9][4:6]#date

print "time : %s, latitude : %s(%s), longitude : %s(%s), speed : %s, True Course : %s, Date : %s" %  (time,lat,dirLat,lon,dirLon,speed,trCourse,date)

def decode(coord):
#Converts DDDMM.MMMMM &gt; DD deg MM.MMMMM min
x = coord.split(".")
tail = x[1]