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)
