def __init__(self, master=None):
tk.Frame.__init__(self, master)
self.path = os.path.split(sys.argv[0])[0]
self.data_dir = os.path.join(self.path, DATADIR)
self.cfg = config.Load(os.path.join(self.data_dir, CONFIG))
self.grid(sticky=tk.NSEW)
self.idle_calls = 0
self.charts = []
self.focus_chart = None
self.q = multiprocessing.Queue(maxsize=QUEUE_SIZE)
self.status_q = multiprocessing.Queue(0)
self.next_color = 0
self.running = 1
self.proc = None
self.state = App.SETUP
self.parent_conn, self.child_conn = multiprocessing.Pipe()
self.man_span = 0
self.scaling = config.ScaleInfo()
self.spans = [0] * SPAN_MAX # map range slider to range value
self.time_diff = time.time() - utils.timer() # see module docstring
top = self.winfo_toplevel()
top.geometry(self.cfg.geometry)
try:
top.wm_iconbitmap('electroscope.ico')
except:
pass
top.rowconfigure(0, weight=1)
top.columnconfigure(0, weight=1)
self.scale_min = (SAMPLESCALE_MIN, 0, FREQSCALE_MIN)
self.scale_max = (SAMPLESCALE_MAX, 0, FREQSCALE_MAX)
self.plot_sizes = [SAMPLESCALE_MAX, 0, FREQSCALE_MAX]
# the layout is 3 rows:
self.rowconfigure(0, weight=1)
self.rowconfigure(1, weight=1000)
self.rowconfigure(2, weight=1)
# row 1 is constructed as 2 columns, with all the expansion
# assigned to the graphs
self.columnconfigure(0, weight=1000)
self.columnconfigure(1, weight=1)
# construct the widgets - note that these member functions know where
# they belong in the grid, so they are sensitive to grid layout changes
self.create_menu(self)
self.create_controls(self)
self.create_graphs(self)
self.create_button_row(self)
# connect event handlers
top.protocol("WM_DELETE_WINDOW", self.on_quit)
pubsub.subscribe('status', self.set_status)
pubsub.subscribe('focus2', self.on_focus)
# start a process to receive and buffer data
self.start_source(self.cfg.sources)
self.on_timer()
# start the code that processes and displays the data
self.after_idle(self.on_plot_type)
self.after_idle(self.read_queue)
def __init__(self, Loader_Log):
# Try to load the network config file
# if we cant start the cli
try:
with open('/conf/network.json', 'r') as f:
Network_Config = ujson.load(f)
# start the cli on Error
except:
print("Starting Dobby Loader - Version: " + str(Version))
print("Missing network config starting CLI")
# start the cli, it will trigger a reboot after getting a wifi config
# self.CLI()
import cli
cli.Run(self)
# Default log level = 1 aka Info
self.Log_Level = 1
# Log queue to hold logs untill we can pass it on to base
self.Log_Queue = Loader_Log
# Log relies on this to check if we need to blink on errors
# So needs to be set before log is used the first time
self.Indicator = None
# Create self.wlan0 reference
self.wlan0 = network.WLAN(network.STA_IF)
# Activate self.wlan0 regardless if it is no not
self.wlan0.active(True)
# System header added in front of log messages
self.System_Header = "/Unconfigured"
# Var to hold stat of MQTT Connection
self.MQTT_State = 'init'
# Used to download modules aka mqtt broker
self.Server = Network_Config["MQTT Broker"]
self.Hostname = Network_Config["Hostname"]
# Log start of script
self.Log(1, "System", "Starting Dobby Base - Version: " + str(Version))
# Create MQTT Object
import umqttsimple as MQTT
self.MQTT = MQTT
# Import config
import config as dConfig
# Load device config
Device_Config = dConfig.Load('device')
# Change log level if set in config
self.Log_Level = Device_Config.get('Log Level', 1)
# Change system header
self.System_Header = Device_Config['System Header']
## Holds all loaded modules
self.Modules = {}
# Holds loaded System Modules like WirePusher if enabeled
self.Sys_Modules = {}
# List of push messages that failed to send
# we retry when online again
self.Push_Queue = []
# Change CPU frequancy if requested
# if Config.get('CPU_16', False) == True:
# machine.freq(160000000)
# self.Log(1, 'System', 'CPU frequancy set to: 16MHz')
# MQTT Connection status
self.MQTT_State = 'init'
self.MQTT_Reconnect_At = 0
self.MQTT_Subscribe_To = []
self.MQTT_Client = None
self.MQTT_Ping_At = utime.ticks_ms()
# Subscribe to Commands topic
self.MQTT_Subscribe(self.Peripherals_Topic("Commands"))
# Var to indicate of we have published the ip we got when wifi connected
self.Published_Boot = False
# ++++++++++++++++++++++++++++++++++++++++ MQTT ++++++++++++++++++++++++++++++++++++++++
# Remember to add something raondom after the hostname so the borker see a new connecton
# Check if we got a user and pass for mqtt
# Generate Unique Post Hostname
Post_Hostname = str(uos.urandom(1)[0] % 1000)
# Log event
self.Log(0, 'MQTT',
'Using hostname: ' + self.Hostname + "-" + Post_Hostname)
# Stores messages so we can act on them in MQTT Loop
## List containing Topic and payload
## [[<Topic>, <Payload>]]
self.MQTT_Incomming_Queue = []
# Create MQTT Client
self.MQTT_Client = self.MQTT.MQTTClient(
self.Hostname + "-" + Post_Hostname, self.Server,
int(Device_Config.get('MQTT Port', 1883)),
Device_Config.get('MQTT Username', None),
Device_Config.get('MQTT Password', None))
# Set last will
self.MQTT_Client.set_last_will(
self.System_Header + "/" + self.Hostname + "/Log/Will",
"Disconnected")
# try to connect to mqtt
self.MQTT_Connect()
# Device_Config is no loger needed so will delete it to free up space
del Device_Config
# ++++++++++++++++++++++++++++++++++++++++ Setup peripherals ++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++ Setup peripherals ++++++++++++++++++++++++++++++++++++++++
# ++++++++++++++++++++++++++++++++++++++++ Setup peripherals ++++++++++++++++++++++++++++++++++++++++
# Variable for Pin Monitor
# Remember to pass base aka self
import pinmonitor
self.Pin_Monitor = pinmonitor.Init(self)
# Loop over config names in /conf and import matching modules
## Get config names
Config_List = uos.listdir('/conf')
# Remove device.json since we dont want to use that again
Config_List.remove('device.json')
Config_List.remove('network.json')
## Loop over names in config
for Name in Config_List:
# Strip .json from name
Name = Name.replace('.json', '')
# DHT has to be in capital or else it will try to load the micropython module called dht
if Name == 'dht':
Name = 'DHT'
# Import the config
Config = dConfig.Load(Name)
Error = None
# Load config is False if no config is found
if Config is not False:
try:
# Try to import
Module = __import__(Name)
# Store objevt in self.Modules
# Pass config and get perifical object
# Remember to pass Shared aka self so we can log in Button and use dobby variables
self.Modules[Name] = Module.Init(self, Config)
except (AttributeError, TypeError, SyntaxError, KeyError) as e:
Error = str(e)
# Incompatible mpy file
# except ValueError:
# # remove module
# uos.remove('/lib/dobby/' + Name.replace('.json', '.mpy'))
# # Log event
# Error = "Removed Module: " + Name.replace('.json', '') + " due to incompatibility"
except MemoryError:
Error = 'Not enough free memory. Free memory: ' + str(
gc.mem_free())
except self.Error as e:
Error = str(e)
# No errors on import in creation of module object
else:
# Log event
self.Log(0, "System", "Module loaded: " + str(Name))
finally:
# Check if Module import ok
if Error != None:
# remove module from self.Modules if added
try:
del self.Modules[Name.replace('.json', '')]
except:
pass
# Dont remove config on "Missing module" we are trying to download it when we get wlan0 up
if Error.startswith("Missing module: ") != True:
# Log event
self.Log(
4, "System", "Unable to load module: " +
str(Name) + " - Error: " + Error)
# Remove config file
uos.remove("/conf/" + Name + '.json')
# Remove config file
uos.remove("/lib/" + Name + '.mpy')
# Log removal of config file
self.Log(
1, "System",
"Removed config file and module for: " + Name)
else:
self.Log(0, 'System', "Invalid config: " + Name)
# Activate indicator if 'LED' owned by Indicator aka not used for something else
# on esp32 its IO2
# on esp8266 its D4
if self.Pin_Monitor.Get_Owner(self.Pin_Monitor.LED) == 'Indicator':
# check if indicator is already imported and init
if self.Sys_Modules.get('indicator', None) == None:
# Import Indicator
import indicator
# Init Indicator and store in Sys_Modules to enable loop
self.Sys_Modules['indicator'] = indicator.Init(
self, {"System": {
"Pin": "LED"
}})
# Create the indicator object
self.Indicator = self.Sys_Modules['indicator'].Peripherals[
"System"]
# indicator already imported to add an object in stead
else:
# Create the indicator object
self.Indicator = self.Sys_Modules['indicator'].Add(
"System", {"Pin": "LED"})
# On add the indicator will be blinked 3 times
# will use this as boot blink
# add wifi infication if disconnected
if self.wlan0.isconnected() == False:
self.Indicator.Add("WiFi", 4, "0.5s", "0.75s", True)
else:
# Log we could not enable indicator led
self.Log(0, 'System/Indicator',
"LED Pin in use, cannot enable system indicator")
# Remove dconfig again since we are done with it
del dConfig
# Boot done message
self.Log(
0, 'System', 'Dobby - Initialization compleate - Free memory: ' +
str(gc.mem_free()))
import os
import requests
import telegram
import time
import config
from telegram import Update, Message
from telegram.ext import Updater
from telegram.ext import CommandHandler
import random
import templates
config.Load()
TELEGRAM_TOKEN: str = config.data['telegram']['token']
TELEGRAM_USERS: dict = config.data['telegram']['users']
def add_new_user(id, name, status='user'):
TELEGRAM_USERS[str(id)] = {
'id': id,
'name': name,
'status': status,
'mute': False
}
config.Save()
def get_user(uid):
if isinstance(uid, Update):
uid = uid.message.from_user.id
uid = str(uid)
def __init__(self, Dobby):
# Dict to hold config
Config = {}
# Try to load network.json to 'Config'
# if failes create an empthy dict
try:
# Try to load config
Config = dConfig.Load('network')
except:
# Create empthy dict on failure
Config = {}
# print cli init message
print("Starting cli")
print("Please configure:")
print(" Hostname")
print(" WiFi SSID")
print(" WiFi Password")
print(" MQTT Broker")
print("")
# start eternal loop while getting user
while True:
try:
User_Entry = input("Dobby CLI: ")
except (EOFError, KeyboardInterrupt):
# If we got interrupted exit
print(" Leaving CLI")
sys.exit()
# Check if the 200 pound gorilla pressed enter without entering a command
if User_Entry == "":
continue
# ---------------------------------------- Help ----------------------------------------
elif User_Entry.lower() == "help":
print()
print("Avalible commands:")
print()
print(" boot - boot the device")
print(" json - past device config as a json string")
print(" show - shows the loaded config")
print(" module list - lists all installed modules")
print(" module delete - delete a installed module")
print(
" set <config> <to> - sets 'Hostname', 'WiFi SSID', 'WiFi Password', 'MQTT Broker'"
)
print()
# ---------------------------------------- boot ----------------------------------------
# reboots the device
# if required settings is give
# saves config to fs first
elif User_Entry.lower() == "boot":
# check if config is ok
try:
dConfig.Check(Config, [
'Hostname', 'WiFi SSID', 'WiFi Password', 'MQTT Broker'
])
except Dobby.Error as e:
print(" Missing config: " + str(e))
continue
# save config to file
if dConfig.Save(Config, 'network') == False:
print(" Unable to save config")
continue
# Log event
print(" Config saved rebooting")
# Reboot the device
machine.reset()
# ---------------------------------------- set ----------------------------------------
# prints the current config
elif User_Entry.lower() == "set":
# List of options user can change
Config_Options = [
'Hostname', 'WiFi SSID', 'WiFi Password', 'MQTT Broker',
'Log Level'
]
# print list with number in front
for i in range(len(Config_Options)):
print(" " + str(i) + " - " + str(Config_Options[i]))
# Get config option number from user
try:
print()
print("Press CTRL + C to cancle")
print()
Selected_Option = input("Please select config to change: ")
# Convert selection to int
Selected_Option = int(Selected_Option)
# check config exists in list
Config_Options[Selected_Option]
except (EOFError, KeyboardInterrupt):
print(" canceled")
except (ValueError, IndexError):
print(" invalid config selected: " +
str(Selected_Option))
else:
# Get config option number from user
try:
print()
New_Value = input("Please enter new value for " +
Config_Options[Selected_Option] +
": ")
except (EOFError, KeyboardInterrupt):
print(" canceled")
else:
# change config value
Config[Config_Options[Selected_Option]] = New_Value
# Log event
print(" Config: " +
str(Config_Options[Selected_Option]) +
" set to: " + str(New_Value))
# ---------------------------------------- show ----------------------------------------
# prints the current config
elif User_Entry.lower() == "show":
print("Current config:")
for Key in [
'Hostname', 'WiFi SSID', 'WiFi Password',
'MQTT Broker', 'Log Level'
]:
print(" " + Key + ": " +
Config.get(Key, "Not configured"))
# ---------------------------------------- json ----------------------------------------
# past device config as a json string
elif User_Entry.lower() == "json":
# Get json string from user
json_Config = input("Please paste device config json string: ")
# Try to parse json
try:
# parse json to config dict
json_Config = ujson.loads(json_Config)
# Error in json string
except ValueError:
print()
print(" Invalid json string")
print()
continue
# Json loaded ok, check if we got the needed config
else:
Check_List = [
'Hostname', 'WiFi SSID', 'WiFi Password', 'MQTT Broker'
]
try:
dConfig.Check(json_Config, Check_List)
except Dobby.Error as e:
# Log error
print(" Missing config entries: " + str(e))
continue
# if we got a large config for some reason only take what we need aka keys in the check list
for Key in Check_List:
# Save value from json_Config in Config var
Config[Key] = json_Config[Key]
# Log Event
print(" json config ok")
continue
# ---------------------------------------- module list ----------------------------------------
# lists all modules
elif User_Entry.lower() == "module list":
# print to give distance to above
print()
# get list of libs
Lib_List = uos.listdir('lib')
# print list with number in front
for i in range(len(Lib_List)):
print(" " + str(i) + " - " + str(Lib_List[i]))
# Print to give space to command below
print()
# ---------------------------------------- module delete ----------------------------------------
# lists all modules with number in front and lets the user deside what to delete
# ctrl + c to cancle
elif User_Entry.lower() == "module delete":
# print to give distance to above
print()
# get list of libs
Lib_List = uos.listdir('lib')
# print list with number in front
for i in range(len(Lib_List)):
print(" " + str(i) + " - " + str(Lib_List[i]))
# Get user input
try:
print()
print("Press CTRL + C to cancle")
print()
User_Entry = input("Select module to delete: ")
except (EOFError, KeyboardInterrupt):
print(" canceled")
else:
try:
# delete selected lib aka module
uos.remove('lib/' + Lib_List[int(User_Entry)])
except TypeError:
print(" invalid module selected: " + User_Entry)
else:
print(" deleted module: " +
Lib_List[int(User_Entry)])
# ---------------------------------------- Unknown command ----------------------------------------
else:
print("unknown command: " + User_Entry)
sys.path.insert(0, 'preprocess/')
sys.path.insert(0, 'models/')
sys.path.insert(0, 'layers/')
from sklearn.metrics import log_loss, classification_report
import Generate_train_test2
import config
from caffenet import CaffeNet
from keras.applications.imagenet_utils import decode_predictions
import numpy as np
from load_cifar10 import load_cifar10_data
if __name__ == '__main__':
finetune = True
img_rows, img_cols = 227, 227 # Resolution of inputs
channel = 3
batch_size, nb_epoch, num_classes, save_weights = config.Load()
# Load Cifar10 data. Please implement your own load_data() module for your own dataset
X_train, Y_train, X_valid, Y_valid = load_cifar10_data(img_rows, img_cols)
model = CaffeNet(weights='caffenet_weights_th.h5', classes=num_classes)
# Start Fine-tuning
if finetune:
model.fit(
X_train,
Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
shuffle=True,
verbose=1,
validation_data=(X_valid, Y_valid),