Create a gist now

Instantly share code, notes, and snippets.

Unread Email Counter for the Intel/Arduino Galileo
# pyMailCheck.py - Logs into your gmail and prints the number of unread emails.
# Place this file in the top level of your Galileo's SD card.
import imaplib # Used to connect to an IMAP4 server.
obj = imaplib.IMAP4_SSL('imap.gmail.com', '993') # Connect to an IMAP4 sever over SSL, port 993
obj.login('my_email_address@gmail.com','myPassword') # Identify the client user and password
obj.select() # Select a the 'INBOX' mailbox (default parameter)
# Search mailbox no (None) charset, criterion:"UnSeen". Will return a tuple, grab the second part,
# split each string into a list, and return the length of that list:
print len(obj.search(None,'UnSeen')[1][0].split())
/* Galileo Email Checker
by: Jim Lindblom
SparkFun Electronics
date: January 7, 2013
license: Beerware. Please use, reuse, and modify this code.
If you find it useful, you can buy me a beer when we meet.
This code connects a Galileo to WiFi. Then runs a Python script
- https://gist.github.com/jimblom/8292444#file-pymailcheck-py -
that lives on the Galileo's SD card to check how many unread
emails you have. That number is displayed on an OpenSegment
Shield - https://www.sparkfun.com/products/11846 - which is
controlled over SPI.
*/
#include <SPI.h> // SPI is used to control the OpenSegment Shield
#include <WiFi.h> // WiFi (could be swapped out for Ethernet)
#include <SD.h> // The SD library is used to read a temporary file,
// where the py script stores an unread email count.
//////////////////////
// WiFi Definitions //
//////////////////////
char ssid[] = "WiFiSSID"; // your network SSID (name)
char pass[] = "WiFiPassword"; // your network password (use for WPA, or use as key for WEP)
IPAddress ip;
int status = WL_IDLE_STATUS;
/////////////////////
// Pin Definitions //
/////////////////////
const int SS_PIN = 10; // SPI slave select pin (10 on the shield)
const int STAT_LED = 13; // The Galileo's status LED on pin 13
////////////////////////////////
// Email-Checking Global Vars //
////////////////////////////////
const int emailUpdateRate = 10000; // Update rate in ms (10 s)
long emailLastMillis = 0; // Stores our last email check time
int emailCount = 0; // Stores the last email count
// setup() initializes the OpenSegment, the SD card, and WiFi
// If it exits successfully, the status LED will turn on.
void setup()
{
pinMode(STAT_LED, OUTPUT);
digitalWrite(STAT_LED, LOW);
Serial.begin(9600); // Serial monitor is used for debug
initDisplay(); // starts up SPI and resets the OS Shield
initSDCard(); // Initializes the SD class
// Initialize WiFI. On success turn on the stat LED. On fail,
// print an error on the LED, and go into an infinite loop.
if (initWiFi() == 1) // If WiFi connects, turn on Stat LED
digitalWrite(STAT_LED, HIGH);
else
{ // If WiFi connect fails, print error, inifinite loop
SPIWriteString("----", 4);
while (1)
;
}
}
// loop() checks for the unread email count every emailUpdateRate
// milliseconds. If the count has changed, update the display.
void loop()
{
// Only check email if emailUpdateRate ms have passed
if (millis() > emailLastMillis + emailUpdateRate)
{
emailLastMillis = millis(); // update emailLastMillis
// Get unread email count, and store into temporary variable
int tempCount = getEmailCount();
if (tempCount != emailCount) // If it's a new value, update
{ // Do this to prevent blinking the same #
emailCount = tempCount; // update emailCount variable
printEmailCount(emailCount); // print the unread count
}
}
// Bit of protection in case millis overruns:
if (millis() < emailLastMillis)
emailLastMillis = 0;
}
// printEmailCount(emails) prints the given number to both the
// serial monitor, and the OpenSegment Shield.
void printEmailCount(int emails)
{
Serial.print("You have ");
Serial.print(emails);
Serial.println(" unread mail.");
SPIWriteByte('v'); // Clear display
for (int i=3; i>= 0; i--)
{
SPIWriteByte((int) emails / pow(10, i));
emails = emails - ((int)(emails / pow(10, i)) * pow(10, i));
}
}
// getEmailCount runs the pyMail.py script, and reads the output.
// It'll return the value printed by the pyMail.py script.
int getEmailCount()
{
int digits = 0;
int temp[10];
int emailCnt = 0;
// Send a system call to run our python script and route the
// output of the script to a file.
system("python /media/realroot/pyMail.py > /media/realroot/emails");
File emailsFile = SD.open("emails"); // open emails for reading
// read from emails until we hit the end or a newline
while ((emailsFile.peek() != '\n') && (emailsFile.available()))
temp[digits++] = emailsFile.read() - 48; // Convert from ASCII to a number
emailsFile.close(); // close the emails file
system("rm /media/realroot/emails"); // remove the emails file
// Turn the inidividual digits into a single integer:
for (int i=0; i<digits; i++)
emailCnt += temp[i] * pow(10, digits - 1 - i);
return emailCnt;
}
// initDisplay() starts SPI, and clears the display to "0000"
void initDisplay()
{
initSPI();
SPIWriteByte('v');
SPIWriteString("0000", 4);
}
// initSPI() begins the SPI class, and sets up our SS_PIN output
void initSPI()
{
pinMode(SS_PIN, OUTPUT);
digitalWrite(SS_PIN, HIGH);
SPI.begin();
SPI.setBitOrder(MSBFIRST);
SPI.setClockDivider(SPI_CLOCK_DIV64);
SPI.setDataMode(SPI_MODE0);
}
// initSDCard() begins the SD class
void initSDCard()
{
SD.begin();
}
// initWiFi() initializes WiFi, connecting to the ssid/passkey
// combo defined up above.
// This function will attempt 3 connections to WiFi. If we
// succeed a 1 is returned, and the IP address is printed.
// If connections fail, a 0 is returned.
uint8_t initWiFi()
{
byte timeout = 0;
while ((status != WL_CONNECTED) && (timeout < 3))
{
Serial.print("Setting up WiFi : attempt ");
Serial.println(timeout + 1);
// Connect to WPA/WPA2 network. Change this line if using
// open or WEP network:
status = WiFi.begin(ssid, pass);
//delay(10000); // Wait 10 seconds between connect attempts
timeout++;
}
if (timeout >= 3)
return 0;
else
{
Serial.print("Connected to ");
ip = WiFi.localIP();
Serial.println(WiFi.SSID());
Serial.println(ip);
// !!! Idea here: print IP address to seven segment display.
// That'll make it easier to know which address to ssh over to
// if we need.
return 1;
}
}
// SPIWriteString will write an array of chars (str) of length
// len out to SPI. Write order is [0], [1], ..., [len-1].
void SPIWriteString(char * str, uint8_t len)
{
digitalWrite(SS_PIN, LOW);
for (int i=0; i<len; i++)
{
SPI.transfer(str[i]);
}
digitalWrite(SS_PIN, HIGH);
}
// SPIWriteByte will write a single byte out of SPI.
void SPIWriteByte(uint8_t b)
{
digitalWrite(SS_PIN, LOW);
SPI.transfer(b);
digitalWrite(SS_PIN, HIGH);
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment