def Connect(): #Conectar a una red
option=raw_input("\n Desea Conectarse a alguna red? \n s=Si n=No \n" )
yes= "s" or "S"
no= "n" or "N"
if option == yes:
ssid=raw_input("\n Ingrese el SSID de la red\n")
password=raw_input("\n Contrasenna\n")
from wireless import Wireless
wireless = Wireless()
wireless.connect(ssid=ssid, password=password)
if wireless :
print "\n Conexion establecida"
else:
print "\n No se pudo conectar a la red, verifique el SSID y la contrasena ingresada"
elif option==no:
pass
else:
print "\n Ingrese una opcion correcta"
Connect()
def get_wifi_devs():
try:
from wireless import Wireless
w = Wireless()
return w.interfaces()
except:
return []
def network_connect():
print "connecting to ssid: Ashwin"
wireless = Wireless()
res = wireless.connect(ssid='Ashwin', password='')
if not res:
print "error connectingi to Ashwin..."
print "connected. continue..."
def __init__(self, socket=None):
self.socket = socket
#used to switch connection
self.connectionManager = Wireless()
#array of drone initializer
self.drones = {'Solo Gold': None, 'Solo Green': None}
def getMyMac():
try:
wireless = Wireless()
ifaces = wireless.interfaces()
iface = ifaces[-1]
mac = (netifaces.ifaddresses(iface)[netifaces.AF_LINK][0]['addr'])
return mac
except:
print("Please manually select your interface using ifconfig or ipconfig using the -i flag")
sys.exit(-1)
def actionOk(self, event):
password = self.linkField.GetValue()
print WIFI+password
wireless = Wireless()
retorno=wireless.connect(ssid="%s" % WIFI, password="******" % password)
if retorno==True :
self.GetParent().Destroy()
else:
self.GetParent().ChangePanel()
print retorno
def showImage(self):
data = self.lineEdit.text()
text = self.comboBox.currentText()
wireless = Wireless()
wireless.connect(ssid=text,password=data)
self.stackedWidget.setCurrentIndex(1)
#p = Process(target=self.serverthread,args=())
#p.start()
start_new_thread(self.serverthread,())
self.stop_thread_signal.connect(self.changeDisplay)
def get_networks(self):
wireless = Wireless()
ifs = wireless.interfaces()
if len(ifs) == 0:
return []
res = []
for c in Cell.all(ifs[0]):
res.append(c.ssid)
return res
def guesser():
"""guess 'u' or 'h'"""
try:
from wireless import Wireless
wireless = Wireless()
connection = wireless.current()
if connection.startswith('eduroam') or connection.startswith('saar'):
return 'u'
else:
return 'h'
except:
return 'u'
def iBot(i):
wireless = Wireless(['wlan0'])
link="https://rajayalla98.pythonanywhere.com/get"
if i == 9:
if wireless.connect(ssid='I-Bot', password='******'):
time.sleep(100)
print wireless.current()
response = urllib2.urlopen('http://11.11.11.11/')
html = response.read()
humidity,temperature = html.split("....")
print humidity,temperature
return temperature,humidity
else:
print "Did not connect"
return [tem,hum]
elif i == 19:
if wireless.connect(ssid='Dont ask me', password='******'):
data = {'temperature':tem,'humidity':hum}
time.sleep(10)
print wireless.current()
requests.get(link,params=data)
return [tem,hum]
else:
print "Did not connect"
return [tem,hum]
else:
print "in loop"
return [tem,hum]
def connect_wifi(wifi='WIFI'):
"""
Connect WiFi network
Args:
wifi (str) WIFI or GOPRO, indicate wich wifi use.
Returns:
Void
Raises:
idk yet.
"""
from wireless import Wireless
W = Wireless()
W.interface()
if wifi == 'WIFI':
W.connect(ssid=_.WIFI_SSID, password=_.WIFI_PASS)
elif wifi == 'GOPRO':
W.connect(ssid=_.GOPRO_WIFI, password=_.GOPRO_PASS)
else:
print('No option!')
return False
def main():
import argparse
parser = argparse.ArgumentParser("A watcher for ping")
parser.add_argument("--testing", action="store_true")
args = parser.parse_args()
logging.basicConfig(level=logging.DEBUG if args.testing else logging.INFO)
client = ActivityWatchClient("aw-watcher-network", testing=args.testing)
bucketname = "{}_{}".format(client.client_name, client.client_hostname)
eventtype = "ping"
client.create_bucket(bucketname, eventtype)
logger.info("Starting to log ping")
while True:
t = datetime.utcnow()
sleeptime = 60 - (t.second + t.microsecond / 1000000.0)
sleep(sleeptime)
timestamp = datetime.now(pytz.utc)
wifiname = Wireless().current()
try:
out = ping(30)
client.send_events(bucketname,
createEvents(out, timestamp, wifiname))
logger.info("Sent events")
except Exception as e:
import sys, traceback
traceback.print_exc()
logger.error("Exception thrown while pinging {}".format(e))
def authenticateWifi(ssid, password):
signal.signal(signal.SIGALRM, handler)
signal.alarm(
20) #Set the parameter to the amount of seconds you want to wait
try:
#RUN CODE HERE
wireless = Wireless()
wireless.connect(ssid, password)
except:
pass
#print(2)
signal.alarm(20) #Resets the alarm to 30 new seconds
signal.alarm(0) #Disables the alarm
def send_alert(message=' ⚠️ *Error* al conectarse con la GoPro',
telf=_.DEFAULT_TELF):
from twilio.rest import Client
from wireless import Wireless
from util import _constants as _
w = Wireless()
w.interface()
wf = w.connect(ssid=_.WIFI_SSID, password=_.WIFI_PASS)
client = Client(account_sid, auth_token)
message = client.messages.create(from_='whatsapp:+14155238886',
body=message,
to='whatsapp:{}'.format(telf))
print(message.sid)
def drone_connect():
print "connecting to drone..."
wireless = Wireless()
res = wireless.connect(ssid='ardrone2_047592', password='')
if not res:
print "error connecting..."
return
print "connected. starting telnet"
HOST = "192.168.1.1"
tn = telnetlib.Telnet(HOST)
command = 'killall udhcpd; iwconfig ath0 mode managed essid "Ashwin"; ifconfig ath0 192.168.43.50 netmask 255.255.255.0 up;'
tn.write(command)
tn.write("exit\n")
class Network:
def __init__(self):
self.network = Wireless()
self.networkLock = threading.Lock()
self.defaultNetwork = config.getDefaultNetwork()
def connect(self, ssid, pw, lock=True):
if lock == True:
self.networkLock.acquire()
if self.network.current() != ssid:
if timed(lambda: self.network.connect(ssid=ssid, password=pw), 8) == False:
raise NetworkError(ssid)
else:
if ssid != self.network.current():
raise NetworkError(ssid)
def disconnect(self):
self.networkLock.release()
def connectToDefault(self):
self.network.connect(ssid=self.defaultNetwork[0], password=self.defaultNetwork[1])
def getSSIDList(self):
try:
ssids = []
nmc = NMClient.Client.new()
devs = nmc.get_devices()
for dev in devs:
if dev.get_device_type() == NetworkManager.DeviceType.WIFI:
for ap in dev.get_access_points():
ssids.append(ap.get_ssid())
except:
pass
return ssids
def isGoPro(self, ssid):
lettersMatched = 0
matchWord = 'gopro'
for char in ssid:
if char.lower() == matchWord[lettersMatched]:
lettersMatched += 1
if lettersMatched == len(matchWord):
return True
return False
class WirelessUser(models.Model):
wifi = Wireless()
name = models.CharField(max_length=50, default="Home")
ssid = models.CharField(max_length=20)
password = models.CharField(max_length=20)
is_on = models.BooleanField(default=False)
def __str__(self):
return self.name
def start_wifi_check(self):
self.is_on = self.have_internet()
return self.is_on
def connectus(self):
self.is_on = self.wifi.connect(ssid=self.ssid, password=self.password)
print("First try...")
if self.is_on == False:
print("Second try...")
self.is_on = self.wifi.connect(ssid=self.ssid,
password=self.password)
if self.is_on == True:
print(self.ssid, self.password)
print("run worker")
#sleep(2)
os.system('sudo supervisorctl start motherworker')
self.save()
return self.is_on
def wifi_check(self):
#print (self.wifi.current())
#if self.wifi.current() == None:
if self.have_internet() != True:
if self.is_on == True:
os.system('sudo supervisorctl stop motherworker')
self.is_on = False
else:
if self.is_on == False:
self.is_on = True
os.system('sudo supervisorctl start motherworker')
self.save()
return self.is_on
def have_internet(self):
conn = httplib.HTTPConnection('www.google.com', timeout=5)
try:
conn.request("HEAD", "/")
conn.close()
print("We have true internet")
return True
except:
conn.close()
print("No internet connection!")
return False
def refresh_worker(self):
os.system('sudo supervisorctl stop motherworker')
os.system('sudo supervisorctl start motherworker')
print("worker has been restarted!")
def __init__(self, socket=None):
self.socket = socket
self.dronesName = ["Solo Gold", "Solo Green"]
self.wifiConnections = {
'Solo Gold': ['SoloLink_gold', 'sololinkmst'],
'Solo Green': ['SoloLink_MST', 'sololinkmst']
}
#used to switch connection
self.conn = Wireless()
#array of drones initializer
self.drones = {
'Solo Gold':
drone.Drone('Solo Gold', self.wifiConnections['Solo Gold']),
'Solo Green':
drone.Drone('Solo Green', self.wifiConnections['Solo Green'])
}
def connect_wifi(ssid: str, password: Optional[str] = None) -> bool:
UTIL_LOGGER.debug(f"connecting to {ssid}")
if sys.platform == 'linux':
from wireless import Wireless
return Wireless().connect(ssid=ssid, password=password)
elif sys.platform == 'win32' or sys.platform == 'cygwin':
import winwifi
return winwifi.WinWiFi.connect(ssid)
else:
UTIL_LOGGER.error(f"Can't auto-connect to wifi on {sys.platform}")
return False
def get_currently_connected_ap_ssid():
# strip() trims the trailing newline character
# Typically, decode-strip-split will convert the raw check_output() like
# b'wlan0 ESSID:"NyankoLab-2.4G"\n'
# into
# ['wlan0', 'ESSID:"NyankoLab-2.4G"']
# stdout = subprocess.check_output(['iwgetid']).decode('utf-8').strip().split()
# logging.info(f'Wi-Fi AP info: {stdout}')
# if len(stdout) < 2:
# return ''
# essid_and_name = stdout[1].split(':')
# if len(essid_and_name) < 2:
# logging.warn(f'iwgetid returned SSID info in an unexpected format: {stdout}')
# return ''
# ssid = essid_and_name[1].strip('"')
# return ssid if 0 < len(ssid) else None
w = Wireless()
ssid = w.current()
logging.info(f'Current ssid: {ssid}')
return ssid
def measure_once():
for SSID in SSIDS:
device_start_ts = time.time()
# Connect device to access point
wireless = Wireless()
ap_start_ts = time.time()
wireless.connect(SSID, PASSWORD)
ap_stop_ts = time.time()
# Connect client to node
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket_start_ts = time.time()
s.connect((TCP_IP, TCP_PORT))
socket_stop_ts = time.time()
send_start_ts = time.time()
s.send(MESSAGE)
send_stop_ts = time.time()
device_stop_ts = time.time()
s.close()
ap_delay_ms = (ap_stop_ts - ap_start_ts) * 1000
socket_delay_ms = (socket_stop_ts - socket_start_ts) * 1000
send_delay_ms = (send_stop_ts - send_start_ts) * 1000
device_delay_ms = (device_stop_ts - device_start_ts) * 1000
print("AP " + SSID + ": start: " + str(ap_start_ts))
print("AP " + SSID + ": stop: " + str(ap_stop_ts))
print("AP " + SSID + ": delay: " + str(ap_delay_ms))
print("Socket " + SSID + ": start: " + str(socket_start_ts))
print("Socket " + SSID + ": stop: " + str(socket_stop_ts))
print("Socket " + SSID + ": delay: " + str(socket_delay_ms))
print("Send " + SSID + ": start: " + str(send_start_ts))
print("Send " + SSID + ": stop: " + str(send_stop_ts))
print("Send " + SSID + ": delay: " + str(send_delay_ms))
print("Device " + SSID + ": start: " + str(device_start_ts))
print("Device " + SSID + ": stop: " + str(device_stop_ts))
print("Device " + SSID + ": delay: " + str(device_delay_ms))
ap_measurements.append(ap_delay_ms)
socket_measurements.append(socket_delay_ms)
send_measurements.append(send_delay_ms)
device_measurements.append(device_delay_ms)
def getNetwork():
"""Tries to discover the name of the current network, first the
network interface but then the name of the WiFi network, if no
WiFi network is present, it will return the name of the network
interface. If there is no default route and thus no Internet then
it will return an empty string."""
gws = netifaces.gateways()
# Need to make sure the default route exists.
if gws['default'] != {}:
defaultGW = gws['default'][netifaces.AF_INET]
currentNetwork = defaultGW[1]
else: # If the above is true, there is no default route
return ""
# Now we need to check to see if we're on a WiFi network or not.
w = Wireless()
wName = w.current()
if not wName is None:
currentNetwork = wName
return currentNetwork
def main():
wireless = Wireless()
print("Switching to GoPro SSID={}...".format(Config.GoPro.SSID))
wireless.connect(ssid=Config.GoPro.SSID, password=Config.GoPro.SSID_PASS)
print("Connected to GoPro SSID")
sleep(2) # sleep since it takes time for network connection to establish
print("Connecting to GoPro...")
gopro = GoProCamera.GoPro()
print("GoPro connected")
print("Downloading media...")
media = gopro.downloadAll(media_type=Config.MEDIA_TYPE,
dest_folder=Config.MEDIA_DEST_FOLDER)
print("Download complete")
if (Config.GoPro.is_power_off_when_done):
print("Powering off GoPro...")
gopro.power_off()
print("GoPro powered off")
print("Switching to Home SSID={}...".format(Config.HomeNetwork.SSID))
wireless.connect(ssid=Config.HomeNetwork.SSID,
password=Config.HomeNetwork.SSID_PASS)
print("Connected to Home SSID")
sleep(2)
print("Starting upload to Google Photos...")
googlephotos.upload_folder(os.path.abspath(Config.MEDIA_DEST_FOLDER),
album=Config.GooglePhotos.DEST_ALBUM,
auth_file=Config.GooglePhotos.CREDENTIALS_PATH)
print("Upload to Google Photos complete")
def announce_ip():
index = 0
wireless = Wireless()
while index < 200:
print '++ attempting to announce ip: {}'.format(index)
try:
ip_address = get_ip()
current_connection = wireless.current()
print '++ found ip_address: {}'.format(str(ip_address))
print '++ found current_connection: {}'.format(str(current_connection))
routes = subprocess.check_output('route -n', shell=True)
print '++ routes'
print routes
print '++ endroutes'
if ip_address:
slack_notify_message('@channel: its pi: {} | {}'.format(str(ip_address), str(current_connection)))
break
# else try to connect
if USE_PYTHON_TO_CONNECT:
print '++ trying to connect'
connected = wireless.connect(ssid=SECRETS_DICT['WIFI_SSID'], password=SECRETS_DICT['WIFI_PASSWORD'])
if not connected:
print ':-( failed to connect'
else:
print ':) connected'
except Exception as e:
print ':/ error: {}'.format(str(e.message))
pass
index += 1
time.sleep(1)
# after we have connected, log some info about the connection
if LOG_DETAILED_INFO:
try:
print '++++ logging detailed info'
ifconfig = subprocess.check_output('ifconfig', shell=True)
print 'ifconfig: {}'.format(ifconfig)
iwget = subprocess.check_output('iwgetid', shell=True)
print 'iwget: {} | {}'.format(iwget, get_ip())
except Exception as e:
print 'warning: failed to log detailed info: {}'.format(e.message)
def __init__(self):
self.disp = Display(Pin(DC), Pin(RES), Pin(CS), W, H, B)
self.disp.show_progress('Start', 3)
self.th = TempHumi(Pin(DHT))
self.sgp = CO2TVOC(Pin(SCL), Pin(SDA))
self.wireless = Wireless(WIFI_NAME, WIFI_PASSWORD)
self.datetime = DateTime(self.wireless)
self.logger = Logger(LOG_FILENAME)
self.logger.write_startlog('\nSTART\n')
self.pubcli = MQTT_CLI(self.wireless, MQTT_CLIENT_NAME, MQTT_SEVER_IP)
self._count = 0
self._boarder_state = True
def checkNetwork(ssid):
timeout = 20
sleeptime = 5
loop = 0
while loop < timeout:
wireless = Wireless()
s = wireless.current()
# Connected to a wifi network
if s is not None:
# Total network
if s == ssid:
print("+-[Connected] to {}".format(ssid))
return True
# Another wifi network
else:
return True
else:
print("+-[Not connected] to {}. Waiting 5s to retry".format(ssid))
time.sleep(sleeptime)
loop += 1
return False
def __init__(self, event):
super().__init__()
self.stopped = event
self.count = 0
self.wlan_count_found = 0
self.wireless_module = Wireless()
self.wlan_name_found_to_connect = ""
self.wlan_name_found_to_connect_time = 999999999999
# defines a hotspot object with the ssid "Test Wlan" and the password from the constants,
# ssid will be changed later. Because of a known bug, the hotspot is stopped once before the start.
self.access_point = pyaccesspoint.AccessPoint(
ssid="Test Wlan", password=const.Connection.WLAN_PASSWORD)
self.access_point.stop()
self.hotspot_status = False
self.own_wlan_name_from_hotspot = "parknet"
self.own_wlan_time_from_hotspot = 9999999999999
self.last_wlan_connected = "unset"
self.block_list = []
def callback(self):
if 'wifi_list' not in self.mongo_document:
def blacklisted(iface):
"""
Checks if interface starts with
- smoothie
- mon
"""
return iface.startswith('smoothie') or iface.startswith('mon')
ifaces = [a for a in Wireless().interfaces() if not blacklisted(a)]
self.update({'$set': {'wifi_list': ifaces}})
self.stop()
def __init__(self, socket = None):
self.socket = socket
self.dronesName = ["Solo Gold", "Solo Green"]
self.wifiConnections = {
'Solo Gold' : ['SoloLink_gold', 'sololinkmst'],
'Solo Green' : ['SoloLink_MST', 'sololinkmst']
}
#used to switch connection
self.conn = Wireless()
#array of drones initializer
self.drones = {
'Solo Gold' : drone.Drone('Solo Gold', self.wifiConnections['Solo Gold']),
'Solo Green' : drone.Drone('Solo Green', self.wifiConnections['Solo Green'])
}
def main():
wireless = Wireless()
while(True):
if wireless.current() == ssid:
print "Already connected to {0}".format(ssid)
break
while wireless.current() != ssid:
print "Connecting..."
wireless.connect(ssid=ssid, password=password)
if wireless.current() == ssid:
print "Connected to: {0}".format(ssid)
break
def __init__(self, log_level=logging.INFO):
# setup log
log_file = '/var/log/gopro-proxy.log'
log_format = '%(asctime)s %(message)s'
logging.basicConfig(format=log_format, level=log_level)
# file logging
fh = logging.FileHandler(log_file)
fh.setLevel(log_level)
fh.setFormatter(logging.Formatter(log_format))
logger = logging.getLogger()
logger.setLevel(log_level)
logger.addHandler(fh)
# setup camera
self.camera = GoProHero()
self.snapshots = os.environ.get('GOPRO_SNAPSHOTS', True)
# setup wireless
interface = os.environ.get('GOPRO_WIFI_INTERFACE', None)
self.wireless = Wireless(interface)
def add_to_file(network_data):
os.system("echo '"+str(network_data)+"' >> /home/pi/Desktop/networks.txt")
serialSocket = serial.Serial(
port='/dev/ttyUSB0',
baudrate = 9600,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
bytesize=serial.EIGHTBITS,
timeout=1
)
while 1:
try:
data = serialSocket.readline()
wireless = Wireless()
zero,first,second = data.split(',')
if (zero == "network"):
print("ssid: "+first+ " pass: "******"Conectando a internet.")
if (internet_on()):
add_to_file(data);
print("Conectado a internet.")
serialSocket.write("Datos Correctos")
os.system("echo \"$(date '+%Y/%M/%D %H:%M:%S')-> Conetado a la red brindada\" >> /home/pi/Desktop/log.txt")
break;
else:
print("No conectado a internet.")
os.system("echo \"$(date '+%Y/%M/%D %H:%M:%S')-> No conectada a la red brindada\" >> /home/pi/Desktop/log.txt")
serialSocket.write("No se pudo conectar a esa red")
class ConnectToSSID:
def __init__(self, ssid, password):
self.ssid = ssid
self.password = password
self.wireless = Wireless()
self.system = platform.system()
def connect(self):
if self.system == 'Linux':
self.connect_linux()
if self.system == 'Darwin':
self.connect_osx()
if self.system == 'Windows':
self.connect_windows()
def connect_linux(self):
while(True):
if self.wireless.current() == self.ssid:
print "Already connected to {0}".format(self.ssid)
break
while self.wireless.current() != self.ssid:
print "Connecting..."
self.wireless.connect(ssid=self.ssid, password=self.password)
if self.wireless.current() == self.ssid:
print "Connected to: {0}".format(self.ssid)
break
def get_mac_address(self):
ifname = 'wlan0'
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
info = fcntl.ioctl(s.fileno(), 0x8927, struct.pack('256s', ifname[:15]))
return ':'.join(['%02x' % ord(char) for char in info[18:24]])
def connect_osx(self):
reload(sys)
sys.setdefaultencoding('utf8')
ssid_osx = self.ssid.replace (" ", "\ ")
while(True):
if self.wireless.current() == self.ssid:
print "Already connected to {0}".format(self.ssid)
break
while(True):
if self.find_ssid() == True:
print "SSID: {0} found".format(self.ssid)
break
while(True):
if self.wireless.current() != self.ssid:
print "Connecting..."
try:
threading.Timer(5, self.timeout).start()
self.wireless.connect(ssid=ssid_osx, password=self.password)
except:
break
if self.wireless.current() == self.ssid:
print "Connected to: {0}".format(self.ssid)
break
def ssid_list(self):
cmd = '/System/Library/PrivateFrameworks/Apple80211.framework/Versions/Current/Resources/airport -s'
p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True)
output = p.stdout.read()
output = str(output)
return output
def find_ssid(self):
while(True):
ssid_list = self.ssid_list()
num = int(ssid_list.find(self.ssid))
if num >= 0:
return type(num) is int
if num < 0:
print "Searching for SSID: {0}".format(self.ssid)
continue
break
def timeout(self):
thread.interrupt_main()
def connect_windows(self):
print "Doesn't currently support Windows"
class ServerBrain:
def __init__(self, socket = None):
self.socket = socket
self.dronesName = ["Solo Gold", "Solo Green"]
self.wifiConnections = {
'Solo Gold' : ['SoloLink_gold', 'sololinkmst'],
'Solo Green' : ['SoloLink_MST', 'sololinkmst']
}
#used to switch connection
self.conn = Wireless()
#array of drones initializer
self.drones = {
'Solo Gold' : drone.Drone('Solo Gold', self.wifiConnections['Solo Gold']),
'Solo Green' : drone.Drone('Solo Green', self.wifiConnections['Solo Green'])
}
def getDistanceMeters(firstLocation, secondLocation):
latitude = float(secondLocation.lat) - float(firstLocation.lat)
longitude = float(secondLocation.lon) - float(firstLocation.lon)
return math.sqrt((latitude*latitude) + (longitude*longitude))*1.113195e5
def switchConnection(self, droneName):
print "I'm going to switch WiFi connection, ", droneName
return self.conn.connect(ssid=self.drones[droneName].wifiConnection[0], password=self.drones[droneName].wifiConnection[1])
def connectDrone(self, droneName):
if self.conn.current() != self.wifiConnections[droneName]:
if self.switchConnection(droneName) == False:
#self.conn.power(False) #this command sets off the WiFi antenna
return droneName + " netwotk is not reacheble"
self.drones[droneName].connect()
location = self.drones[droneName].getActualLocation()
return location
def activateThread(self, functionName, name, listOfLocations):
if functionName == "flight":
eventlet.spawn(self.flight, listOfLocations, name)
def arm(self, name):
print "Arming... ", name
self.switchConnection(name)
self.drones[name].vehicle = connect('udpout:10.1.1.10:14560', wait_ready=True)
print "Current WiFi network: ", self.conn.current()
print "Vehicle of " + name + " is: ", self.drones[name].vehicle is not None
print name + " is armable: ", self.drones[name].vehicle.is_armable
while not self.drones[name].vehicle.is_armable:
print "Waiting for vehicle to initialise..", name
self.drones[name].vehicle.mode = VehicleMode("GUIDED")
self.drones[name].vehicle.armed = True
print name + " armed: ", self.drones[name].vehicle.armed
while not self.drones[name].vehicle.armed:
print "Waiting for arming ", name
time.sleep(1)
print "I finish the arm function execution and I'm ready to take off, ", name
def flight(self, listOfLocations, name):
print "I'm " + name + " and I'm inside flight function"
self.arm(name)
targetAltitude = 2
self.drones[name].vehicle.simple_takeoff(targetAltitude)
eventlet.sleep(5)
while True:
print "I'm trying to understand if I reach the target altitude ", name
eventlet.sleep(3)
self.switchConnection(name)
message = {"reached": False , "altitude": self.drones[name].vehicle.location.global_relative_frame.alt, "name" : name}
if self.drones[name].vehicle.location.global_relative_frame.alt >= targetAltitude*0.95:
message = {"reached": True , "altitude": targetAltitude, "name" : name}
self.drones[name].vehicle.mode = VehicleMode('RTL')
self.socket.emit('Altitude Reached', message)
if message["reached"] == True:
break
eventlet.sleep(3)
self.drones[name].buildListOfLocations(listOfLocations)
for locationToReach in listOfLocations:
eventlet.sleep(3)
self.switchConnection(name)
#self.drones[name].vehicle = connect('udpout:10.1.1.10:14560', wait_ready=True)
print "Location to reach for " + name + " is ", locationToReach
soloCurrentLocation = vehicle.location.global_relative_frame
targetDistance = self.getDistanceMeters(soloCurrentLocation, locationToReach)
self.drones[name].vehicle.simple_goto(locationToReach)
eventlet.sleep(2)
while True:
self.switchConnection(name)
soloCurrentLocation = self.drones[name].vehicle.global_relative_frame
remainingDistance = self.getDistanceMeters(soloCurrentLocation, targetDistance)
socketio.emit('Update Live Location', {
"name": name,
"status": "flying",
"latitude" : soloCurrentLocation.lat,
"longitude" : soloCurrentLocation.lon,
"altitude" : soloCurrentLocation.alt,
})
if remainingDistance <= targetDistance * 0.05:
#here the code for taking picture
socketio.emit('Update Live Location', {
"name": name,
"status": "reached"
})
break
eventlet.sleep(2)
#self.drones[name].vehicle = connect('udpout:10.1.1.10:14560', wait_ready=True)
self.drones[name].vehicle.mode = VehicleMode('RTL')
from wireless import Wireless
import wifi
import time
import socket
wifilist = []
wireless=Wireless()
interface=wireless.interface()
Zentri_ssid_string='ZentriOS'
def Search():
cells = wifi.Cell.all(interface)
for cell in cells:
wifilist.append(cell)
return wifilist
def FindFromSearchList(ssid):
wifilist = Search()
for cell in wifilist:
if ssid in cell.ssid:
return cell
return False
def FindFromSavedList(ssid):
cell = wifi.Scheme.find(interface, ssid)
def getSSID(): from wireless import Wireless wireless = Wireless() return wireless.current()
def getNetworkInfo(): global IP, ssid wireless = Wireless() ssid = wireless.current() p = subprocess.Popen(['hostname', '-I'], stdout=subprocess.PIPE,stderr=subprocess.PIPE) IP, err = p.communicate()
import Adafruit_Nokia_LCD as LCD import Adafruit_GPIO.SPI as SPI import psutil import math import requests import json from PIL import Image from PIL import ImageDraw from PIL import ImageFont from subprocess import check_output from gpiozero import CPUTemperature from wireless import Wireless wireless = Wireless() # Raspberry Pi software SPI config: SCLK = 17 DIN = 18 DC = 27 RST = 23 CS = 8 # Software SPI usage (defaults to bit-bang SPI interface): disp = LCD.PCD8544(DC, RST, SCLK, DIN, CS) # Initialize library. disp.begin(contrast=100)
class MainWindow(QtGui.QWidget):
def __init__(self):
QtGui.QWidget.__init__(self)
##### Camera / Wifi Configuration imports
with open("sony/camera_settings.config") as json_file:
json_data = json.load(json_file)
self.SSID = json_data['ssid']
self.PASSWORD = json_data['password']
#self.MAC_ADDRESS = json_data['mac_address']
self.IP_ADDRESS = json_data['ip_address']
#self.MODEL = json_data['model']
self.wireless = Wireless()
if self.wireless.current() == self.SSID:
self.api = Controller(self.IP_ADDRESS)
self.sonycap = SonyCV(self.IP_ADDRESS)
else:
print "Camera WiFi not connected"
self.fps = 30
self.sdcard_path = None
self.video_path = None
# Creates QPixmap of a black rectangle as video placeholder
# Livestream default size (Sony) = 640 x 360
black_rect = QtGui.QPixmap(640, 360)
black_rect.fill(QtGui.QColor("black"))
##### Widget Definitions / Settings
self.video_frame_left = QtGui.QLabel()
self.video_frame_right = QtGui.QLabel()
self.video_frame_left.setPixmap(black_rect)
self.video_frame_right.setPixmap(black_rect)
self.listwidget = QtGui.QListWidget(self)
self.SDPath_label = QtGui.QLabel(self)
self.SDPath_label.setText("SD Card Path:")
self.SDPathButton = QtGui.QPushButton("Set")
self.SDPathButton.clicked.connect(self.getSDPath)
self.SDPath = QtGui.QLineEdit(self)
self.SDPath.setReadOnly(True)
self.videoPath_label = QtGui.QLabel(self)
self.videoPath_label.setText("Videos Destination:")
self.videoPathButton = QtGui.QPushButton("Set")
self.videoPathButton.clicked.connect(self.getVideoPath)
self.videoPath = QtGui.QLineEdit(self)
self.videoPath.setReadOnly(True)
self.transfer_label = QtGui.QLabel(self)
self.transfer_label.setText("Transfer Videos:")
self.transfer_button = QtGui.QPushButton("Transfer")
self.transfer_button.clicked.connect(self.get_files_from_sdcard)
self.convert_videos_label = QtGui.QLabel(self)
self.convert_videos_label.setText("Convert videos to h.264:")
self.convert_videos_button = QtGui.QPushButton("Convert")
self.convert_videos_button.clicked.connect(self.convert_videos)
self.camera_wifi_label = QtGui.QLabel(self)
self.camera_wifi_label.setText("Camera Wifi:")
self.camera_wifi_connected_label = QtGui.QLabel(self)
self.camera_wifi_connected()
self.controls_label = QtGui.QLabel(self)
self.controls_label.setText("Controls")
self.controls_label.setFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold))
self.controls_label.setAlignment(QtCore.Qt.AlignCenter)
self.settings_label = QtGui.QLabel(self)
self.settings_label.setText("Settings")
self.settings_label.setFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold))
self.settings_label.setAlignment(QtCore.Qt.AlignCenter)
self.transfer_convert_label = QtGui.QLabel(self)
self.transfer_convert_label.setText("Transfer / Convert")
self.transfer_convert_label.setFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold))
self.transfer_convert_label.setAlignment(QtCore.Qt.AlignCenter)
self.stream_label = QtGui.QLabel(self)
self.stream_label.setText("Live Stream:")
self.stream_button = QtGui.QPushButton('Start')
self.stream_bool = False
#self.connect(self.stream_button, QtCore.SIGNAL("released()"), self.stream_toggle)
self.stream_button.released.connect(self.stream_toggle)
self.stream_light = QtGui.QLabel(self)
self.record_label = QtGui.QLabel(self)
self.record_label.setText("Video Record:")
self.record_button = QtGui.QPushButton('On')
self.record_bool = False
#self.connect(self.stream_button, QtCore.SIGNAL("released()"), self.stream_toggle)
self.record_button.released.connect(self.record_toggle)
self.record_light = QtGui.QLabel(self)
self.beepMode_label = QtGui.QLabel(self)
self.beepMode_label.setText("Beep Mode:")
self.beepMode_checkbox = QtGui.QCheckBox()
self.connect(self.beepMode_checkbox, QtCore.SIGNAL('stateChanged(int)'), self.beep_toggle)
self.flipMode_label = QtGui.QLabel(self)
self.flipMode_label.setText("Video Flip:")
self.flipMode_checkbox = QtGui.QCheckBox()
self.connect(self.flipMode_checkbox, QtCore.SIGNAL('stateChanged(int)'), self.flip_toggle)
self.format_quality_label = QtGui.QLabel(self)
self.format_quality_label.setText("Format / Quality:")
self.format_combobox = QtGui.QComboBox(self)
self.connect(self.format_combobox, QtCore.SIGNAL('activated(int)'), self.quality_handler)
self.quality_combobox = QtGui.QComboBox(self)
self.connect(self.quality_combobox, QtCore.SIGNAL('activated(int)'), self.video_settings_handler)
self.formats = ['XAVC S 4K', 'XAVC S', 'MP4']
XAVC_S_4K_qualities = ['100M 30p', '60M 30p', '100M 24p', '60M 24p']
XAVC_S_qualities = ['50M 60p', '50M 30p', '50M 24p', '100M 120p', '60M 120p', '100M 240p', '60M 240p']
MP4_qualities = ['PS', 'HQ', 'STD', 'HS120', 'HS240']
self.qualities = [XAVC_S_4K_qualities, XAVC_S_qualities, MP4_qualities]
##### Enabled / Disable buttons based on WiFi connection
if self.wireless.current() == self.SSID:
self.stream_button.setEnabled(True)
self.record_button.setEnabled(True)
self.beepMode_checkbox.setEnabled(True)
self.flipMode_checkbox.setEnabled(True)
self.format_combobox.setEnabled(True)
self.quality_combobox.setEnabled(True)
else:
self.stream_button.setEnabled(False)
self.record_button.setEnabled(False)
self.beepMode_checkbox.setEnabled(False)
self.flipMode_checkbox.setEnabled(False)
self.format_combobox.setEnabled(False)
self.quality_combobox.setEnabled(False)
gridLayout = QtGui.QGridLayout()
gridLayout.setSpacing(5)
gridLayout.setContentsMargins(5, 5, 5, 5)
# Top row
gridLayout.addWidget(self.controls_label, 0, 0, 1, 3)
gridLayout.addWidget(self.settings_label, 0, 3, 1, 3)
gridLayout.addWidget(self.transfer_convert_label, 0, 7, 1, 3)
gridLayout.addWidget(self.camera_wifi_label, 0, 11, 1, 1)
gridLayout.addWidget(self.camera_wifi_connected_label, 0, 12, 1, 1)
# Bottom row
gridLayout.addWidget(self.video_frame_left, 5, 0, 1, 6)
gridLayout.addWidget(self.video_frame_right, 5, 7, 1, 6)
# Column 1
gridLayout.addWidget(self.record_label, 1, 0, 1, 1)
gridLayout.addWidget(self.record_button, 1, 1, 1, 1)
gridLayout.addWidget(self.record_light, 1, 2, 1, 1)
gridLayout.addWidget(self.stream_label, 2, 0, 1, 1)
gridLayout.addWidget(self.stream_button, 2, 1, 1, 1)
gridLayout.addWidget(self.stream_light, 2, 2, 1, 1)
# Column 2
gridLayout.addWidget(self.format_quality_label, 2, 3, 1, 1)
gridLayout.addWidget(self.format_combobox, 2, 4, 1, 1)
gridLayout.addWidget(self.quality_combobox, 2, 5, 1, 1)
gridLayout.addWidget(self.beepMode_label, 3, 3, 1, 1)
gridLayout.addWidget(self.beepMode_checkbox, 3, 4, 1, 1)
gridLayout.addWidget(self.flipMode_label, 4, 3, 1, 1)
gridLayout.addWidget(self.flipMode_checkbox, 4, 4, 1, 1)
# Column 3
gridLayout.addWidget(self.SDPath_label, 1, 7, 1, 1)
gridLayout.addWidget(self.SDPathButton, 1, 8, 1, 1)
gridLayout.addWidget(self.SDPath, 1, 9, 1, 1)
gridLayout.addWidget(self.videoPath_label, 2, 7, 1, 1)
gridLayout.addWidget(self.videoPathButton, 2, 8, 1, 1)
gridLayout.addWidget(self.videoPath, 2, 9, 1, 1)
gridLayout.addWidget(self.transfer_label, 3, 7, 1, 1)
gridLayout.addWidget(self.transfer_button, 3, 8, 1, 1)
gridLayout.addWidget(self.convert_videos_label, 4, 7, 1, 1)
gridLayout.addWidget(self.convert_videos_button, 4, 8, 1, 1)
# Column 4
gridLayout.addWidget(self.listwidget, 1, 10, 4, 3)
# (widget_name, row, column, rows spanned, columns spanned)
self.setLayout(gridLayout)
self.setWindowTitle('Control Panel')
self.show()
self.timer = QtCore.QTimer()
self.init_gui_state()
def init_gui_state(self):
if self.wireless.current() == self.SSID:
# Initialize beep mode setting
if self.api.beepMode('Current') == 'On':
self.beepMode_checkbox.setChecked(True)
else:
self.beepMode_checkbox.setChecked(False)
# Initialize camera flip setting
if self.api.flipSetting('Current') == 'On':
self.flipMode_checkbox.setChecked(True)
else:
self.flipMode_checkbox.setChecked(False)
# Initialize format / quality settings
current_format, current_quality = self.api.videoSettings('Current')
for i, format in enumerate(self.formats):
self.format_combobox.addItem(format)
if current_format == self.formats[i]:
self.format_combobox.setCurrentIndex(i)
qualities = self.qualities[i]
for k, quality in enumerate(qualities):
self.quality_combobox.addItem(qualities[k])
if current_quality == qualities[k]:
self.quality_combobox.setCurrentIndex(k)
def camera_wifi_connected(self):
if self.wireless.current() == self.SSID:
self.camera_wifi_connected_label.setText("Connected")
self.camera_wifi_connected_label.setStyleSheet('QLabel {color: green;}')
else:
self.camera_wifi_connected_label.setText("Not Connected")
self.camera_wifi_connected_label.setStyleSheet('QLabel {color: red;}')
def stream_toggle(self):
#sending_button = self.sender()
#print sending_button.text()
if self.wireless.current() == self.SSID:
self.stream_bool = not self.stream_bool
if self.stream_bool:
self.startCapture()
self.stream_light.setText("Streaming")
self.stream_light.setStyleSheet('QLabel {color: red;}')
self.stream_button.setText("Stop")
#self.stream_button.setStyleSheet('QPushButton {color: white;}')
else:
self.stopCapture()
self.stream_light.setText("")
self.stream_button.setText("Start")
#self.stream_button.setStyleSheet('QPushButton {color: black;}')
def record_toggle(self):
#sending_button = self.sender()
#print sending_button.text()
if self.wireless.current() == self.SSID:
self.record_bool = not self.record_bool
if self.record_bool:
self.api.recordMode('On')
self.record_light.setText("Recording")
self.record_light.setStyleSheet('QLabel {color: red;}')
#self.record_light.setPixmap(QtGui.QPixmap("record-button.png"))
self.record_button.setText("Off")
#self.stream_button.setStyleSheet('QPushButton {color: white;}')
else:
self.api.recordMode('Off')
self.record_light.setText("")
self.record_button.setText("On")
#self.stream_button.setStyleSheet('QPushButton {color: black;}')
def startCapture(self):
if self.wireless.current() == self.SSID:
self.timer.timeout.connect(self.nextFrameSlot)
self.timer.start(1000./self.fps)
def stopCapture(self):
self.timer.stop()
def nextFrameSlot(self):
frame = self.sonycap.capture()
# Converts frame from BGR for RGB format
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
img = QtGui.QImage(frame, frame.shape[1], frame.shape[0], QtGui.QImage.Format_RGB888)
pix = QtGui.QPixmap.fromImage(img)
self.video_frame_left.setPixmap(pix)
def beep_toggle(self):
if self.wireless.current() == self.SSID:
if self.beepMode_checkbox.isChecked():
self.api.beepMode('On')
else:
self.api.beepMode('Off')
def flip_toggle(self):
if self.wireless.current() == self.SSID:
if self.flipMode_checkbox.isChecked():
self.api.flipSetting('On')
else:
self.api.flipSetting('Off')
def video_settings_handler(self):
current_format = str(self.format_combobox.currentText())
current_quality = str(self.quality_combobox.currentText())
# Selecting a quality after format will trigger a change
# of settings on the camera
self.api.videoSettings(current_format, current_quality)
def quality_handler(self):
current_format = str(self.format_combobox.currentText())
self.quality_combobox.clear()
for i, format in enumerate(self.formats):
if current_format == self.formats[i]:
qualities = self.qualities[i]
for k, quality in enumerate(qualities):
self.quality_combobox.addItem(qualities[k])
def getSDPath(self):
sdcard_path = QtGui.QFileDialog.getExistingDirectory(
self,
"Open a folder",
"/Volumes",
QtGui.QFileDialog.ShowDirsOnly)
self.sdcard_path = str(sdcard_path)
self.SDPath.setText(sdcard_path)
def getVideoPath(self):
video_path = QtGui.QFileDialog.getExistingDirectory(
self,
"Open a folder",
expanduser("~"),
QtGui.QFileDialog.ShowDirsOnly)
self.video_path = str(video_path)
self.videoPath.setText(video_path)
def get_files_from_sdcard(self):
fm = fileMover(self.sdcard_path, self.video_path)
fm.getFilesFromSDCard('XAVCS')
def convert_videos(self):
ffmpegConverter(self.video_path)
reload(sys)
sys.setdefaultencoding('utf8')
# function to check the presense of SSID
def is_present (candidate):
subprocess.call(["airport -s -x>ssids.xml"], shell=True)
myplist = plistlib.readPlist('ssids.xml')
print 'The current list is:', myplist
for el in myplist:
if candidate == el.get('SSID_STR'):
print 'State is valid'
return True
print 'State is not valid'
return False
wireless = Wireless()
print "Current: ", wireless.current()
print "Interfaces: ",wireless.interfaces()
# --------- Open the files
lines = [line.strip() for line in open("Untitled.txt", 'r')]
dones = [line.strip() for line in open("Done.txt", 'r')]
subprocess.call(["airport -s -x>ssids.xml"], shell=True)
f= open('Results.txt', 'a')
f2= open('Done.txt', 'a')
result = plistlib.readPlist('ssids.xml')
print 'Already done: ', dones
i = 0
# ------ Going to scan
for elem in result:
class GoProProxy:
maxRetries = 3
# init
def __init__(self, log_level=logging.INFO):
# setup log
log_file = '/var/log/gopro-proxy.log'
log_format = '%(asctime)s %(message)s'
logging.basicConfig(format=log_format, level=log_level)
# file logging
fh = logging.FileHandler(log_file)
fh.setLevel(log_level)
fh.setFormatter(logging.Formatter(log_format))
logger = logging.getLogger()
logger.setLevel(log_level)
logger.addHandler(fh)
# setup camera
self.camera = GoProHero()
self.snapshots = os.environ.get('GOPRO_SNAPSHOTS', True)
# setup wireless
interface = os.environ.get('GOPRO_WIFI_INTERFACE', None)
self.wireless = Wireless(interface)
# connect to the camera's network
def connect(self, camera):
func_str = 'GoProProxy.connect({}, {})'.format(
camera.ssid, camera.password)
# jump to a new network only if needed
if self.wireless.current() != camera.ssid:
self.wireless.connect(
ssid=camera.ssid, password=camera.password)
# evaluate connection request
if self.wireless.current() == camera.ssid:
# reconfigure the password in the camera instance
self.camera.password(camera.password)
logging.info('{}{}{}'.format(Fore.CYAN, func_str, Fore.RESET))
return True
else:
logging.info('{}{} - network not found{}'.format(
Fore.YELLOW, func_str, Fore.RESET))
return False
# send command
def sendCommand(self, command):
result = False
# make sure we are connected to the right camera
if self.connect(command.camera):
# try to send the command, a few times if needed
i = 0
while i < self.maxRetries and result is False:
result = self.camera.command(command.command, command.value)
i += 1
else:
# mini-status update if we couldn't connect
command.camera.last_attempt = timezone.now()
command.camera.summary = 'notfound'
# did we successfully talk to the camera?
self.updateCounters(command.camera, result)
command.camera.save()
# save result
command.time_completed = timezone.now()
command.save()
# get status
def getStatus(self, camera):
# make sure we are connected to the right camera
camera.last_attempt = timezone.now()
connected = self.connect(camera)
# could we find the camera?
if connected:
# update counters
camera.last_update = camera.last_attempt
self.updateCounters(camera, True)
# try to get the camera's status
status = self.camera.status()
camera.summary = status['summary']
# extend existing status if possible
if camera.status != '':
# allows us to retain knowledge of settings when powered off
try:
old_status = json.loads(camera.status)
if old_status != '':
old_status.update(status)
status = old_status
except ValueError:
logging.info('{}{} - existing status malformed{}'.format(
Fore.YELLOW, 'GoProProxy.getStatus()', Fore.RESET))
# save status to camera
camera.status = json.dumps(status)
# grab snapshot when the camera is powered on
if self.snapshots is True and 'power' in status \
and status['power'] == 'on':
camera.save()
image = self.camera.image()
if image is not False:
camera.image = image
camera.image_last_update = camera.last_attempt
else:
# update counters
self.updateCounters(camera, False)
# update status
camera.summary = 'notfound'
# save result
camera.save()
def updateCounters(self, camera, success):
camera.connection_attempts += 1
if success is not True:
camera.connection_failures += 1
# main loop
def run(self):
logging.info('{}GoProProxy.run(){}'.format(Fore.GREEN, Fore.RESET))
logging.info('Wifi interface: {}, wifi driver: {}'.format(
self.wireless.interface(), self.wireless.driver()))
logging.info('Attempt snapshots: {}'.format(self.snapshots))
# keep running until we land on Mars
# keep the contents of this loop short (limit to one cmd/status or one
# status) so that we can quickly catch KeyboardInterrupt, SystemExit
while 'people' != 'on Mars':
# PRIORITY 1: send command for the current network on if possible
commands = Command.objects.filter(
time_completed__isnull=True,
camera__ssid__exact=self.wireless.current())
if len(commands) > 0:
self.sendCommand(commands[0])
# get the status now because it is cheap
if self.wireless.current() == commands[0].camera.ssid:
self.getStatus(commands[0].camera)
# PRIORITY 2: send the oldest command still in the queue
else:
commands = Command.objects.filter(
time_completed__isnull=True).order_by('-date_added')
if len(commands) > 0:
self.sendCommand(commands[0])
# get the status now because it is cheap
if self.wireless.current() == commands[0].camera.ssid:
self.getStatus(commands[0].camera)
# PRIORITY 3: check status of the most stale camera
else:
cameras = Camera.objects.all().order_by('last_attempt')
if len(cameras) > 0:
self.getStatus(cameras[0])
# protect the cpu in the event that there was nothing to do
time.sleep(0.1)
def __init__(self):
QtGui.QWidget.__init__(self)
##### Camera / Wifi Configuration imports
with open("sony/camera_settings.config") as json_file:
json_data = json.load(json_file)
self.SSID = json_data['ssid']
self.PASSWORD = json_data['password']
#self.MAC_ADDRESS = json_data['mac_address']
self.IP_ADDRESS = json_data['ip_address']
#self.MODEL = json_data['model']
self.wireless = Wireless()
if self.wireless.current() == self.SSID:
self.api = Controller(self.IP_ADDRESS)
self.sonycap = SonyCV(self.IP_ADDRESS)
else:
print "Camera WiFi not connected"
self.fps = 30
self.sdcard_path = None
self.video_path = None
# Creates QPixmap of a black rectangle as video placeholder
# Livestream default size (Sony) = 640 x 360
black_rect = QtGui.QPixmap(640, 360)
black_rect.fill(QtGui.QColor("black"))
##### Widget Definitions / Settings
self.video_frame_left = QtGui.QLabel()
self.video_frame_right = QtGui.QLabel()
self.video_frame_left.setPixmap(black_rect)
self.video_frame_right.setPixmap(black_rect)
self.listwidget = QtGui.QListWidget(self)
self.SDPath_label = QtGui.QLabel(self)
self.SDPath_label.setText("SD Card Path:")
self.SDPathButton = QtGui.QPushButton("Set")
self.SDPathButton.clicked.connect(self.getSDPath)
self.SDPath = QtGui.QLineEdit(self)
self.SDPath.setReadOnly(True)
self.videoPath_label = QtGui.QLabel(self)
self.videoPath_label.setText("Videos Destination:")
self.videoPathButton = QtGui.QPushButton("Set")
self.videoPathButton.clicked.connect(self.getVideoPath)
self.videoPath = QtGui.QLineEdit(self)
self.videoPath.setReadOnly(True)
self.transfer_label = QtGui.QLabel(self)
self.transfer_label.setText("Transfer Videos:")
self.transfer_button = QtGui.QPushButton("Transfer")
self.transfer_button.clicked.connect(self.get_files_from_sdcard)
self.convert_videos_label = QtGui.QLabel(self)
self.convert_videos_label.setText("Convert videos to h.264:")
self.convert_videos_button = QtGui.QPushButton("Convert")
self.convert_videos_button.clicked.connect(self.convert_videos)
self.camera_wifi_label = QtGui.QLabel(self)
self.camera_wifi_label.setText("Camera Wifi:")
self.camera_wifi_connected_label = QtGui.QLabel(self)
self.camera_wifi_connected()
self.controls_label = QtGui.QLabel(self)
self.controls_label.setText("Controls")
self.controls_label.setFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold))
self.controls_label.setAlignment(QtCore.Qt.AlignCenter)
self.settings_label = QtGui.QLabel(self)
self.settings_label.setText("Settings")
self.settings_label.setFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold))
self.settings_label.setAlignment(QtCore.Qt.AlignCenter)
self.transfer_convert_label = QtGui.QLabel(self)
self.transfer_convert_label.setText("Transfer / Convert")
self.transfer_convert_label.setFont(QtGui.QFont("Arial", 14, QtGui.QFont.Bold))
self.transfer_convert_label.setAlignment(QtCore.Qt.AlignCenter)
self.stream_label = QtGui.QLabel(self)
self.stream_label.setText("Live Stream:")
self.stream_button = QtGui.QPushButton('Start')
self.stream_bool = False
#self.connect(self.stream_button, QtCore.SIGNAL("released()"), self.stream_toggle)
self.stream_button.released.connect(self.stream_toggle)
self.stream_light = QtGui.QLabel(self)
self.record_label = QtGui.QLabel(self)
self.record_label.setText("Video Record:")
self.record_button = QtGui.QPushButton('On')
self.record_bool = False
#self.connect(self.stream_button, QtCore.SIGNAL("released()"), self.stream_toggle)
self.record_button.released.connect(self.record_toggle)
self.record_light = QtGui.QLabel(self)
self.beepMode_label = QtGui.QLabel(self)
self.beepMode_label.setText("Beep Mode:")
self.beepMode_checkbox = QtGui.QCheckBox()
self.connect(self.beepMode_checkbox, QtCore.SIGNAL('stateChanged(int)'), self.beep_toggle)
self.flipMode_label = QtGui.QLabel(self)
self.flipMode_label.setText("Video Flip:")
self.flipMode_checkbox = QtGui.QCheckBox()
self.connect(self.flipMode_checkbox, QtCore.SIGNAL('stateChanged(int)'), self.flip_toggle)
self.format_quality_label = QtGui.QLabel(self)
self.format_quality_label.setText("Format / Quality:")
self.format_combobox = QtGui.QComboBox(self)
self.connect(self.format_combobox, QtCore.SIGNAL('activated(int)'), self.quality_handler)
self.quality_combobox = QtGui.QComboBox(self)
self.connect(self.quality_combobox, QtCore.SIGNAL('activated(int)'), self.video_settings_handler)
self.formats = ['XAVC S 4K', 'XAVC S', 'MP4']
XAVC_S_4K_qualities = ['100M 30p', '60M 30p', '100M 24p', '60M 24p']
XAVC_S_qualities = ['50M 60p', '50M 30p', '50M 24p', '100M 120p', '60M 120p', '100M 240p', '60M 240p']
MP4_qualities = ['PS', 'HQ', 'STD', 'HS120', 'HS240']
self.qualities = [XAVC_S_4K_qualities, XAVC_S_qualities, MP4_qualities]
##### Enabled / Disable buttons based on WiFi connection
if self.wireless.current() == self.SSID:
self.stream_button.setEnabled(True)
self.record_button.setEnabled(True)
self.beepMode_checkbox.setEnabled(True)
self.flipMode_checkbox.setEnabled(True)
self.format_combobox.setEnabled(True)
self.quality_combobox.setEnabled(True)
else:
self.stream_button.setEnabled(False)
self.record_button.setEnabled(False)
self.beepMode_checkbox.setEnabled(False)
self.flipMode_checkbox.setEnabled(False)
self.format_combobox.setEnabled(False)
self.quality_combobox.setEnabled(False)
gridLayout = QtGui.QGridLayout()
gridLayout.setSpacing(5)
gridLayout.setContentsMargins(5, 5, 5, 5)
# Top row
gridLayout.addWidget(self.controls_label, 0, 0, 1, 3)
gridLayout.addWidget(self.settings_label, 0, 3, 1, 3)
gridLayout.addWidget(self.transfer_convert_label, 0, 7, 1, 3)
gridLayout.addWidget(self.camera_wifi_label, 0, 11, 1, 1)
gridLayout.addWidget(self.camera_wifi_connected_label, 0, 12, 1, 1)
# Bottom row
gridLayout.addWidget(self.video_frame_left, 5, 0, 1, 6)
gridLayout.addWidget(self.video_frame_right, 5, 7, 1, 6)
# Column 1
gridLayout.addWidget(self.record_label, 1, 0, 1, 1)
gridLayout.addWidget(self.record_button, 1, 1, 1, 1)
gridLayout.addWidget(self.record_light, 1, 2, 1, 1)
gridLayout.addWidget(self.stream_label, 2, 0, 1, 1)
gridLayout.addWidget(self.stream_button, 2, 1, 1, 1)
gridLayout.addWidget(self.stream_light, 2, 2, 1, 1)
# Column 2
gridLayout.addWidget(self.format_quality_label, 2, 3, 1, 1)
gridLayout.addWidget(self.format_combobox, 2, 4, 1, 1)
gridLayout.addWidget(self.quality_combobox, 2, 5, 1, 1)
gridLayout.addWidget(self.beepMode_label, 3, 3, 1, 1)
gridLayout.addWidget(self.beepMode_checkbox, 3, 4, 1, 1)
gridLayout.addWidget(self.flipMode_label, 4, 3, 1, 1)
gridLayout.addWidget(self.flipMode_checkbox, 4, 4, 1, 1)
# Column 3
gridLayout.addWidget(self.SDPath_label, 1, 7, 1, 1)
gridLayout.addWidget(self.SDPathButton, 1, 8, 1, 1)
gridLayout.addWidget(self.SDPath, 1, 9, 1, 1)
gridLayout.addWidget(self.videoPath_label, 2, 7, 1, 1)
gridLayout.addWidget(self.videoPathButton, 2, 8, 1, 1)
gridLayout.addWidget(self.videoPath, 2, 9, 1, 1)
gridLayout.addWidget(self.transfer_label, 3, 7, 1, 1)
gridLayout.addWidget(self.transfer_button, 3, 8, 1, 1)
gridLayout.addWidget(self.convert_videos_label, 4, 7, 1, 1)
gridLayout.addWidget(self.convert_videos_button, 4, 8, 1, 1)
# Column 4
gridLayout.addWidget(self.listwidget, 1, 10, 4, 3)
# (widget_name, row, column, rows spanned, columns spanned)
self.setLayout(gridLayout)
self.setWindowTitle('Control Panel')
self.show()
self.timer = QtCore.QTimer()
self.init_gui_state()
def update_current_connection():
global wifi, current
wifi = Wireless()
current = wifi.current()
import ConfigParser
config = ConfigParser.RawConfigParser()
config.read("/usr/local/mindsensors/conf/msdev.cfg")
homefolder = config.get("msdev", "homefolder")
currentdir = os.path.join(homefolder, "programs")
# Globals
config_file = "/etc/wpa_supplicant/wpa_supplicant.conf" # Config file for Wi-Fi
wifi = None
wlan_inteface = "wlan0"
psm = PiStorms_GRX()
# Check if a wifi adapter is available
try:
wifi = Wireless()
wlan_interface = wifi.interfaces()[0]
except Exception as e:
psm.screen.fillRect(0, 0, 320, 240, fill = (0,0,0), display = False)
psm.screen.drawAutoText("No Wi-Fi adapter", 35, 20, fill = (255,0,0), size = 25, display = False)
psm.screen.drawAutoText("available!", 35, 50, fill = (255,0,0), size = 25, display = False)
psm.screen.drawButton(35, 160, width = 250, height = 40, text="Continue", display=False)
psm.screen.fillRect(0, 0, 1, 1, fill = (0,0,0), display = True)
while True:
cont = psm.screen.checkButton(35, 160, 250, 40)
if cont: sys.exit(0)
current = wifi.current() # Currently connected network
available = Cell.all(wlan_interface) # Available networks
box = TouchScreenInput(psm.screen)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
return socket.inet_ntoa(fcntl.ioctl(
s.fileno(),
0x8915, # SIOCGIFADDR
struct.pack('256s', ifname[:15])
)[20:24])
myLCD = lcd.Jhd1313m1(0, 0x3E, 0x62)
myLCD.setColor(0, 255, 0)
myLCD.setCursor(0, 0)
ip = getIP('wlan0')
wireless = Wireless()
ssid = wireless.current()
myLCD.write(ssid)
myLCD.setCursor(1,0)
myLCD.write(ip)
while True:
if ip != getIP('wlan0'):
myLCD.clear()
myLCD.setCursor(0,0)
ssid = wireless.current()
myLCD.write(ssid)
#Bullet Time!!! 90 degrees GIF
import time
import sys
import requests
import re
import urllib
import os
from wireless import Wireless
#Iniciando la clase para conexion con camaras
wifi = Wireless('wlan0')
#Lista con ssid de camaras
cameras = ['Bullet_5', 'Bullet_6']
#Funcion para descargar las ultimas 10 imagenes de la camara seleccionada
def getImages(cam):
image = urllib.URLopener()
#Variable con la direccion donde se encuentran las fotos
adress = "http://10.5.5.9/videos/DCIM/100GOPRO/"
#Descargando toda la informacion desplegada en el url
r = requests.get(adress)
#Variable con caracteres que forman parte del nombre de las imagenes
expression = r'"(\w+.JPG)"'
from wireless import Wireless
# Enter the password for your gopro and make sure you are connected to the wifi network
PASSWORD = ""
GOPRO_NETWORK = "as-gopro"
UPLOAD_NETWORK = "Nifi"
SLEEP_TIME = 360
MAX_ERRORS = 10
LOCAL_DIR = "/Users/andrew/Pictures/"
CAMERA_ON = "http://10.5.5.9/bacpac/PW?t={}&p=%01"
DELETE_LAST_PHOTO = "http://10.5.5.9/camera/DL?t={}"
CAMERA_PHOTO_MODE_ON = "http://10.5.5.9/camera/CM?t={}&p=%01"
CAMERA_RESOLUTION_MEDIUM = "http://10.5.5.9/camera/PR?t={}&p=%06"
wireless = Wireless()
error_count = 0
def run_command(url):
global error_count
try:
resp = requests.get(url.format(PASSWORD))
if resp.status_code != 200:
print "Error processing command %s. Status code: %s" % (url, resp.status_code)
error_count += 1
if error_count > MAX_ERRORS:
print "Too many errors exiting"
# Raise some kind of alert
return False
from wireless import Wireless
import random
wireless = Wireless()
name = input("enter the name of network(ssid)")
data_1 = [
1, 2, 3, 4, 5, 6, 7, 8, 9, 0, '!', '@', '#', '$', '%', '^', '&', '*', '(',
')', '_', '-', '=', '+', '[', ']', '{', '}', 'a', 'b', 'c', 'd', 'e', 'f',
'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',
'v', 'w', 'x', 'y', 'z'
]
#conn=wireless.connect(ssid=name, password=random.choice(tuple(data_1)))
for i in range(0, 1):
while not True:
data_2 = str(random.randint(0, 10)) + str(random.randint(0, 10)) + str(
random.randint(0, 10)) + str(random.randint(0, 10)) + str(
random.randint(0, 10)) + str(random.randint(0, 10)) + str(
random.randint(0, 10)) + str(random.randint(0, 10))
print(data_2)
while print(wireless.connect(ssid=name, password=data_2)) == True:
pass_ac = random.choice(data_2)
print(pass_ac)
#Hit and trial
"""
while True:
data_2=str(random.randint(0,10)) +str(random.randint(0,10)) +str(random.randint(0,10)) +str(random.randint(0,10)) +str(random.randint(0,10)) +str(random.randint(0,10)) +str(random.randint(0,10)) +str(random.randint(0,10))
print(data_2)
while print(wireless.connect(ssid=name, password=data_2))==True:
def main(args):
parser = argparse.ArgumentParser(
description='Find active users on the current wireless network.')
parser.add_argument('-p', '--packets',
default=1000,
type=int,
help='How many packets to capture.')
parser.add_argument('-i', '--interface',
default=None,
type=str,
help='Which wireless interface to use.')
parser.add_argument('-s', '--ssid',
default=None,
type=str,
help='Which SSID to use.')
parser.add_argument('-r', '--results',
default=None,
type=int,
help='How many results to show.')
args = parser.parse_args()
try:
if args.interface:
iface = args.interface
else:
wireless = Wireless()
ifaces = wireless.interfaces()
eprint('Available interfaces: {}'.format(', '.join(ifaces)))
iface = ifaces[-1]
eprint('Interface: {}'.format(iface))
if args.ssid:
ssid = args.ssid
else:
wireless = Wireless()
ssid = wireless.current()
if ssid is None:
eprint(NO_SSID)
return
eprint('SSID: {}'.format(ssid))
except:
eprint(NO_WIRELESS)
raise
mac_re_str = '([\dA-F]{2}:){5}[\dA-F]{2}'
mac_re = re.compile(mac_re_str, re.I)
network_macs = set()
try:
gws = netifaces.gateways()[netifaces.AF_INET]
gw_ifaces = ', '.join([gw[1] for gw in gws])
eprint('Available gateways: {}'.format(gw_ifaces))
gw_ip = next(gw[0] for gw in gws if gw[1] == iface)
eprint('Gateway IP: {}'.format(gw_ip))
gw_arp = subprocess.check_output(['arp', '-n', str(gw_ip)])
gw_arp = gw_arp.decode('utf-8')
gw_mac = EUI(mac_re.search(gw_arp).group(0))
gw_mac.dialect = mac_unix_expanded
network_macs.add(gw_mac)
eprint('Gateway MAC: {}'.format(gw_mac))
except StopIteration:
eprint('No gateway for {}'.format(iface))
except KeyError:
eprint('No gateways available: {}'.format(netifaces.gateways()))
except:
eprint(NO_GATEWAY_MAC)
bssid_re = re.compile(' BSSID:(\S+) ')
tcpdump_mac_re = re.compile('(SA|DA|BSSID):(' + mac_re_str + ')', re.I)
length_re = re.compile(' length (\d+)')
client_macs = set()
data_totals = defaultdict(int)
cmd = 'tcpdump -i {} -Ile -c {} -s 0'.format(iface, args.packets).split()
try:
bar_format = '{n_fmt}/{total_fmt} {bar} {remaining}'
progress = tqdm(run_process(cmd),
total=args.packets,
bar_format=bar_format)
for line in progress:
line = line.decode('utf-8')
# find BSSID for SSID
if ssid in line:
bssid_matches = bssid_re.search(line)
if bssid_matches:
bssid = bssid_matches.group(1)
if 'Broadcast' not in bssid:
network_macs.add(EUI(bssid))
# count data packets
length_match = length_re.search(line)
if length_match:
length = int(length_match.group(1))
mac_matches = tcpdump_mac_re.findall(line)
if mac_matches:
macs = set([EUI(match[1]) for match in mac_matches])
leftover = macs - network_macs
if len(leftover) < len(macs):
for mac in leftover:
data_totals[mac] += length
client_macs.add(mac)
if progress.n < progress.total:
eprint('Sniffing finished early.')
except subprocess.CalledProcessError:
eprint('Error collecting packets.')
raise
except KeyboardInterrupt:
pass
totals_sorted = sorted(data_totals.items(),
key=lambda x: x[1],
reverse=True)
eprint('Total of {} user(s)'.format(len(totals_sorted)))
for mac, total in reversed(totals_sorted[:args.results]):
mac.dialect = mac_unix_expanded
if total > 0:
print('{}\t{} bytes'.format(mac, total))
from wireless import Wireless wireless = Wireless() print(wireless.current()) # python3 -m pip install wireless #only MAC
if (internet_off()):
os.system("echo \"$(date '+%Y/%M/%D %H:%M:%S')-> Red: Iniciando daemon bluetooth\" >> /home/pi/Desktop/log.txt")
os.system("sudo python /home/pi/Desktop/obibaby/src/server-bluetooth.py & disown")
if (internet_off()):
file = open('/home/pi/Desktop/networks.txt', 'r')
text = file.read()
list = text.split('\n')
for item in list:
try:
os.system("echo \"$(date '+%Y/%M/%D %H:%M:%S')-> Red: "+item+"\" >> /home/pi/Desktop/log.txt")
print item
os.system("echo \"$(date '+%Y/%M/%D %H:%M:%S')-> Antes del wireless\" >> /home/pi/Desktop/log.txt")
wireless = Wireless()
bssid,psk = item.split(",")
print("ssid: "+bssid+ " pass: "******"echo \"$(date '+%Y/%M/%D %H:%M:%S')-> Red: Intento\" >> /home/pi/Desktop/log.txt")
if (internet_on()):
print("Conected")
os.system("echo \"$(date '+%Y/%M/%D %H:%M:%S')-> Red: Conectado\" >> /home/pi/Desktop/log.txt")
os.system("echo '' >> /home/pi/Desktop/log.txt")
break
os.system("echo \"$(date '+%Y/%M/%D %H:%M:%S')-> Red: No conectado\" >> /home/pi/Desktop/log.txt")
os.system("echo '' >> /home/pi/Desktop/log.txt")
except:
print "Not connected or invalid input, mi cuate"
continue
def is_connected_to_network():
"""Check to see if connected to WeyeFeye network with name like 'WeyeFeyeb17d8a'"""
w = Wireless()
network_name = w.current()
connected = bool(network_name and "WeyeFeye" in network_name)
return connected
def __init__(self, ssid, password):
self.ssid = ssid
self.password = password
self.wireless = Wireless()
self.system = platform.system()
self.status = "Off"
print "Apagar"
return
# Hacemos las asignaciones de los pines fisicos
pin_rele = 25
# Establecemos el valor del TOKEN facilitado por The BotFather
TOKEN = "289317488:AAEpHlZCmDrndtD_zxbFp1YVkQXuDgZ9zFc"
# Creamos una instancia tipo rele para el enchufe
plug = rele(pin_rele)
# Creamos objeto para manejar estado de la conexion
wifi = Wireless()
# Creamos conexion con bot de telegram
bot = telebot.TeleBot(TOKEN)
# Definimos identificadores de usuarios
cesar_id = 9519882
# Definimos funcion para comprobar la identidad de los usuarios
def check_security(message):
print message.chat.username
print message.from_user.id
print message.chat.id
if message.chat.type == "group":
return True
def __init__(self):
self.network = Wireless()
self.networkLock = threading.Lock()
self.defaultNetwork = config.getDefaultNetwork()
