def _test_get_config(farmware, config, type_, expected): def _get_state(): return { 'process_info': { 'farmwares': { 'Farmware Name': { 'config': [{ 'name': 'twenty', 'value': 20 }] } } } } if type_ is None: received = get_config_value(farmware, config, _get_state=_get_state) else: received = get_config_value(farmware, config, type_, _get_state=_get_state) assert received == expected, 'expected {}, received {}'.format( repr(expected), repr(received)) print('get_config_value result {} == {}'.format(repr(received), repr(expected)))
def load_config(self): #ASSUMPTIONS - CHANGE HERE TO ADJUST TO YOUR CASE self.ml_per_sec = 80.0 #my pump produces 80ml/sec self.coming_of_age = 7 * 15 #I believe that in 15 weeks plant becomes an adult (i.e. takes the full height and spread) self.magic_d2lm = 3 #Magic mutiplier to convert plant size to ml needed for watering self.small_rain = 1 #1mm is a small rain (cancells watering today) self.medium_rain = 10 #10mm is a medium rain (cancells watering today and tomorrow) self.big_rain = 20 #20mm is a big rain (cancells watering today, tomorrow and day after tomorrow) # super(MLH,self).load_config() # self.get_arg('action' , "test", str) # self.get_arg('pointname' , '*', str) # self.get_arg('default_z' , 0, int) # self.get_arg('filter_meta' , None, list) # self.get_arg('save_meta' , None,list) # self.get_arg('init' , None, str) # self.get_arg('before' , None, str) # self.get_arg('after' , 'Water [MLH]', str) # self.get_arg('end' , None, str) self.farmware_name = 'MLH' self.args[action] = get_config_value(self.farmware_name, config_name='action', value_type=str) self.args[pointname] = get_config_value(self.farmware_name, config_name='pointname', value_type=str) self.args[default_z] = get_config_value(self.farmware_name, config_name='default_z', value_type=int) self.args[filter_meta] = get_config_value(self.farmware_name, config_name='filter_meta', value_type=list) self.args[save_meta] = get_config_value(self.farmware_name, config_name='save_meta', value_type=list) self.args[init] = get_config_value(self.farmware_name, config_name='init', value_type=str) self.args[before] = get_config_value(self.farmware_name, config_name='before', value_type=str) self.args[after] = get_config_value(self.farmware_name, config_name='after', value_type=str) self.args[end] = get_config_value(self.farmware_name, config_name='end', value_type=str) self.args['pointname'] = self.args['pointname'].lower().split(',') self.args['pointname'] = [x.strip(' ') for x in self.args['pointname']] self.log(str(self.args))
def integer(PKG, input_name): data = get_config_value(PKG, input_name, int) try: data = int(data) except: errors.append('Must be integer for input: {}.'.format(input_name)) else: return data
def load_config(self): super(GridRunnerWare, self).load_config() self.args['action'] = get_config_value(farmware_name=self.app_name, config_name='action', value_type=str) self.args['sequence'] = get_config_value(farmware_name=self.app_name, config_name='sequence', value_type=str) self.args['default_z'] = get_config_value(farmware_name=self.app_name, config_name='default_z', value_type=int) self.args['mincorner'] = ast.literal_eval( get_config_value(farmware_name=self.app_name, config_name='mincorner', value_type=str)) self.args['maxcorner'] = ast.literal_eval( get_config_value(farmware_name=self.app_name, config_name='maxcorner', value_type=str)) self.args['stepsize'] = ast.literal_eval( get_config_value(farmware_name=self.app_name, config_name='stepsize', value_type=str)) self.log(str(self.args))
def sequence(PKG, input_name): seq_name = get_config_value(PKG, input_name, str) if ''.join(seq_name.split()).lower() == 'none': errors.append( 'Encountered "None" for required sequence {}" '.format(input_name)) return False elif len(''.join(seq_name.split())) > 0: try: sequence_id = app.find_sequence_by_name(name=seq_name) return sequence_id except: input_errors.append( 'Failed to find sequence ID for {}'.format(seq_name)) return None
def combo(PKG, input_name): string = get_config_value(PKG, input_name, str) string = ''.join(string.split(' ')).lower() if string == 'none': errors.append( 'Encountered "None" for required sequence {}" '.format(input_name)) return None elif ',' not in string: errors.append( 'Combo field does not contain a comma: {}'.format(input_name)) return None else: split = string.split(',') if split[0] not in 'xy': errors.append( 'Left side of comma must be "X" or "Y". Found: {}'.format( split[0])) try: split[1] = int(split[1]) except: errors.append( 'Right side of comma should be an Integer. Found: {}'.format( split[1])) return {'axis': split[0], 'value': split[1]}
our safe position by going at slow speed until it's activated on all sides and then we have our, starting position = safe position. ''' start_arm_x = device.get_current_position('x') start_arm_y = device.get_current_position('y') start_arm_z = device.get_current_position('z') safeZ = -200 ''' values for opencv pos_x = 1013 pos_y = 24 pos_z = -400 ''' legacy = get_config_value('Seeding Path', 'Legacy Seeder')#User inputs 0 for false and 1 for true. # Load inputs from Farmware page widget specified in manifest file pos_x = get_config_value('Seeding Path', 'start_x')#Starting X position of Pathway pos_y = get_config_value('Seeding Path', 'start_y')#Starting Y position of Pathway pos_z = get_config_value('Seeding Path', 'start_z') plantLength = get_config_value('Seeding Path', 'Plant-to-Plant Delta X\nFor current waffer use 40mm') #Distance between one center of a plant to another X dimention plantWidth = get_config_value('Seeding Path', 'Plant-to-Plant Delta Y\nFor current waffer use 30mm') #Distance between one center of a plant to another Y dimention #currently a scaler, make it a list later, the next two inputs plantCountLong = get_config_value('Seeding Path', '# of Plants Long') #How many plants are in a column plantCountWide = get_config_value('Seeding Path', '# of Plants Wide') #How many plans are in a row seedToolX = 1330 seedTrayX = 1330#measure for actual value seedToolY = 136 seedTrayY = 136#measure for actual value seedToolZ = -325
#!/usr/bin/env python '''Farmware: execute a set_pin_io_mode command.''' from farmware_tools import get_config_value, device farmware_name = 'Set pin IO mode-kuruwan' pin_number = get_config_value(farmware_name, config_name='pin_number') pin_io_mode = get_config_value(farmware_name, config_name='pin_io_mode') device.set_pin_io_mode(pin_io_mode, pin_number)
# 2. To work out Z axis height i.e the opposite: hypotenuse = current X pos - beginining of X then opposite = sin(angle) * hypotenuse # 3. Then add that height (the opposite) to the startZGrid value # Remember if using alternate inbetween last row is missed so: # Normal grid: 3 rows x 2 columns = 6 cells # Alternate in between grid: 2 rows x 4 columns = 6 cells as last rows 2 of alternate inbetween columns missed # Not tested turning alternate inbetween on both grids at the same time # A better way would be to initialise 2 arrays with x,y coordinates and loop through them but this algo works # Future considerations: # Load two arrays of coordinates first and then loop through them note one grid could be diamond pattern one could be normal grid # Think if using alternate inbetween then instead of x count = 11, x count = the number of actual x positions i.e. x count = 21 # then on any column tell it when to use the odd or even numbered x positions #try : xAxisCount = get_config_value(farmware_name='Grid2Grid20Min', config_name='xAxisCount', value_type=int) yAxisCount = get_config_value(farmware_name='Grid2Grid20Min', config_name='yAxisCount', value_type=int) spaceBetweenXGrid1 = get_config_value(farmware_name='Grid2Grid20Min', config_name='spaceBetweenXGrid1', value_type=float) spaceBetweenYGrid1 = get_config_value(farmware_name='Grid2Grid20Min', config_name='spaceBetweenYGrid1', value_type=float) startXGrid1 = get_config_value(farmware_name='Grid2Grid20Min', config_name='startXGrid1', value_type=float) startYGrid1 = get_config_value(farmware_name='Grid2Grid20Min', config_name='startYGrid1', value_type=float) startOfXSlopeGrid1 = get_config_value(farmware_name='Grid2Grid20Min', config_name='startOfXSlopeGrid1', value_type=float) sineOfAngleXGrid1 = get_config_value(farmware_name='Grid2Grid20Min', config_name='sineOfAngleXGrid1', value_type=float) alternateInBetweenGrid1 = get_config_value(farmware_name='Grid2Grid20Min', config_name='alternateInBetweenGrid1', value_type=int) sequenceAfter1stGridMove = get_config_value(farmware_name='Grid2Grid20Min', config_name='sequenceAfter1stGridMove', value_type=str) spaceBetweenXGrid2 = get_config_value(farmware_name='Grid2Grid20Min', config_name='spaceBetweenXGrid2', value_type=float) spaceBetweenYGrid2 = get_config_value(farmware_name='Grid2Grid20Min', config_name='spaceBetweenYGrid2', value_type=float) startXGrid2 = get_config_value(farmware_name='Grid2Grid20Min', config_name='startXGrid2', value_type=float) startYGrid2 = get_config_value(farmware_name='Grid2Grid20Min', config_name='startYGrid2', value_type=float)
[190, 267], [190, 305], [190, 343], [190, 381], [190, 419], [190, 457], [222, 0], [222, 38], [222, 76], [222, 114], [222, 152], [222, 190], [222, 229], [222, 267], [222, 305], [222, 343], [222, 381], [222, 419], [222, 457]] seedToolX = 1330 seedToolY = 136 seedToolZ = -325 toolExtractX = 1240 toolExtractZ = -250 seedTrayX = 1340 seedTrayY = 0 seedTrayDepth = -290 pos_x = get_config_value('Legacy Seeding Path', 'start_x') pos_y = get_config_value('Legacy Seeding Path', 'start_y') pos_z = get_config_value('Legacy Seeding Path', 'start_z') #Pick up seeding tool moveAbs(seedToolX, seedToolY, safeZ) moveAbs(seedToolX, seedToolY, seedToolZ) moveAbs(toolExtractX, seedToolY, seedToolZ) moveAbs(toolExtractX, seedToolY, toolExtractZ) for i in range(len(plantLocation)): #Get current location of arm current_arm_x = device.get_current_position('x') current_arm_y = device.get_current_position('y') current_arm_z = device.get_current_position('z') #Move to seed tray
from DB import DB from Image import Image import json from Parameters import Parameters import requests import cv2 from Capture import Capture import numpy as np from PlantDetection import PlantDetection from farmware_tools import device from farmware_tools import get_config_value import CeleryPy import time farmware_name ='Seedling transfering' origin_tray = get_config_value(farmware_name, config_name='Origin_tray') destiny_tray = get_config_value(farmware_name, config_name='Destiny_tray') weeder = (20, 553, -402) dir_path = os.path.dirname(os.path.realpath(__file__)) if origin_tray>0 and origin_tray<=4 and destiny_tray>0 and destiny_tray<=4 and origin_tray!=destiny_tray: matrix = np.load(dir_path + '/' + 'array'+str(origin_tray)+'.npy') matrix2 = np.load(dir_path + '/' + 'array'+str(destiny_tray)+'.npy') CeleryPy.move_absolute(weeder, (0, 0, 0), 150) CeleryPy.move_absolute(weeder, (100, 0, 0), 150) CeleryPy.move_absolute(weeder, (100, 0, 100), 150) CeleryPy.move_absolute(weeder, (100, 0, 200), 150) CeleryPy.write_pin(number=4, value=1, mode=0) CeleryPy.wait(100) CeleryPy.write_pin(number=4, value=0, mode=0) CeleryPy.wait(200)
#!/usr/bin/env python ''' ' Random Move Relative ''' import os from farmware_tools import device from farmware_tools import app from farmware_tools import get_config_value from random import randint # coordinate dict coord = {'x': 0, 'y': 0, 'z': 0} # loop over axes andd apply a random offset for axis in coord: lo = int(get_config_value('Random Move Relative', (axis + '_lo'))) hi = int(get_config_value('Random Move Relative', (axis + '_hi'))) pos = randint(lo, hi) pos *= -1 if randint(0, 1) else 1 coord[axis] = pos log = "Moving relative: {}".format(coord) device.log(log, 'info', ['toast']) # perform the move device.move_relative(coord['x'], coord['y'], coord['z'], 100)
#!/usr/bin/env python """Move Rectangle Farmware""" #Import libraries from farmware_tools import device from farmware_tools import get_config_value # Load inputs from Farmware page widget specified in manifest file pos_x = get_config_value('Move Rectangle', 'start_x') pos_y = get_config_value('Move Rectangle', 'start_y') pos_z = get_config_value('Move Rectangle', 'start_z') rectLength = get_config_value('Move Rectangle', 'length') rectWidth = get_config_value('Move Rectangle', 'width') #Define functions def moveAbs(x, y, z): device.log('Moving to ' + str(x) + ', ' + str(y) + ', ' + str(z), 'success', ['toast']) device.move_absolute( { 'kind': 'coordinate', 'args': {'x': x, 'y': y, 'z': z} }, 100, { 'kind': 'coordinate', 'args': {'x': 0, 'y': 0, 'z': 0} } ) #Arm Path # B * * * * * * * C # * *
#!/usr/bin/env python """Move Rectangle Farmware""" #Import libraries from farmware_tools import device, get_config_value, app #Find arm position at start of program start_arm_x = device.get_current_position('x') start_arm_y = device.get_current_position('y') start_arm_z = device.get_current_position('z') #Load inputs from Farmware page widget specified in manifest file. X axis is length, Y axis is width. pos_x = get_config_value('Seeding Path', 'start_x') pos_y = get_config_value('Seeding Path', 'start_y') pos_z = get_config_value('Seeding Path', 'start_z') plantLength = get_config_value('Seeding Path', 'plant_l') plantWidth = get_config_value('Seeding Path', 'plant_w') cellCountX = get_config_value('Seeding Path', 'cellX') cellCountY = get_config_value('Seeding Path', 'cellY') #Define additional varialbes safeZ = -200 plantingRetract = 5 seedToolX = 1330 seedToolY = 136 seedToolZ = -325 toolExtractX = 1240 plant_x = 0 plant_y = 0 #Define functions
#!/usr/bin/env python ''' ' Single Axis ''' import os from farmware_tools import device from farmware_tools import app from farmware_tools import get_config_value # create Celery coordinate node coord = device.assemble_coordinate(0, 0, 0) # apply currrent positions to coordinate node for axis in coord['args']: coord['args'][axis] = device.get_current_position(axis) # get the desired axis to modify and set the coordinate node to the desired value single_axis = get_config_value('Single Axis', 'axis', str).lower() coord['args'][single_axis] = int(get_config_value('Single Axis', 'pos')) #log = 'Axis: {}, Coordinate: {}'.format(single_axis, coord) log = "Moving '%s' axis to %d" % (single_axis.upper(), coord['args'][single_axis]) device.log(log, 'info', ['toast']) # perform the move device.move_absolute(coord, 100, device.assemble_coordinate(0, 0, 0))
#!/usr/bin/env python '''Farmware: switch between USB and Raspberry Pi cameras.''' import os import json from farmware_tools import device from farmware_tools import get_config_value switch_camera_to = get_config_value(farmware_name='Switch Camera', config_name='camera_setter', value_type=str) switch_camera_to = switch_camera_to.strip() switch_camera_to = switch_camera_to.upper() if switch_camera_to not in ("RPI", "USB"): message = "Wrong input to switch camera provided: " + switch_camera_to + ". Values USB or RPI shd be used" device.log(message, message_type='info') else: camera = os.getenv('camera', 'USB') device.set_user_env('camera', json.dumps(switch_camera_to)) message = "Camera was switched to " + switch_camera_to device.log(message, message_type='success')
def usb_camera_photo(): 'Take a photo using a USB camera.' # Settings camera_port = 0 # default USB camera port discard_frames = 20 # number of frames to discard for auto-adjust # Check for camera if not os.path.exists('/dev/video' + str(camera_port)): print("No camera detected at video{}.".format(camera_port)) camera_port += 1 print("Trying video{}...".format(camera_port)) if not os.path.exists('/dev/video' + str(camera_port)): print("No camera detected at video{}.".format(camera_port)) log("USB Camera not detected.", "error") # Open the camera camera = cv2.VideoCapture(camera_port) sleep(0.1) #setup camera parameters brightness = get_config_value(farmware_name='take-photo', config_name='brightness_val', value_type=float) contrast = get_config_value(farmware_name='take-photo', config_name='contrast_val', value_type=float) saturation = get_config_value(farmware_name='take-photo', config_name='saturation_val', value_type=float) hue = get_config_value(farmware_name='take-photo', config_name='hue_val', value_type=float) gain = get_config_value(farmware_name='take-photo', config_name='gain_val', value_type=float) width = get_config_value(farmware_name='take-photo', config_name='width_val', value_type=int) height = get_config_value(farmware_name='take-photo', config_name='height_val', value_type=int) if width != 640: camera.set(cv2.CAP_PROP_FRAME_WIDTH, width) log("Resolution width:{}".format(width), "info") else: camera.set(cv2.CAP_PROP_FRAME_WIDTH, 640) if height != 480: camera.set(cv2.CAP_PROP_FRAME_HEIGHT, height) log("Resolution height:{}".format(height), "info") else: camera.set(cv2.CAP_PROP_FRAME_HEIGHT, 480) if brightness != 10.0: camera.set(cv2.CAP_PROP_BRIGHTNESS, brightness) log("set brightness", "info") if contrast != 10.0: camera.set(cv2.CAP_PROP_CONTRAST, contrast) log("set contrast", "info") if saturation != 10.0: camera.set(cv2.CAP_PROP_SATURATION, saturation) log("set saturation", "info") if hue != 10.0: camera.set(cv2.CAP_PROP_HUE, hue) log("set hue", "info") if gain != 10.0: camera.set(cv2.CAP_PROP_GAIN, gain) log("set gain", "info") # Let camera adjust for _ in range(discard_frames): camera.grab() # Take a photo ret, image = camera.read() # Close the camera camera.release() # Output if ret: # an image has been returned by the camera filename = image_filename() # Try to rotate the image try: final_image = rotate(image) except: final_image = image else: filename = 'rotated_' + filename # Save the image to file cv2.imwrite(upload_path(filename), final_image) print("Image saved: {}".format(upload_path(filename))) else: # no image has been returned by the camera log("Problem getting image.", "error")
#!/usr/bin/env python """Move To Safe Farmware""" from farmware_tools import device from farmware_tools import get_config_value # Load inputs from Farmware page widget specified in manifest file z_height = get_config_value('Move To Safe', 'safe_z') pos_x = device.get_current_position('x') pos_y = device.get_current_position('y') pos_z = z_height device.log('Moving to ' + str(pos_x) + ', ' + str(pos_y) + ', ' + str(pos_z), 'success', ['toast']) device.move_absolute( { 'kind': 'coordinate', 'args': { 'x': pos_x, 'y': pos_y, 'z': pos_z } }, 100, { 'kind': 'coordinate', 'args': { 'x': 0, 'y': 0, 'z': 0 }
'error', ['toast']) # Open the camera camera = cv2.VideoCapture(camera_port) sleep(0.1) # Let camera adjust for _ in range(discard_frames): camera.grab() # Take a photo ret, image = camera.read() # Close the camera camera.release() # Output if ret: # an image has been returned by the camera filename_path = upload_path(image_filename()) # Save the image to file cv2.imwrite(filename_path, image) print('Image saved: {}'.format(filename_path)) else: # no image has been returned by the camera device.log('Problem getting image from video{}.'.format(camera_port), 'error', ['toast']) if __name__ == '__main__': CAMERA_PORT = get_config_value('multi-camera-take-photo', 'camera_port') usb_camera_photo(CAMERA_PORT)
# doc.getElementsByTagName returns NodeList name = doc.getElementsByTagName("name")[0] print(name.firstChild.data) staffs = doc.getElementsByTagName("staff") for staff in staffs: sid = staff.getAttribute("id") nickname = staff.getElementsByTagName("nickname")[0] salary = staff.getElementsByTagName("salary")[0] print("id:%s, nickname:%s, salary:%s" % (sid, nickname.firstChild.data, salary.firstChild.data)) ''' xml_url = get_config_value(farmware_name='Weather watcher', config_name='forecast_url_setter', value_type=str) period_to_check = get_config_value(farmware_name='Weather watcher', config_name='period_to_check_setter', value_type=int) skip_watering_limit = get_config_value( farmware_name='Weather watcher', config_name='skip_watering_limit_setter', value_type=int) watering_sequence = get_config_value(farmware_name='Weather watcher', config_name='watering_sequence_setter', value_type=str) # validate xml_url if URL is from yr.no website, whether XML can be reached # validate if period_to_check is in 6,12,18,24
import urllib2 import json import base64 from Crypto.PublicKey import RSA import farmware_tools as fwt server = fwt.get_config_value("account_switcher", "server", str) email = fwt.get_config_value("account_switcher", "email", str) credentials_json = json.dumps({ 'password': fwt.get_config_value("account_switcher", "password", str), 'email': email, 'version': 1, 'id': '_whatever' }) key_url = server + "/api/public_key" key_string = urllib2.urlopen(key_url).read() public_key = RSA.importKey(key_string) encrypted = public_key.encrypt(credentials_json, 32)[0] secret = base64.b64encode(encrypted) rpc = fwt.device.rpc_wrapper({ 'kind': 'change_ownership', 'args': {}, 'body': [ fwt.device.assemble_pair("secret", secret),
def __init__(self, farmwarename): self.farmwarename = farmwarename self.input_sequence_init_dic = {} self.input_sequence_beforemove_dic = {} self.input_sequence_aftermove_dic = {} self.input_sequence_end_dic = {} self.input_title = get_config_value(self.farmwarename, 'title', value_type=str) self.input_filter_min_x = get_config_value(self.farmwarename, 'filter_min_x', value_type=str) self.input_filter_max_x = get_config_value(self.farmwarename, 'filter_max_x', value_type=str) self.input_filter_min_y = get_config_value(self.farmwarename, 'filter_min_y', value_type=str) self.input_filter_max_y = get_config_value(self.farmwarename, 'filter_max_y', value_type=str) self.input_sequence_init = get_config_value(self.farmwarename, 'sequence_init', value_type=str).split(",") self.input_sequence_beforemove = get_config_value( self.farmwarename, 'sequence_beforemove', value_type=str).split(",") self.input_sequence_aftermove = get_config_value( self.farmwarename, 'sequence_aftermove', value_type=str).split(",") self.input_sequence_end = get_config_value(self.farmwarename, 'sequence_end', value_type=str).split(",") self.input_offset_x = get_config_value(self.farmwarename, 'offset_x', value_type=int) self.input_offset_y = get_config_value(self.farmwarename, 'offset_y', value_type=int) self.input_default_z = get_config_value(self.farmwarename, 'default_z', value_type=int) self.input_default_speed = get_config_value(self.farmwarename, 'default_speed', value_type=int) self.input_debug = get_config_value(self.farmwarename, 'debug', value_type=int) self.api = API(self.input_debug)
# Not tested turning alternate inbetween on both grids at the same time # To work out Z axis height: # 1. To work out the X axis angle use simple trig: angle = sin(angle) = opposite \ hypotenuse i.e. angle = sin-1 (opposite \ hypotenuse) # 2. To work out Z axis height i.e the opposite: hypotenuse = current X pos - beginining of X then opposite = sin(angle) * hypotenuse # 3. Then add that height (the opposite) to the startZGrid value # To signal to the recursve sequence that the Grid2Grid has finished turn on Pin3 class GridPosition: def __init__(self, xPosition, yPosition, zPosition): self.xPosition = xPosition self.yPosition = yPosition self.zPosition = zPosition numberOfPlants = get_config_value(farmware_name='Grid2Grid', config_name='numberOfPlants', value_type=int) movesPerCycle = get_config_value(farmware_name='Grid2Grid', config_name='movesPerCycle', value_type=int) xPositionsGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='xPositionsGrid1', value_type=int) yPositionsGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='yPositionsGrid1', value_type=int) spaceBetweenXGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='spaceBetweenXGrid1', value_type=float) spaceBetweenYGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='spaceBetweenYGrid1', value_type=float) startXGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='startXGrid1', value_type=float) startYGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='startYGrid1', value_type=float) startOfXSlopeGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='startOfXSlopeGrid1', value_type=float) sineOfXAngleGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='sineOfXAngleGrid1', value_type=float) alternateInBetweenGrid1 = get_config_value(farmware_name='Grid2Grid', config_name='alternateInBetweenGrid1', value_type=int) sequenceAfter1stGridMove = get_config_value(farmware_name='Grid2Grid', config_name='sequenceAfter1stGridMove', value_type=str) xPositionsGrid2 = get_config_value(farmware_name='Grid2Grid', config_name='xPositionsGrid2', value_type=int) yPositionsGrid2 = get_config_value(farmware_name='Grid2Grid', config_name='yPositionsGrid2', value_type=int)
def homomorph_filter_N3(src, sigma): B, G, R = cv2.split(src) nB, minB, maxB = homomorph_filter_N1(B, sigma) nG, minG, maxG = homomorph_filter_N1(G, sigma) nR, minR, maxR = homomorph_filter_N1(R, sigma) max = np.max([maxB, maxG, maxR]) min = np.min([minB, minG, minR]) nB = remap(nB, min, max) nG = remap(nG, min, max) nR = remap(nR, min, max) return cv2.merge((nB, nG, nR)) width = get_config_value(fw_name, config_name="width", value_type=int) height = get_config_value(fw_name, config_name="height", value_type=int) bright = get_config_value(fw_name, config_name="bright", value_type=int) contrast = get_config_value(fw_name, config_name="contrast", value_type=int) saturation = get_config_value(fw_name, config_name="sat", value_type=int) hue = get_config_value(fw_name, config_name="hue", value_type=int) device.log(message='reading ok', message_type='success') def usb_camera_photo(): #'Take a photo using a USB camera.'# camera_port = 0 # default USB camera port max_port_num = 1 # highest port to try if not detected on port discard_frames = 10 # number of frames to discard for auto-adjust max_attempts = 5 # number of failed discard frames before quit cam = cv2.VideoCapture(0)
# 1 - Get the current coordinates # 2 - Once the next co-ordinates are identified based on the current co-ordinates move there # 3 - Log the move # Decide if you pass a start flag for the first grid move on subsequent calls set this to false # May need to pass the current x, y, z co-ordinates rather than make the first call for the current co-ordinates # Remember if using alternate inbetween last row is missed so: # Normal grid: 3 rows x 2 columns = 6 cells # Alternate in between grid: 2 rows x 4 columns = 6 cells as last rows 2 of alternate inbetween columns missed # Not tested turning alternate inbetween on both grids at the same time # A better way would be to initialise 2 arrays with x,y coordinates and loop through them but this algo works device.log(message='diung params', message_type='success') rowsGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='rowsGrid1', value_type=int) colsGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='colsGrid1', value_type=int) spaceBetweenRowsGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='spaceBetweenRowsGrid1', value_type=float) spaceBetweenColsGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='spaceBetweenColsGrid1', value_type=float) startXGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='startXGrid1', value_type=float) startYGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='startYGrid1', value_type=float) startZGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='startZGrid1', value_type=float) alternateInBetweenGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='alternateInBetweenGrid1', value_type=int) startLastRowOfGrid1 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='startLastRowOfGrid1', value_type=int) rowsGrid2 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='rowsGrid2', value_type=int) colsGrid2 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='colsGrid2', value_type=int) spaceBetweenRowsGrid2 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='spaceBetweenRowsGrid2', value_type=float) spaceBetweenColsGrid2 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='spaceBetweenColsGrid2', value_type=float) startXGrid2 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='startXGrid2', value_type=float) startYGrid2 = get_config_value(farmware_name='Grid2Grid30Sec', config_name='startYGrid2', value_type=float)
X_START = Qualify.integer(PKG, 'x_start') Y_START = Qualify.integer(PKG, 'y_start') X_MAX = Qualify.integer(PKG, 'x_max') Y_MAX = Qualify.integer(PKG, 'y_max') ZAP_HEIGHT = Qualify.integer(PKG, 'zap_height') ZAP_SPEED = Qualify.integer(PKG, 'zap_speed') ZAP_TIMEOUT = Qualify.integer(PKG, 'zap_timeout') Z_TRANSLATE = Qualify.integer(PKG, 'z_translate') X_MOVE = Qualify.integer(PKG, 'x_move') Y_MOVE = Qualify.integer(PKG, 'y_move') AREA_SIZE = Qualify.integer(PKG, 'area_size') LASER_OFFSET_X = Qualify.integer(PKG, 'offset_x') LASER_OFFSET_Y = Qualify.integer(PKG, 'offset_y') WEED_TYPE = get_config_value(PKG, 'weed_type', str).lower() if WEED_TYPE not in ['weed', 'safe-remove', 'both']: device.log('Weed type invalid. Must be WEED, SAFE-REMOVE or BOTH', 'error') sys.exit() weeder_tool_retrieve_sequence_id = Qualify.sequence(PKG, 'tool_weed_retrieve') weeder_tool_return_sequence_id = Qualify.sequence(PKG, 'tool_weed_return') if len(input_errors): for err in input_errors: device.log(err, 'error', ['toast']) sys.exit() else: device.log('No config errors detected') device.write_pin(PIN_LIGHTS, 1, 0)
# Flip labels to display vertically full = cv2.flip(cv2.transpose(border), 0) # Add sensor value labels value_labels = [{'text': '0', 'position': (760, 560)}, {'text': '512', 'position': (760, 305)}, {'text': '1023', 'position': (760, 50)}] _add_labels(full, value_labels) # Add most recent time time_string = strftime('%b %d %H:%M UTC', gmtime(RECENT['time'])) _add_labels(full, [{'text': time_string, 'position': (650, 580)}]) # Add time offset labels for i, column in enumerate(range(10, 600, 90)[::-1]): _add_labels(full, [{'text': '-{} hr'.format(6 + i * 3), 'position': (column, 580)}]) # Add label area to plot area full[44:556, 40:760] = p # Add plot title title = '{}sensor (pin {})'.format('soil ' if IS_SOIL_SENSOR else '', PIN) cv2.putText(full, title.upper(), (325, 25), 0, 0.75, 0, 2) return full def save(image): """Save the plot image.""" filename = '/sensor_data_plot_{}.png'.format(int(time())) cv2.imwrite(env.Env().images_dir + filename, image) if __name__ == '__main__': PIN = get_config_value('plot-sensor-data', 'pin') IS_SOIL_SENSOR = PIN == 59 save(plot(reduce_data(get_pin_data(PIN))))
#!/usr/bin/env python ''' ' Testing running sequences and Farmwares ''' import os import json import requests from farmware_tools import device, app from farmware_tools import get_config_value s_name = get_config_value('Run Sequence', 'sequence_name', str) f_name = get_config_value('Run Sequence', 'farmware_name', str) loops = get_config_value('Run Sequence', 'loop_farmware', int) if len(''.join(s_name.split())) > 0: try: sequence_id = app.find_sequence_by_name(name=s_name) except: device.log("Couldn't find a sequence with name: {}".format(s_name), 'error', ['toast']) else: device.log("No text was entered in sequence input.", 'error', ['toast']) if len(''.join(f_name.split())) > 0: for i in range(loops): device.execute_script(label=f_name) else: device.log("No text was entered in farmware input.", 'error', ['toast'])
#!/usr/bin/env python '''Hello Farmware Input A simple Farmware example that tells FarmBot to log a new message including the provided input. ''' from farmware_tools import get_config_value, device INPUT_VALUE = get_config_value(farmware_name='Hello Farmware Input', config_name='input', value_type=str) device.log(message='Hello Farmware! Input was: {}'.format(INPUT_VALUE), message_type='success')
#!/usr/bin/env python """Set servo angle.""" from farmware_tools import get_config_value, device farmware_name = 'Set Servo Angle' pin_number = get_config_value(farmware_name, config_name='pin_number') servo_angle = get_config_value(farmware_name, config_name='servo_angle') device.set_servo_angle(pin_number, servo_angle)