Team 1 IST 411 Command and Control meeting minutes

12-7-16
-Fixed the Interface.py and the CommandAndControl.py files.
-Got the files waiting on each other
-Tested the files on 2 raspberry pis and 3 xBees.

Team 6 - Safety and Access Control System Meeting

Wednesday, 12/7 - Google Hangouts

After the team leaders met to discuss and implement a structured template for our project presentation, our group edited our section by moving the information from our original slides while also deleting some. Additionally, we added:

• Code snippets
• A timeline of our milestones
• A diagram representing how the keyless entry (Android App) works between the user, SSH connection and output

Team 1 Braking System Meeting Minute

Team 1 Meeting Minutes,

12/4/16  Sunday 1PM  - 5PM, 12/5/16 Monday 9 PM - 1 AM   12/6/16 Tuesday Class Time
Progress:

Finished Documentation


Final Android UI

Revising  PowerPoint.

Team 6 - Safety and Access Control System Meeting

Monday, 12/5 - 132 Woodland

Our group met during Common Break and worked on our presentation.

IST Team 3 Climate Control meeting minutes

12/2 Meeting

• We are almost finished all our documentation. We have maintenance documentation finished and just need to combine all the documents together.
• PowerPoint presentation almost completed

Completed:

1. Bluetooth is able to communicate with android device using two ports. We used threading to display the temperature as well as reading the temperature on the tablet. 
2. Controlling the cooling fan and heating pad with our app by using bluetooth.
3. If user decreases temperature then the A/C will be turned on
4. If user increases temperature then the heat will be turned on

Current UI

Increasing temperature will turn on Heat

Decreasing temperature will turn on A/C

IST Team 2 Monitoring and Logging minutes

Accomplished:

• Discussed how we will be integrating with CNS
• Worked out additional methods needed for passing messages to CNS
• Created watchdog timer and tracking methods for system timeouts

To Do:

• Integrate with CCS message queue/Threading code
• Write test harness to simulate messages coming in from the queue
• Test entire chain (CCS>MLS>CNS)

IST 411 Team 3 Connectivity and Notification meeting minutes

Team Meeting 11/30/16

• Discussed with monitoring and logging team on how the message will be sent
• Added CNSmonitoring file that utilizes the Message class to receive messages
• Tested some methods to receive a message and read messages' payloads

IST 411 Command and Control Team 1 Meeting minutes

Meeting minutes 12/1/16

- Discussed the errors we have for the interface

- Slowly fixing errors one by one

- Stopped by IST 440 to see how the process is going

- Located our errors and consulted professor Joe Oakes for assistance

Team 6 - Safety and Access Control System Meeting Minutes

Wednesday, 11/30 - Google Hangouts

• Discussed and organized the outline of our presentation
• Created a list to reorganize our GitHub files into folder structures

RPM to MPH for Accelorometer

 #Accelrometer RPM to MPH
 #Rahul Manoharan
 #11/17/2016

import smbus
import time


bus = smbus.SMBus(1)


 # This is the address we setup in the Arduino Program
address = 0x08


def writeNumber(value):
     bus.write_byte(address, value)
     return -1


def redNumber():
     number = bus.read_byte(address)
     return number


while True:
     var = input("enter a number:")
     writeNumber(var)
     print ("RPI: Hi Arduino, I sent you "), var
     time.sleep(1)

     #number is rpm number
     number = readNumber()
     print ("Arduino: Here's the current RPM: "), number
     
    #conversion equation
     MPH = ( (4.5 * number) * 60) / 63360
     print ("Here's the current MPH: "), MPH

Team 3 Meeting Minutes 11/17/16

We discussed

• Connectivity class redesign
• CNS class with methods like CNSTransfer which takes the data and transfer it(implemented by monitoring and logging. Calls cns transfer method and put in the data we need. (Define the needs Define transfer protocol. Checksum needed: HCI))
• Take that data for Notification Class. Checks for checksum, Call CNS transfer

ALAN/ KEVAL/ SYDNEED- DEFINE CNS CLASS and CNS Transfer methods

ABU - Notification Bluetooth

Team 1 Command and control Meeting minutes

Meeting minutes 11/17
- Created an interface for 440
- Discussed communication issues in our team
- Discussed with other teams to communicate with us

IST411 Team 2 Monitoring and Logging Meeting Minutes

What we discussed:

• Important aspects of the code
• Requirements for CNS integration
• Requirements from CCS communication system
• Issues left going forward
• System Complexity

What we accomplished:

• Refactored monitoring class to adjust threading mechanism to accept communication code from CCS
• Blueprinted additional methods to allow Monitoring class to be invoked by outside systems
• Diagrammed overall system integration flow with other groups in 411

What needs to be done:

• Write watchdogs and threading methods in Monitoring class
• Write logic for payload recognition
• Discuss messaging protocol complexity with CCS

IST440 Messages to send and recieve

Team 1 Braking System Meeting Minutes

Tuesday 11/8, Thursday 11/10 and Friday 11/11

Our team met up and talked about the work for the rest of the projects. Tuesday and Thursday both are in class, Friday late afternoon our team met for an hour. We focused on brake On and Off .py program.

Progress:

• Python Code for E-Brake (Parking Brake), Sensor Brake, Normal Brake, and ABS Brake are all finished for Turning them ON.  

• Creating Python Code for OFF in all these Brake Type. 

• We redesigned the Android UI for with horizontal view and buttons on the one side of screen.

• Created a user in Android application, Only the driver will be able to login the apps and apply the brakes.

Work for next stage:

• Create more secure way to connect Android to Pi. (External file to read the host name and password for RPi. 

• Create two way communication between Pi and Android ( Apache2, PHP, MySQL and PHPMyadmin in thoughts), Create a socket between two devices, will test out.

• Finish the background code for when android buttons were clicked.

Team 3 Climate Control Meeting Minutes

Our team met and talked together in a Google hangouts call and discussed about the objectives we are trying to  complete. This meeting took about 1 hour and 30 minutes. We also meet in the classroom on 11/9 and 11/11 for about 4 hours total.

Worked on:

- Python code for outside temperature, outside humidity, inside temperature, both fans on and off, cooling on and off , and heating pad on and off.

- Updated the User Interface by adding manual increase and decrease of temperature through buttons.

- Manual toggle of Fan 1 and Fan 2 (ON and OFF function, ex: color change of toggle buttons)

- Bluetooth Connectivity


Working towards:

- JSON script to send over Bluetooth for outside temperature, outside humidity, inside temperature, both fans on and off, cooling on and off , and heating pad on and off.

- Read JSON and place the values into the text view.

- Read JSON from Android to Raspberry Pi through Bluetooth.

-  Perform a test where you must FIRST be able to have the server connected to Bluetooth and have it LISTEN for feedback, server socket. 

- Perform a test where you can send data to the server from a different script which is the client socket

Team 1 Command and Control meeting minutes

11/10/16 7:30 - 9:30

Update as of 11/10/16:
1. xBee communication through
   Serialization done.
2. Message queue done.
3. Command & Control System local communication between our
   system and Monitoring & Logging has begun. We are using a
   localhost pika connection to communicate incoming messages
   from the xBee to the Monitoring & Logging System.
4. Created dummy Monitoring and Logging client code to wait for
   messages for the sake of testing using pika.
5. Cleaned up folder system.

Plan as of 11/10/16:
-----------------------
1. Finish up local pika communication between Command and
   Control and Monitoring and Logging.
2. Get "serial" package installed for Python, removing this
   error:

3. Write Unit Tests for testing.
4. Provide finalized pika communication interface to Monitoring
   & Logging.
5. Provide finalized xBee communication interface (A few lines
   of code in a function) to all 440 Teams.

IST 411 Team 3 Connectivity and Notification Team Meeting Minutes

Meeting 11/8/16
During this meeting:

• Use bash script to check for external device.
• Send the Json dump file using SFTP. The Json dump from the logging system is sent as a text file. 
• Will have to figure out if we want to use bluetooth, wifi, or USB connection to send files.
• (Updated) Uses WIFI.
• Added left and right turn signal lights "out" unit testing for both front and rear lights.
• Will have to get more specific names from the lighting team.

IST 411 Team 2 Monitoring and Logging System 11/10/2016 Meeting Minutes

In development for next week:

• Finishing Unit Tests for logging.py
• Look at how we will interface with Command and Control
• Remove threading from Monitoring
• Instantiate a Monitoring object, one object will handle all of the incoming messages globally
• Transferring messages that contain sub-optimal health codes to Connectivity and Notifications

Finished this week:

• Started on Unit Tests for logging.py
• Started on clearing messages from the Mongo Database
• Finished dumping a text file containing the messages in the database
• Can dump by:
• Subsystem
• Errors
• All collections

Example of an All Collection data text file 

Thursday 11/10 - In class 

Tasks:

• Upgraded OS to Rasbperry Pi Pixel
• Configured ad hoc network
• Currently working on connecting via Bluetooth
• updated Jira server tasks

Team 6 - Safety and Access Control System Meeting Minutes

Wednesday, 11/9 - Google Hangouts

Tasks:

• Got nfc.py to run on RPi 2, however bluetooth isn't supported unless we use a bluetooth dongle. Will need further research and discussion.
• Research about ad hoc wifi network
• Updated tasks in Jira: 
• Write and test code for triggering car alarm using the gyroscope, accelerometer, & magnetometer sensors on the Sense HAT 

IST 411 Team 1 Command & Control - Progress Update

We met with the other 411 groups after our 412 class on Wednesday, 11/2/2016. There, we came up with a unified cohesive view of what the project would be. The Command and Control team now has a crystal clear picture of what is expected of our system and can move forward with the process of writing code.

----------------------------------------------------------------

Team Plan as of 11/3/2016:

1. Update Jira with tasks for code stubbing and method writing
2. Begin code stubbing process.
3. Meet with IST 440 during their class time to create messaging
   standard.
4. Write interface code for message sending and receiving for a
   client xBee.(Breaking System, Lighting System, etc.)
5. Write interface code for message blast-out from Command &
   Control xBee.

----------------------------------------------------------------

Team Goal: By next Thursday 11/10/2016:

1. Have functioning code for sending and receiving messages
   that we can provide to the 440 Teams.
2. Have functioning code for receiving and blasting out
   messages from the Command & Control xBee.
3. Provide interface for Monitoring & Logging to store messages
   that Command & Control receives.

IST 411 Team 3 Connectivity and Notification Team Meeting Minutes

Meeting date 11/2/2016

• Added more unit testing to github in the  notification_unitTest.py file.
• Updated working code for connecting to the internet via blue tooth.
• Discussed with group leaders of how and when we will send messages to each other.
• Provided examples of what we need in another post.

IST 411 Team 3 Connectivity and Notification information Req from Monitoring and Logging

The extreme health codes from each system eg : {'OID' : 'MLS', 'DID' : 'CNS', 'PLD' : ' HC# Brakes have failed'}, {'OID' : 'MLS', 'DID' : 'CNS', 'PLD' : 'HC# left turn signal non functional'}

We will also need the information that are maintenance related like :
{'OID' : 'MLS', 'DID' : 'CNS', 'PLD' : ' Batteries need to be changed'}
{'OID' : 'MLS', 'DID' : 'CNS', 'PLD' : ' Brake calipers need to be changed'}
{'OID' : 'MLS', 'DID' : 'CNS', 'PLD' : ' Fans for the climate control system needs to be changed'}
{'OID' : 'MLS', 'DID' : 'CNS', 'PLD' : ' Lights are near the end of their life cycle'}

We could set up the alert to be sent once the light have been turned on and off for a certain number of times or when the brakes have been used a certain number of times (setting up a life cycle for the wear and tear parts of the vehicle). An entry of a counter variable into the collection would work.

IST 411 Team 2 Monitoring and Logging meeting minutes

Group meeting with entire class discussed requirements for communication and interfacing with the XBees. Continued discussing messaging standards and the need for groups to define their payloads.

Group Progress:

• Fixed logging class to provide all basic mongo functionality
• Created methods needed for handling parsing of messages in to various collections
• Refactored code to allow for code reuse and remove duplicate code
• Added comments to new and updated methods
• Created a testing program for the logging class
• Discussed the need for a full class meeting with 440 to determine message payload requirements

Tasks under development:

• Create logging file output in easy to read format
• Determine how to get the logging file from Pi to whatever device requested it
• Create db message retrieve and clear methods
• Design, implement, and test interface between monitoring class and communication class

Team 3 Climate Control Meeting Minutes

Our team met up together in a Google hangouts call and discussed about the objectives we are trying to  complete. This meeting took about 1 hour and 30 minutes.

11/02/2016

• Created Python code for:
• Fan ON/OFF
• Cooling Fan ON/OFF
• Heating Pad ON/OFF
• We are going to send files via Bluetooth to the pi and have it communicate with android devices
• Updated Jira server tasks for each member
• Temperature sensor is working with the pi

Update 11/04/2016

Spent five hours working on Android UI and Bluetooth Connect:

• Configured all python files with correct GPIO Pin and made On/Off files for
• Fan One
• Fan Two
• Heating Pad
• AC Cooling 
• Connect Breadboard to the Raspberry Pi
• Power on Fans, AC Cooling, and Heating pad
• Connect Pi to Android tablet and use tablet to turn fan ON and OFF with buttons 

IST 440 Lighting Team Meeting Minuets

The weeks of October 24th and October 31st:

• Got the new lights for the car. Consisting of two light matrices and two LED progress bars. 
• The two light matrices will work as the front lights on a car, whereas the progress bar will be the two back lights.
• Worked with both the lighting matrix and the progress bar to create the lights we need.
• Got all the necessary lights needed laid out on the light matrix.
• Added new toggles to the Android app.
• Tested the new toggles. 
• Ran into an issue where we had an issue when running two lights at once.
• Added logic to the Android app to turn off the previous toggle. 
•  Ran into an issue with the Progress bar. 
• When we run the same code we get different outcome even though there is no instance of randomness.
• Currently working to debug the Progress bars to get a constant outcome on what is needed. 
• Once all lights are laid out, we will communicate with other teams to have the lights go off when certain criteria is meet.

Battery level indicator

This weekend I designed a light bar that can be used as an indicator for the battery level of the vehicle. The LED strip uses 8 DotStar RGB LEDs from Adafruit that can each be assigned their own color and brightness.

The board uses a 5 wire interface to connect with the Raspberry Pi:

• Red wire: 5v
• Black wire: GND
• Orange wire: 3.3v
• Yellow wire: Data (pin 23)
• Green wire: Clock (pin 24)

The code to run this is incredibly simple. Granted, if you want to do fancy fades and color sweeps you will have to do some research, but turning on a specific LED to a certain color is very straightforward. You will be using the Adafruit library found here: https://github.com/adafruit/Adafruit_DotStar_Pi

It can be cloned to your Pi by navigating to the directory you want to store the files in and typing the command: git clone https://github.com/adafruit/Adafruit_DotStar_Pi

The picture above is a result of me running the following code:

First you have the library/module import. Then you define how many LEDs you have hooked up. Then you set up which RPi pins are to be used for your data and clock signal. Be careful to choose only standard/plain GPIO pins, otherwise you will run into errors. Then you initialize the LED strip with the parameters you've defined. The setBrightness() method takes in an integer from 0-255. I find that the best colors come around the 15-25 range, 255 is just blinding. You're making a battery level indicator, not a pair of high beams for your headlights. The next block of code sets the color of individual LEDs. The parameters of the setPixelColor() method are as follows: (LED#, Green, Red, Blue) Each color can have values from 0-255. All zeroes = no light, all 255 = full blast. Playing around with the RGB combinations for each LED should yield some good colors. Lastly, the show() method writes all of this data to the LEDs and forces the strip to update. Without this, you wouldn't see any of your changes in the lights.

If you have any questions, feel free to ask here or email me. I will be in class on Thursday and will have the indicator strip on hand so you can test it. I expect you guys to have some sort of working code by then, along with a plan on how you're going to map battery voltages to the colors/status of the LEDs.

FYI, You can hook up massive amounts of these to a Pi. You don't need any extra boards or PiHats. If any other groups are interested in using a similar light bar as an indicator, please let me know ASAP. 

Before

Updated Car photos

Car Speedometer Installed

I finally got the parts for the car speedometer so I mounted and tested them on the chassis. The system measures the RPMs of the big white gear and the center driveshaft of the vehicle - turning that number into an MPH figure is just a matter of finding how far the car travels in a single revolution of the shaft, multiplying it by the RPM and then doing the appropriate unit conversions. 

The system uses two magnets embedded in the white center gear to trigger a Hall Effect Sensor (2 triggers = 1 gear revolution). The sensitivity of the sensor can be adjusted by the blue potentiometer on the HES Logic Board.  The Arduino Pro Mini (3.3v, do not try and program it as a 5v device!) times how long each revolution takes and then averages the last 5 readings to get a stable RPM figure. The Arduino is connected to the Drivetrain Team Raspberry Pi via 4 wires: GND, 5V, SDA, SCL. You should recognize that as the I2C communication bus. Via this bus, the RPi asks the Arduino for an RPM value and the Arduino replies with its current RPM reading. The code running on the Arduino is attached below, in case you were curious - you don't really need to know too much about it if your only goal is implementing it in your system. 

It doesn't matter what message you send the Arduino - it will always respond with the RPM number. Now, on to the sending side - the Raspberry Pi. Talking to the Arduino is very simple via I2C. The code I used below sends whatever number the user inputs in the Pi to the Arduino and then waits for a reply. 

Yes, I'm providing the code as a jpeg. I'm evil. When this code runs, it returns the RPM number to the RPi. Once you have that number, you're gonna want to convert to MPH and then serve it up to the Android App. If you have any questions, please ask in the comments or email me if it's urgent. 

Team 1 Braking System (10/24 - 10/28) Meeting Minutes

Progress:

              Android apps button will send command to the Raspberry pi to run one of the python application in Pi and Servo will start the braking or ABS. Will add ultrasonic sensor and Parking Brake soon.

Tuesday, 10/24  and 10/27 -  In Class

• Finished the remote control from Android Apps to Raspberry Pi via SSH
• Add parking brake for raspberry pi 
• Figure out the ultrasonic sensor in the existing python code
• Anti-block Braking System was finished and tested in the project car. It was working.
• Need to re-do the Java code because using SSH will be hard coded pi's password. Alternative method is to read the password from an external file.
• Need to fill up the comment inside the java and python.

Wednesday. 10/25 

Tasks

• Put Json code into python as well because it will send out message to other devices.
• Test out other method on Android send command to Pi which is set Pi as web server, and android as client communicate through Json.

Next Week:

• Focus on encryption of password of Pi, no hard coded in Java
• Work on JSON at raspberry Pi

Team 1 Braking System Meeting Minute

Team meeting on 10/18 and 10/20 in class.

• Testing with the servo in 90 and 180 degree
• Met with Ivan about the car construction and how are we wanted to apply the servo into the car.
• Tested the servo brake system with Ivan's car

New UI updated

• We added red color have transparent on the tires when the brake is on

Will do next week

• Will merge the UI into the remote control SSH files for Android Apps
• Will have Pi to send messages to the Logging and Monitoring subsystem every time the brakes are applied

Poster

IST 440 Team 5: Energy Management System

Wednesday, 10/25 and 10/27- In class 

Tasks:

• Set up Bluetooth on pi  and connect with Android devices.
• Configure MOpi with power source we got from Ivan
• Figure out conversion of voltage readings into percentage battery level
• Redefined code files and directories
• updated Jira server tasks

IST TEAM 3 Connectivity and Notification MEETING MINUTES

Our group will meet together on 10/28/16 to discuss a few things we want and need.

What we've been working on:

• Testing Insertion json messages into database

What needs to be done for next week:

• Insert messages from other classes we've received and put them into the database.
• More data testing with connectivity and notifications

What we need from other systems for the time being:

• Nothing for now.

XBee configuration

The Xbee modules have been configured and talk to each other. The topology we are using is a ZigBee mesh, with 6 Routers and 1 Coordinator. The XBees are running in Transparent mode, so it's just a very simple text transmission, no bells and whistles. Basic code to interface with them will be tested this weekend - the rest of the development will be handed over to the Command and Control team. More specifications to follow.

IST 440W Team 3 - Climate Control

Team Meetings

This past week we had 3 team meetings: 2 via Google Hangouts on October 24th (1 hour 45 mins) and 26th (1 hour 30 mins), and 1 in person on the 26th (2 hours), as well.

Updated Items

We were able to get a Bluetooth connection between the Raspberry Pi and the Android Nexus 7 Tablet. The two devices are able to send messages back and forth.

We are no longer using a Grove Pi; it was replaced with a Temp Sensor, The sensor is smaller than the Grove Pi, but still gives us the same information.

A change few minor changes were made to our User Interface. Compared to our last design, the background is black, which allows the text to stand out more and give it a finishing look. "Defrost" was replaced with "Auto", and there is now the option to choose between two fan speeds rather than just one.

Jira tasks were also updated and divided among each team member.

Next Week's Objectives

• Work more with the Bluetooth connection between the Raspberry Pi and Nexus 7
• Work on code that will make the fan turn on or off when the user presses the button

IST 411 Team 2 Monitoring and Logging meeting minutes

Items discussed:

• General system interactions and the hierarchy between Monitoring and Logging classes
• The different methods used for parsing messages in the logging class
• Overall communication system functionality for entire car and our specific requirements for it
• Need for an effective testing harness to simulate messages coming from outside our system
• Communication issues between classes and what needs to be done to rectify

Items completed:

• Ran proof of concept message parsing algorithm based on message payloads and origin IDs
• Created simple test file to test Logging class db functionality - needs further development
• Created basic communication diagram for Xbees
• Updated Message class with new methods for better encapsulation
• Updated Message Unit tests to test new methods
• Updated Jira

Drivetrain System Progress Report

Team Meeting: Monday, October 24, 2016

Team 6 - Safety and Access Control System Meeting Minutes

Wednesday, 10/26 - Google Hangouts

Tasks:

• Get pins soldered on Adafruit NFC Breakout Board to connect to RPi and start working on code
• Get sounds of car alarm and door locking/unlocking working from Android App and automatically playing on RPi
• Figure out XBee communication with 411
• Reorganize folder structures and code
• Configure Grove Touch Sensor on GrovePi to RPi

Car Construction Progress

The car now has a mounting plate for "forward facing components" like the headlights (only one mounted) ping sensor and two speakers for the horn.

I have also added two ping sensors to the sides of the car to help with the vehicle's spacial awareness. They do not protrude outside the frame perimeter in order to minimize damage in the event of a collision.

Lastly, I have configured and mounted 4 Xbees S2 Pro modules on the back. They communicate successfully using a serial emulator terminal, but have yet to be tested with the Pis. This is a matter of implementation - Joe already has two S1s running on a separate setup.

IST411 Team 3 Connectivity and Notification

Our group met together on 10/19/16 to discuss a few things we want and need.

What we've been working on:

• Cleaning / unit testing phase
• Connecting to the net via Bluetooth

What needs to be done for next week:

• Grab messages from other classes
• More data testing with connectivity and notifications

What we need from other systems according to the message layout:

• Emergency messages
• door lock/unlock messages
• battery level messages
• faulty parts messages
• faulty heating / cooling messages

Draft ISt 440W Poster

IST 411 Team 1 Command and Control progress charts

Team meeting 10/20/16 (in-class)

• Voltage levels working on the MoPi
• Researching how to convert voltage into percentage
• Android code still in-progress
• Mock display on the Nexxus screen in-progress
• Updated Jira

Drivetrain System Progress Report

Team Meeting: Monday, October 9, 2016

Python Development:

• Learned about the RC car
• Learned that we need to make modifications to current Python code used for the Gopi Go to work with the RC car
• Learned about the workings of a servo
• Worked on coming up with a formula to use for the accelerometer to get the speed of the RC car in motion

Android Development:

• Coding for dashboard has progressed
• Managed to incorporate a progress bar to surround the speedometer 
• Managed to get the symbols P, R, N, D to display at the bottom of the dashboard screen

Team Meeting: Thursday, October 20 2016

Python Development:

• Using Gopi Go servo code for testing
• Testing if old servo code for Gopi Go works with the servo that we obtained
• Testing if the forward and backward movements from our Gopi Go car code will work with the servo
• Old servo code used for Gopi Go was useless
• Made modifications to servo code
• Managed to get basic functioning of servo working

Android Development:

• P, R, N, and D were programmed to change back and forth as toggle buttons to display what position the car has shifted into: Park, Reverse, Neutral, and Drive
• Coding is being done to have the speed of the car display within the rotating progress bar

Team 3 Climate Control Meeting Minutes and Progess

Meeting Minutes:

- Monday 10/17 - (Hangouts) 1.5 hours
- Wednesday 10/19 - (Hangouts) 2.5 hours

Worked on:

- Fixed temperature senor problem with relay
- Finished python code for outside weather API
- Wrote a JSON message from pyhton
- JSON message for humidity
- Completed Android UI



Working Towards:

- Reading a JSON file into Android Studio
- Read JSON message of humidity to determine wheather the defrost button should be on or off
- JSON message for reading increase temperature and heating pad

Team 6 - Safety and Access Control System Meeting Minutes

Wednesday, 10/19 - Google Hangouts

Discussed our next tasks for the project:

• Code for NFC module 
• Get sounds to play when locking/unlocking car doors and car alarm going off (i.e. when car is hit when parked)
• Talk to Ivan about connecting the pins on the RPi and Adafruit NFC tomorrow in class

Updated Android App with unlocking/locking and car alarm functionalities:

IST 411 Monitoring and Logging Team Meeting Minutes

Worked on logging class code and tested db additions
Current algorithms in development:

• takes message
• dumps into db
• separate collections
• checking for errors

Tasks given high priority for upcoming week:

• unit test for message class / update
• refactor monitoring to make threading external
• worked on recieving messages from Xbees
• started logging request format definition
• defined health code statuses

Git code additions

• Added message standards to git repo
• Added system abbreviations to git repo
• logging class updates

GrovePi Mandatory Reading

Hey you! Yeah, you, I'm looking at you. Are you using a Grove Pi to prototype, test, or even planning on implementing it in your project? Have you read any documentation on it? What if I asked you which pins are being used in the Pi GPIO header and which ones were free, would you know the answer?

Based on some of the looks I got last week in class when I asked questions about how the Grove Pi communicated with the RPi and how it talked to its sensors, I think it's time anybody within 5 feet of one of these awesome boards looks at how they work. Even a basic understanding of how it works and what pins go where will make your life easier when you troubleshoot your hardware.

Lets start with what the GrovePi is. The grove Pi is an Arduino Uno with a bunch of plugs. That's it. If you don't know what that is, it's okay - it's essentially another little computer, a bit less powerful than your Pi but really good at talking to sensors. This is what your GrovePi looks like without all the handy connectors and pin headers:

It can run alone if need be, though in the case of the GrovePi, it needs to talk to something in order to be useful. How does it do that? It uses a series of GPIO pins on the RPi. The SPI pins GPIO 8,9,10 and 11 are connected directly to the GrovePi and are used to update new firmware on the GrovePi. The UART GPIO 14 and 15 are connected to a Grove Port and can be used to connect a UART sensor directly to the Raspberry Pi. The actual communication between the GrovePi and the RPi happen over I2C lines GPIO 2 and 3. Aside from those pins, the rest of the pins on the RPi GPIO header should be open for you to use for other functions.

Let's take a look at the GrovePi pinouts now. Below is a diagram of what each pin does on the GrovePi. If you're interested in a more in depth discussion of these capabilities, have a look at the documentation page.

You will see two types of I/O ports, digital and analog (analog port numbering convention for the Arduino is 'A#') Remember, these pins don't map directly to the RPi GPIO, they are separate and only belong to the Arduino (They are accessible from the RPi via the I2C communication bus). Aside from the built in python libraries for the grove sensors that you are already familiar with, each of these pins can be controlled individually, which gives you a lot of power over what they can do. You can even run servos from here (PWM pins)! Sorry for the misinformation I have spread earlier, I didn't look at the specs before coming in to help. If you want to learn more about that, look at the documentation link above.

If you're running other hats on your Pi, check this awesome interactive site - it lets you know which pins are being used for a number of popular hats, along with a general description of what each RPi GPIO pin does: http://pinout.xyz/pinout/

Team 5 Graphs and Meeting Minutes

Team Meeting: 10/18/16 (in class)

• Created static IP for Pi
• Connected Android to Pi via SSH
• Amanda Neal and Shubham Patel are no longer in our group.
• Jeannie Rodriguez---weekly blog
• Divided tasks that needs to be done this week

Car Progress

Over the weekend, I assembled the pi cluster and hooked them up to a power bus running on the main vehicle battery. I also created a mounting board for the rear sensors and lights. My next step is to mount the XBees and verify that the Pis are communicating properly.

Team 6 - Safety and Access Control System Meeting Minutes/Progress

During class time:

• Tried getting PulseAudio to automatically start on the Pi but did not succeed (We will solve this!)
• Verified our python codes work on the SenseHAT connected to the Pi and from Android App (Icons of door/car status: Lock/Unlock, Auto Lock, Speaker On/Off)
• Received Grove Touch Sensor along with the Adafruit PN532 NFC Shield from Joe and had help from Ivan soldering the pins. Researched how to connect it to the Pi and will continue working on it

Google Hangouts (10/13 - Thursday Night)

• Discussed our further tasks:
• PulseAudio to auto start on the Pi
• Pi to auto connect to the bluetooth speaker
• Start working on NFC code
• Updated our board and generated reports on Jira:

Cumulative Flow Diagram:

Created vs. Resolved Issues Report:

Pie Chart: