import crappy
if __name__ == '__main__':
graph_extenso = crappy.blocks.Grapher(('t(s)', 'Exx(%)'), ('t(s)', 'Eyy(%)'),
length=0)
extenso = crappy.blocks.Video_extenso(camera="Webcam",white_spots=False,show_image=True)
crappy.link(extenso,graph_extenso)
s = crappy.blocks.Saver("./test/data.csv",delay=1,labels=['t(s)','Exx(%)'])
crappy.link(extenso,s)
crappy.start()
value['Stress(MPa)'] = (value['Force(N)'] / self.section)
return value
labjack_instron = crappy.blocks.IOBlock(
"Labjack_T7",
labels=["time(sec)", "Position(mm)", "Effort(kN)"],
channels=["AIN0", "AIN1"],
gain=[0.5, 8], # mm/V, kN/V
offset=0,
chan_range=10,
make_zero=True,
resolution=0,
identifier='ANY')
saver_instron = crappy.blocks.Saver(directory + 'Instron.csv')
crappy.link(labjack_instron, saver_instron, condition=EvalStress())
labels = ["time(sec)", 'Tspecimen', 'Tup', 'Tdown']
labjack_temperatures = crappy.blocks.IOBlock("Labjack_T7",
mode="thermocouple",
channels=range(3),
labels=labels,
identifier='ANY')
saver_temperatures = crappy.blocks.Saver(directory + 'Temperatures.csv')
grapher_temperatures = crappy.blocks.Grapher([('time(sec)', label)
for label in labels[1:]],
length=1800)
crappy.link(labjack_temperatures,
grapher_temperatures,
freq=100,
cmd_label='cmd1')
g2 = crappy.blocks.Generator([
dict(type='cyclic_ramp',
speed2=-1,
speed1=1,
condition1='cmd2>1',
condition2='cmd2<-1',
cycles=1e30)
],
freq=50,
cmd_label='cmd2')
mul = crappy.blocks.Multiplex()
#crappy.link(g1,mul)
crappy.link(g1, mul, condition=Delay(50))
crappy.link(g2, mul)
graph = crappy.blocks.Grapher(('t(s)', 'cmd1'), ('t(s)', 'cmd2'))
crappy.link(mul, graph)
save = crappy.blocks.Saver("example_multi.csv",
labels=["t(s)", "cmd1", "cmd2"])
crappy.link(mul, save)
crappy.start()
graph = crappy.blocks.Grapher(('t(s)','x'),('t(s)','y'),('t(s)','r'),length=50)
graphRes = crappy.blocks.Grapher(('t(s)','res'),length=50)
graphLinDef = crappy.blocks.Grapher(('t(s)','Exx'),('t(s)','Exy'))
graphQuadDef = crappy.blocks.Grapher(('t(s)','Ux2'),('t(s)','Vy2'))
# Creating the correl block
correl = crappy.blocks.Correl(camera="XimeaCV",fields=[myX,'y','r',# Rigid body
'exx','eyy','exy', # Linear def
'uxx','uyy','uxy', # Quadratic def (x)
'vxx','vyy','vxy'],# Quadratic def (y)
verbose=2, #To print info
show_diff=True, # Display the residual (slow!)
drop=False, # Disable datapicker
mask=mask,
levels=4, # Reduce the number of levels
iterations=3, # and of iteration
resampling_factor=2.5, # agressive resampling
labels=( #Needed to name our custom field
'x','y','r','Exx','Eyy','Exy',
'Ux2','Uy2','Uxy',
'Vx2','Vy2','Vxy'),
mul=3.2, # Scalar to multiply the direction
res=True)# Ask to return the residual
# Link compacter to main graph
lComp2Graph = crappy.link(correl,graph)
lComp2Graph = crappy.link(correl,graphRes)
lComp2Graph = crappy.link(correl,graphLinDef)
lComp2Graph = crappy.link(correl,graphQuadDef)
crappy.start()
#coding: utf-8
import crappy
"""
Very simple program that displays the output of a choosen camera
"""
if __name__ == "__main__":
cam_list = crappy.camera.MetaCam.classes.keys()
cam_list.remove("Camera")
for i, c in enumerate(cam_list):
print i, c
r = int(raw_input("What cam do you want to use ?> "))
cam = cam_list[r]
camera = crappy.blocks.Camera(camera=cam, verbose=True)
disp = crappy.blocks.Displayer(framerate=20)
crappy.link(camera, disp)
crappy.start()
import crappy
if __name__ == "__main__":
#"""
gen = crappy.blocks.Generator(
[dict(type='sine', freq=1, amplitude=2, offset=1, condition=None)])
io = crappy.blocks.IOBlock(
"Nidaqmx",
channels=[dict(name='Dev1/ai0'),
dict(name='Dev1/ao0')],
samplerate=100,
labels=['t(s)', 'ai0'],
cmd_labels=['cmd'],
)
crappy.link(gen, io)
graph = crappy.blocks.Grapher(('t(s)', 'ai0'))
crappy.link(io, graph)
crappy.start()
"""
io = crappy.blocks.IOBlock("Nidaqmx",device="Dev2",
channels=[dict(name='ai0')],
samplerate = 100,
labels = ['t(s)','ai0'],
)
graph = crappy.blocks.Grapher(('t(s)','ai0'))
crappy.link(io,graph)
crappy.start()
#"""
#coding: utf-8
import crappy
def intify(data):
for i,d in enumerate(data):
if isinstance(d,bool):
data[i] = int(d)
return data
if __name__ == "__main__":
gen = crappy.blocks.Generator([
dict(type='cyclic',value1=0,value2=1,condition1="delay=1",condition2="delay=1")
],repeat=True)
io = crappy.blocks.IOBlock("Nidaqmx",device="Dev2",
channels=[dict(name='ai0'),dict(name='di0'),dict(name='ao0'),dict(name='do1')],
samplerate = 100,
labels = ['t(s)','ai0','di0'],
cmd_labels = ['cmd','cmd'],
)
crappy.link(gen,io)
graph = crappy.blocks.Grapher(('t(s)','di0'),('t(s)','ai0'))
crappy.link(io,graph,condition=intify)
crappy.start()
#coding: utf-8
import crappy
graph = crappy.blocks.Grapher(('t(s)', 'x'), ('t(s)', 'y'), ('t(s)', 'r'),
length=50)
correl = crappy.blocks.Correl(camera="XimeaCV", fields=['x', 'y',
'r']) # Rigid body
crappy.link(correl, graph)
crappy.start()
#coding: utf-8
import crappy
STREAMER = True
channels = range(1)
chan_names = ['cDAQ1Mod1/ai%d'%i for i in channels]
labels = ['t(s)']+['T%d'%i for i in channels]
if __name__ == "__main__":
io = crappy.blocks.IOBlock("Nidaqmx",
channels=[dict(name=c_name,units='C',
type='thrmcpl',
thermocouple_type='K') for c_name in chan_names],
samplerate = 14./len(channels),
labels = ['t(s)','stream'] if STREAMER else labels,
streamer = STREAMER
)
graph = crappy.blocks.Grapher(*[('t(s)',l) for l in labels[1:]])
if STREAMER:
crappy.link(io,graph,condition=crappy.condition.Demux(labels[1:],mean=False,transpose=True))
else:
crappy.link(io,graph)
crappy.start()
import crappy
lbj = crappy.technical.LabJack(actuator={'channel': 'TDAC0'}, verbose=True)
cc = crappy.blocks.ControlCommand(lbj, compacter=1000, verbose=True)
wave = crappy.blocks.WaveGenerator(waveform='square',
duty_cycle=0.5,
wave_frequency=0.5,
nb_points=1,
gain=10)
# dash = crappy.blocks.Dashboard()
# graph = crappy.blocks.Grapher(('time(sec)', 'signal'), length=10)
crappy.link(wave, cc)
# crappy.link(cc, graph)
# crappy.link(cc, dash)
crappy.start()
#coding: utf-8
import crappy
ve = crappy.blocks.Video_extenso(camera='XimeaCV',show_image=True)
ad = crappy.blocks.AutoDrive(
actuator={'name':'CM_drive','port': '/dev/ttyUSB0'},direction='X-')
graph_extenso = crappy.blocks.Grapher(('t(s)', 'Exx(%)'), ('t(s)', 'Eyy(%)'),
length=0)
crappy.link(ve,graph_extenso)
crappy.link(ve,ad)
crappy.start()
import crappy
gx = crappy.blocks.Generator([{'type':'protection','condition2':'F3>5',
'value1':10,'condition1':'F3<-5','value2':-10}],
cmd_label='vx')
gy = crappy.blocks.Generator([{'type':'protection','condition2':'F1>5',
'value1':10,'condition1':'F1<-5','value2':-10}],
cmd_label='vy')
m1 = {'port':'/dev/ttyS4','cmd':'vy'}
m2 = {'port':'/dev/ttyS5','cmd':'vy'}
m3 = {'port':'/dev/ttyS6','cmd':'vx'}
m4 = {'port':'/dev/ttyS7','cmd':'vx'}
common = {'type':'biaxe'}
m = crappy.blocks.Machine([m1,m2,m3,m4],common)
s = crappy.blocks.IOBlock('Comedi',channels=[1,3],gain=[3749,3749],
labels=['t(s)','F1','F3'])
g = crappy.blocks.Grapher(('t(s)','F1'),('t(s)','F3'))
crappy.link(s,g)
crappy.link(s,gx)
crappy.link(s,gy)
crappy.link(gx,m)
crappy.link(gy,m)
crappy.start()
"""
Remember: data is ALWAYS a dict
returning None will drop the data
"""
for k in data:
if k != 't(s)': # Move everything except the time
data[k] += self.offset
return data # Do not forget to return it!
import crappy
print("Available conditions:",crappy.condition.condition_list.keys())
if __name__ == "__main__":
generator = crappy.blocks.Generator(path=[
{'type':'constant','value':0, 'condition':'delay=2'},
{'type':'constant','value':1, 'condition':'delay=2'}
]*20,spam=True)
graph = crappy.blocks.Grapher(('t(s)','cmd'))
smooth_graph = crappy.blocks.Grapher(('t(s)','cmd'))
crappy.link(generator,graph)
crappy.link(generator,smooth_graph,
condition=[crappy.condition.Moving_avg(500),My_condition(5)])
r = crappy.blocks.Reader('Trigged')
crappy.link(generator,r,condition=crappy.condition.Trig_on_change('cycle'))
crappy.start()
sim_speed=SPEED,
mode='speed',
speed_label='T',
kv=1000,
inertia=500,
rv=.01,
torque=-18,
#initial_speed=17.8218,
initial_speed=175,
fv=1e-5
)])
pid = crappy.blocks.PID(P,I,D,input_label='T',out_max=1,out_min=0,
i_limit=.5,send_terms=True)
crappy.link(g,pid)
crappy.link(pid,four,condition=Delay(20/SPEED))
crappy.link(four,pid)
graph = crappy.blocks.Grapher(('t(s)','T'))
crappy.link(four,graph)
graph_pid = crappy.blocks.Grapher(
('t(s)','p_term'),
('t(s)','i_term'),
('t(s)','d_term'),
('t(s)','pid'))
crappy.link(pid,graph_pid)
crappy.start()
#coding: utf-8
from __future__ import print_function
import time
import crappy
save_path = "biotens_data/"
timestamp = time.ctime()[:-5].replace(" ","_")
save_path += timestamp+"/"
# Creating F sensor
effort = crappy.blocks.IOBlock("Comedi",channels=[0], gain=[-48.8],labels=['t(s)','F(N)'])
# grapher
graph_effort = crappy.blocks.Grapher(('t(s)','F(N)'))
crappy.link(effort,graph_effort)
# and saver
save_effort = crappy.blocks.Saver(save_path+"effort.csv")
crappy.link(effort,save_effort)
b = crappy.actuator.Biotens()
b.open()
b.reset_position()
b.set_position(5,50)
# Creating biotens technical
biotens = crappy.blocks.Machine([{'type':'biotens','port':'/dev/ttyUSB0','pos_label':'position1','cmd':'cmd'}]) # Used to initialize motor.
graph_pos= crappy.blocks.Grapher(('t(s)', 'position1'))
crappy.link(biotens,graph_pos)
# And saver
save_pos= crappy.blocks.Saver(save_path+'position.csv')
crappy.link(biotens,save_pos)
# To pilot the biotens
signal_generator = crappy.blocks.Generator([{'type':'constant','condition':'F(N)>90','value':5}],freq=100)
white_spots=False,
max_fps=30)
ad = crappy.blocks.AutoDrive(actuator={
'name': 'CM_drive',
'port': '/dev/ttyUSB0'
},
direction='X-')
graph_extenso = crappy.blocks.Grapher(('t(s)', 'Exx(%)'), ('t(s)', 'Eyy(%)'))
saver_extenso = crappy.blocks.Saver(save_path + "extenso.csv",
labels=['t(s)', 'Exx(%)', 'Eyy(%)'])
# Linking them
crappy.link(ve, graph_extenso)
crappy.link(ve, saver_extenso)
crappy.link(ve, ad)
# Labjack
lj = crappy.blocks.IOBlock("Labjack_t7",
channels=[{
'name': 'AIN0',
'gain': gains[0],
'make_zero': True
}, {
'name': 'AIN1',
'gain': gains[1],
'make_zero': True
}, {
'name': 'TDAC0',
sleep(.2)
img = "data/Pad.png"
coord = [ # Coordinated for the thermocouples
(185, 430), # T1
(145, 320), # T2
(105, 220), # T3
(720, 370), # T4
(720, 250), # T5
(720, 125), # T6
(1220, 410), # T7
(1260, 320), # T8
(1300, 230), # T9
]
options = [{'type':'dot_text',
'coord':coord[i],
'text':'T{} = %.1f'.format(i+1),
'label':'T'+str(i+1)} for i in range(9)]
if __name__ == "__main__":
s = TestBlock([d['label'] for d in options])
options.append({"type":'time','coord':(80,1000)})
d = crappy.blocks.Drawing(img,options, crange=[20,300], title="Temperatures")
crappy.link(s,d)
crappy.start()
#coding: utf-8
import crappy
g = crappy.blocks.Generator(
[dict(type='sine', freq=1, amplitude=1, condition=None)])
s = crappy.blocks.Server()
crappy.link(g, s)
crappy.start()
import crappy
if __name__ == '__main__':
graph_extenso = crappy.blocks.Grapher(('t(s)', 'Exx(%)'),
('t(s)', 'Eyy(%)'),
length=0)
extenso = crappy.blocks.Video_extenso(camera="Webcam",
stop=True,
show_image=True)
crappy.link(extenso, graph_extenso)
crappy.start()
#coding: utf-8
import crappy
g1 = crappy.blocks.Generator(
[dict(type='sine',freq=2,amplitude=2,condition=None)],
freq=200,
cmd_label = 'cmd1'
)
g2 = crappy.blocks.Generator(
[dict(type='sine',freq=.2,amplitude=2,condition=None)],
freq=200,
cmd_label = 'cmd2'
)
m = crappy.blocks.Mean(.5)#,out_labels=['cmd1','cmd2'])
crappy.link(g1,m)
crappy.link(g2,m)
g = crappy.blocks.Grapher(('t(s)','cmd1'),('t(s)','cmd2'))
crappy.link(m,g)
crappy.start()
path2['condition2'] = 'delay=5'
g1 = crappy.blocks.Generator(path=[path], cmd_label="vx")
g2 = crappy.blocks.Generator(path=[path2], cmd_label="vy")
mot = {'type': 'biaxe', 'mode': 'speed'}
motA = {
'port': '/dev/ttyS4',
'cmd': 'vy',
}
motB = {
'port': '/dev/ttyS5',
'cmd': 'vx',
}
motC = {
'port': '/dev/ttyS6',
'cmd': 'vy',
}
motD = {
'port': '/dev/ttyS7',
'cmd': 'vx',
}
b = crappy.blocks.Machine([motA, motB, motC, motD], common=mot)
crappy.link(g1, b)
crappy.link(g2, b)
crappy.start()
import crappy
channels = ['AIN0', 'AIN1']
labjack = crappy.technical.LabJack(sensor={
'mode': 'streamer',
'scan_rate_per_channel': 10000,
'scans_per_read': 1000,
'channels': channels,
'gain': [1, 2000]
},
verbose=True)
streamer = crappy.blocks.Streamer(
sensor=labjack, labels=['time(sec)', 'Position(mm)', 'Force(N)'], mean=100)
grapher = crappy.blocks.Grapher([('time(sec)', 'Force(N)')], length=10)
grapher2 = crappy.blocks.Grapher([('time(sec)', 'Position(mm)')], length=10)
# saver = crappy.blocks.Saver('/home/francois/Essais/traction_ahmed/essai01.csv', stamp='date')
dash = crappy.blocks.Dashboard()
crappy.link(streamer, grapher)
crappy.link(streamer, dash)
crappy.link(streamer, grapher2)
crappy.start()
(185, 430), # T1
(145, 320), # T2
(105, 220), # T3
(720, 370), # T4
(720, 250), # T5
(720, 125), # T6
(1220, 410), # T7
(1260, 320), # T8
(1300, 230), # T9
]
options = [{
'type': 'dot_text',
'coord': coord[i],
'text': 'T{} = %.1f'.format(i + 1),
'label': 'T' + str(i + 1)
} for i in range(9)]
if __name__ == "__main__":
s = TestBlock([d['label'] for d in options])
options.append({"type": 'time', 'coord': (80, 1000)})
d = crappy.blocks.Drawing(img,
options,
crange=[20, 300],
title="Temperatures")
crappy.link(s, d)
crappy.start()
#coding: utf-8
from __future__ import division
import crappy
channels = list(range(16)) # Every channel (from 0 to 15)
ranges = [10000]*len(channels) # -10/+10V (in mV)
# This will NOT apply the gain to the stream, only save a key in the h5
gains = [1]*len(channels)
save_file = "./out.h5"
chan_names = ['ch'+str(i) for i in channels]
spectrum = crappy.blocks.IOBlock('spectrum',ranges=ranges,
channels=channels,
streamer=True,
labels=['t(s)','stream'])
graph = crappy.blocks.Grapher(*[('t(s)',i) for i in chan_names])
if save_file:
hsaver = crappy.blocks.Hdf_saver("./out.h5",
metadata={'channels':channels,'ranges':ranges,'freq':100000,
'factor':[r*g/32000000 for r,g in zip(ranges,gains)]})
crappy.link(spectrum,hsaver)
crappy.link(spectrum,graph,
condition=crappy.condition.Demux(chan_names,mean=False))
crappy.start()
import crappy
nb_chans = 1
channels = range(nb_chans)
gain = [56] * nb_chans
offset = [0] * nb_chans
# With fake sensor
# sensor = crappy.sensor.DummySensor(channels=[0, 1])
# With Comedi
# sensor = crappy.sensor.ComediSensor(channels=channels,
# gain=gain,
# offset=offset)
# With Labjack (T7 or UE9)
# sensor = crappy.technical.LabJack(sensor={'channels': channels}, verbose=True)
# With OpenDAQ
sensor = crappy.technical.OpenDAQ(channels=[1, 2], nsamples=20)
measure = crappy.blocks.MeasureByStep(sensor,
freq=100,
verbose=True,
compacter=100)
# grapher = crappy.blocks.Grapher(('t', 'C0'), ('t', 'C1'), length=100)
dash = crappy.blocks.Dashboard()
# crappy.link(measure, grapher)
crappy.link(measure, dash)
crappy.start()
import crappy
gx = crappy.blocks.Generator([{'type':'protection','condition2':'F3>5','value1':10,
'condition1':'F3<-5','value2':-10}],
cmd_label='vx')
gy = crappy.blocks.Generator([{'type':'protection','condition2':'F1>5','value1':10,
'condition1':'F1<-5','value2':-10}],
cmd_label='vy')
m1 = {'port':'/dev/ttyS4','cmd':'vy'}
m2 = {'port':'/dev/ttyS5','cmd':'vy'}
m3 = {'port':'/dev/ttyS6','cmd':'vx'}
m4 = {'port':'/dev/ttyS7','cmd':'vx'}
common = {'type':'biaxe'}
m = crappy.blocks.Machine([m1,m2,m3,m4],common)
s = crappy.blocks.MeasureByStep('Comedi',channels=[1,3],gain=[3749,3749],
labels=['t(s)','F1','F3'])
g = crappy.blocks.Grapher(('t(s)','F1'),('t(s)','F3'))
crappy.link(s,g)
crappy.link(s,gx)
crappy.link(s,gy)
crappy.link(gx,m)
crappy.link(gy,m)
crappy.start()
cmd_label='v3')
g4 = crappy.blocks.Generator([{'type':'protection','condition2':'F4>5',
'value1':10,'condition1':'F4<-5','value2':-10}],
cmd_label='v4')
m1 = {'port':'/dev/ttyS4','cmd':'v1'}
m2 = {'port':'/dev/ttyS5','cmd':'v2'}
m3 = {'port':'/dev/ttyS6','cmd':'v3'}
m4 = {'port':'/dev/ttyS7','cmd':'v4'}
common = {'type':'biaxe'}
m = crappy.blocks.Machine([m1,m2,m3,m4],common)
s = crappy.blocks.IOBlock('Comedi',channels=[1,2,3,4],gain=3749,
labels=['t(s)','F1','F2','F3','F4'])
g = crappy.blocks.Grapher(('t(s)','F1'),('t(s)','F2'),
('t(s)','F3'),('t(s)','F4'))
crappy.link(s,g)
crappy.link(s,g1)
crappy.link(s,g2)
crappy.link(s,g3)
crappy.link(s,g4)
crappy.link(g1,m)
crappy.link(g2,m)
crappy.link(g3,m)
crappy.link(g4,m)
crappy.start()
#coding: utf-8
import crappy
import tables
import numpy as np
def my_mean(data):
#print("D",data)
#print("t",type(data))
for k,val in data.items():
data[k] = np.mean(val)
#data[k] = val[0]
return data
s = crappy.blocks.IOBlock("T7_streamer",
#labels=['t','AIN0','AIN1'],
#labels=['t','stream'],
channels = [{'name':'AIN0','gain':2,'offset':-13},
{'name':'AIN1','gain':2,"make_zero":True}],
#channels=['AIN0','AIN1'],
streamer=True)
#g = crappy.blocks.Grapher(('t','AIN0'),('t','AIN1'))
#crappy.link(s,g,condition=my_mean)
save = crappy.blocks.Hdf_saver("/home/vic/out.h5",atom=tables.Float64Atom())
crappy.link(s,save)
crappy.start()
pid_list.append(
crappy.blocks.PID(P,
I if i != 5 else 0,
D,
input_label='T%d' % i,
out_max=1,
out_min=0,
i_limit=.5,
send_terms=(SHOW_PID is not None and i == SHOW_PID),
labels=['t(s)', 'pwm%d' % i]))
gen_list.append(
crappy.blocks.Generator(
[dict(type='constant', condition=None, value=v[i])]))
crappy.link(gen_list[-1], pid_list[-1])
crappy.link(pid_list[-1], lj, condition=dc_to_clk('pwm%d' % i))
crappy.link(lj,
pid_list[-1],
condition=[
crappy.condition.Median(MED),
crappy.condition.Moving_avg(MEAN)
])
crappy.link(pid_list[-1], graph_cmd)
graph = crappy.blocks.Grapher(*[('t(s)', 'T%d' % i) for i in pins])
crappy.link(lj,
graph,
condition=[
crappy.condition.Median(MED),
crappy.condition.Moving_avg(MEAN)
cmd_label='cmd2',
freq=500)
io = crappy.blocks.IOBlock("Labjack_t7",
labels=['t(s)', 'c0', 'c1'],
cmd_labels=['cmd1', 'cmd2'],
channels=[
{
'name': 'AIN0'
},
{
'name': 'AIN1'
},
{
'name': 'DAC0'
},
{
'name': 'DAC1'
},
],
verbose=True)
crappy.link(sg1, io)
crappy.link(sg2, io)
g = crappy.blocks.Grapher(('t(s)', 'c0'), ('t(s)', 'c1'))
crappy.link(io, g)
crappy.start()
#coding: utf-8
import crappy
s = crappy.blocks.Client('localhost')
g = crappy.blocks.Grapher(('t(s)', 'cmd'))
crappy.link(s, g)
crappy.start()
value['Shear(MPa)'] = (
(value['Torque(Nm)'] / self.I) * self.rmax * 10 ** -6)
value['Stress(MPa)'] = (value['Force(N)'] / self.section)
return value
labjack_instron = crappy.blocks.IOBlock("Labjack_T7",
labels=["time(sec)", "Position(mm)", "Effort(kN)"],
channels=["AIN0", "AIN1"],
gain = [0.5, 8], # mm/V, kN/V
offset=0,
chan_range=10,
make_zero=True,
resolution=0,
identifier='ANY')
saver_instron = crappy.blocks.Saver(directory + 'Instron.csv')
crappy.link(labjack_instron, saver_instron, condition=EvalStress())
labels = ["time(sec)", 'Tspecimen', 'Tup', 'Tdown']
labjack_temperatures = crappy.blocks.IOBlock("Labjack_T7",
mode="thermocouple",
channels=range(3),
labels=labels,
identifier='ANY')
saver_temperatures = crappy.blocks.Saver(directory + 'Temperatures.csv')
grapher_temperatures = crappy.blocks.Grapher(
[('time(sec)', label) for label in labels[1:]], length=1800)
crappy.link(labjack_temperatures, grapher_temperatures,
condition=ConditionCalib())
crappy.link(labjack_temperatures, saver_temperatures,
kv=1000,
inertia=500,
rv=.01,
torque=-18,
#initial_speed=17.8218,
initial_speed=175,
fv=1e-5)
])
pid = crappy.blocks.PID(P,
I,
D,
input_label='T',
out_max=1,
out_min=0,
i_limit=.5,
send_terms=True)
crappy.link(g, pid)
crappy.link(pid, four, condition=Delay(20 / SPEED))
crappy.link(four, pid)
graph = crappy.blocks.Grapher(('t(s)', 'T'))
crappy.link(four, graph)
graph_pid = crappy.blocks.Grapher(('t(s)', 'p_term'), ('t(s)', 'i_term'),
('t(s)', 'd_term'), ('t(s)', 'pid'))
crappy.link(pid, graph_pid)
crappy.start()
kv = 1000
mot = crappy.blocks.Machine([{'type':'Fake_motor',
'cmd':'pid',
'mode':'speed',
'speed_label':'speed',
# Motor properties:
'kv':kv,
'inertia':2,
'rv':.2,
'fv':1e-5
}])
graph_m = crappy.blocks.Grapher(('t(s)','speed'),('t(s)','cmd'),interp=False)
crappy.link(mot,graph_m)
crappy.link(g,graph_m)
# To see what happens without PID
#crappy.link(g,mot)
#crappy.start()
p = 38/kv
i = .28
d = .015
pid = crappy.blocks.PID(kp=p,
ki=i,
kd=d,
out_max=10,
out_min=-10,
input_label='speed',
"""
This example shows how to use multiple output channels object while acquiring
with an inout object
We use 2 generators to make two independant signals, each of them having
a different cmd label
We simply need to specify these labels in IOBlock and it will automatically
parse the inputs to get the latest value of the when updating the output.
Note: this exemple uses a Labjack but can run on other devices (you may
have to ajust the range for the Comedi)
"""
sg1 = crappy.blocks.Generator([{'type':'sine','freq':.5,'amplitude':.4,
'offset':.2,'condition':'delay=1000'}])
sg2 = crappy.blocks.Generator([{'type':'cyclic_ramp','speed1':.2,'speed2':-.2,
'condition1':'cmd2>.4','condition2':'cmd2<0','cycles':0}],cmd_label='cmd2')
io = crappy.blocks.IOBlock('Comedi',labels=['t(s)','c0','c1'],channels=[0,1],
out_channels=[0,1],verbose=True,cmd_labels=['cmd','cmd2'],make_zero=False)
crappy.link(sg1,io)
crappy.link(sg2,io)
g = crappy.blocks.Grapher(('t(s)','c0'),('t(s)','c1'))
crappy.link(io,g)
crappy.start()
#coding: utf-8
import crappy
"""
Very simple program that displays the output of a choosen camera
"""
if __name__ == "__main__":
cam_list = crappy.camera.MetaCam.classes.keys()
cam_list.remove("Camera")
for i,c in enumerate(cam_list):
print i,c
r = int(raw_input("What cam do you want to use ?> "))
cam = cam_list[r]
camera = crappy.blocks.Camera(camera=cam,verbose=True)
disp = crappy.blocks.Displayer(framerate=20)
crappy.link(camera,disp)
crappy.start()
'condition1':'F3<-5','value2':-10}],
cmd_label='v3')
g4 = crappy.blocks.Generator([{'type':'protection','condition2':'F4>5','value1':10,
'condition1':'F4<-5','value2':-10}],
cmd_label='v4')
m1 = {'port':'/dev/ttyS4','cmd':'v1'}
m2 = {'port':'/dev/ttyS5','cmd':'v2'}
m3 = {'port':'/dev/ttyS6','cmd':'v3'}
m4 = {'port':'/dev/ttyS7','cmd':'v4'}
common = {'type':'biaxe'}
m = crappy.blocks.Machine([m1,m2,m3,m4],common)
s = crappy.blocks.MeasureByStep('Comedi',channels=[1,2,3,4],gain=3749,
labels=['t(s)','F1','F2','F3','F4'])
g = crappy.blocks.Grapher(('t(s)','F1'),('t(s)','F2'),('t(s)','F3'),('t(s)','F4'))
crappy.link(s,g)
crappy.link(s,g1)
crappy.link(s,g2)
crappy.link(s,g3)
crappy.link(s,g4)
crappy.link(g1,m)
crappy.link(g2,m)
crappy.link(g3,m)
crappy.link(g4,m)
crappy.start()
#coding: utf-8 import crappy g = crappy.blocks.Generator([dict(type='sine',freq=1,amplitude=1,condition=None)]) s = crappy.blocks.Server() crappy.link(g,s) crappy.start()
path2 = dict(path)
path2['condition1'] = 'delay=5'
path2['condition2'] = 'delay=5'
g1 = crappy.blocks.Generator(path=[path],cmd_label="vx")
g2 = crappy.blocks.Generator(path=[path2],cmd_label="vy")
mot = {'type':'biaxe',
'mode':'speed'
}
motA = {'port':'/dev/ttyS4',
'cmd':'vy',
}
motB = {'port':'/dev/ttyS5',
'cmd':'vx',
}
motC = {'port':'/dev/ttyS6',
'cmd':'vy',
}
motD = {'port':'/dev/ttyS7',
'cmd':'vx',
}
b = crappy.blocks.Machine([motA,motB,motC,motD],common=mot)
crappy.link(g1,b)
crappy.link(g2,b)
crappy.start()
from __future__ import absolute_import
import crappy
chan = [0,2,3,4,5]
if __name__ == "__main__":
m = crappy.blocks.IOBlock("Labjack_t7",
channels=[dict(name='AIN%d'%i,thermocouple='K') for i in chan],
verbose=True,labels=['t(s)']+['T%d'%i for i in chan])
g = crappy.blocks.Grapher(*[('t(s)','T%d'%i) for i in chan])
#crappy.link(m,g)
crappy.link(m,g,condition=crappy.condition.Moving_avg(10))
crappy.start()
"""
Very simple example that show how to communicate with kollmorgen
variator via crappy.
The IOBlock is currently named "Koll", but it needs proper baptism...
Args:
data: "position", or "speed", depending on which information to display (
could be improved to give both information)
axis: 1,2,3 or 4, or "all", depending on which axis to plot. the 4th is the
rotary encoder.
labels: to give fancy names to each axis.
"""
import crappy
koll = crappy.blocks.IOBlock("Koll",
data="speed",
axis="all",
# labels=["t(s)", "1"])
labels=['t(s)'] + map(str, range(1, 5)))
graph = crappy.blocks.Grapher(("t(s)", "1"),
("t(s)", "2"),
("t(s)", "3"),
("t(s)", "4"), length=1000)
crappy.link(koll, graph)
crappy.start()
import crappy
# labels = ['temps_python(s)', 'temps_arduino(ms)', 'mode', 'vitesse', 'random']
if __name__ == '__main__':
labels = ["current_millis", "effort"]
arduino = crappy.technical.Arduino(port='/dev/ttyACM0',
baudrate=250000,
labels=labels)
measurebystep = crappy.blocks.MeasureByStep(arduino)
graph = crappy.blocks.Grapher(('current_millis', 'effort'), length=10)
dash = crappy.blocks.Dashboard()
crappy.link(measurebystep, graph)
crappy.link(measurebystep, dash, name='dash')
crappy.start()
'exx',
'eyy',
'exy', # Linear def
'uxx',
'uyy',
'uxy', # Quadratic def (x)
'vxx',
'vyy',
'vxy'
], # Quadratic def (y)
verbose=2, #To print info
show_diff=True, # Display the residual (slow!)
drop=False, # Disable datapicker
mask=mask,
levels=4, # Reduce the number of levels
iterations=3, # and of iteration
resampling_factor=2.5, # agressive resampling
labels=( #Needed to name our custom field
'x', 'y', 'r', 'Exx', 'Eyy', 'Exy', 'Ux2', 'Uy2', 'Uxy', 'Vx2', 'Vy2',
'Vxy'),
mul=3.2, # Scalar to multiply the direction
res=True) # Ask to return the residual
# Link compacter to main graph
lComp2Graph = crappy.link(correl, graph)
lComp2Graph = crappy.link(correl, graphRes)
lComp2Graph = crappy.link(correl, graphLinDef)
lComp2Graph = crappy.link(correl, graphQuadDef)
crappy.start()
from __future__ import absolute_import
import crappy
for i, c in enumerate(crappy.inout.in_list):
print i, c
name = crappy.inout.in_list.keys()[int(
raw_input("What board do you want to use ?> "))]
m = crappy.blocks.IOBlock(name, labels=['t(s)', 'chan0'], verbose=True)
g = crappy.blocks.Grapher(('t(s)', 'chan0'))
crappy.link(m, g)
crappy.start()
from time import time
tofloat = crappy.tool.convert_data.data_to_float32
class Torqueforce(crappy.inout.InOut):
def __init__(self,port='/dev/ttyUSB0',baudrate=115200):
self.port = port
self.baudrate = baudrate
self.m = ModbusSerialClient('rtu',port=self.port,baudrate=self.baudrate,
parity='E')
def open(self):
self.m.connect()
def get_data(self):
l = self.m.read_holding_registers(32,4,unit=1).registers
return [time(),tofloat(l[:2]),tofloat(l[2:])]
def close(self):
self.m.close()
io = crappy.blocks.IOBlock("TorqueForce",labels=['t(s)','F(kN)','C(Nm)'],
verbose=True)
graph_f = crappy.blocks.Grapher(('t(s)','F(kN)'))
graph_c = crappy.blocks.Grapher(('t(s)','C(Nm)'))
crappy.link(io,graph_f)
crappy.link(io,graph_c)
crappy.start()
#coding: utf-8
import crappy
if __name__ == "__main__":
#"""
gen = crappy.blocks.Generator([
dict(type='sine',freq=1,amplitude=2,offset=1,condition=None)
])
io = crappy.blocks.IOBlock("Nidaqmx",
channels=[dict(name='Dev1/ai0'),dict(name='Dev1/ao0')],
samplerate = 100,
labels = ['t(s)','ai0'],
cmd_labels = ['cmd'],
)
crappy.link(gen,io)
graph = crappy.blocks.Grapher(('t(s)','ai0'))
crappy.link(io,graph)
crappy.start()
"""
io = crappy.blocks.IOBlock("Nidaqmx",device="Dev2",
channels=[dict(name='ai0')],
samplerate = 100,
labels = ['t(s)','ai0'],
)
graph = crappy.blocks.Grapher(('t(s)','ai0'))
crappy.link(io,graph)
crappy.start()
#"""
pid_list = []
gen_list = []
graph_cmd = crappy.blocks.Grapher(*[('t(s)','pwm%d'%i) for i in pins])
for i in pins:
pid_list.append(crappy.blocks.PID(P,I if i != 5 else 0,D,
input_label='T%d'%i,
out_max=1,out_min=0,
i_limit=.5,
send_terms=(SHOW_PID is not None and i == SHOW_PID),
labels=['t(s)','pwm%d'%i]))
gen_list.append( crappy.blocks.Generator(
[dict(type='constant',condition=None,value=v[i])]))
crappy.link(gen_list[-1],pid_list[-1])
crappy.link(pid_list[-1],lj,condition=dc_to_clk('pwm%d'%i))
crappy.link(lj,pid_list[-1],condition=[crappy.condition.Median(MED),crappy.condition.Moving_avg(MEAN)])
crappy.link(pid_list[-1],graph_cmd)
graph = crappy.blocks.Grapher(*[('t(s)','T%d'%i) for i in pins])
crappy.link(lj,graph,condition=[crappy.condition.Median(MED),crappy.condition.Moving_avg(MEAN)])
if SHOW_PID:
graph_pid = crappy.blocks.Grapher(
('t(s)','p_term'),
('t(s)','i_term'),
('t(s)','d_term'),
('t(s)','pwm%d'%SHOW_PID))
crappy.link(pid_list[pins.index(SHOW_PID)],graph_pid)
#matplotlib.use('Agg')
import crappy
for i, c in enumerate(crappy.inout.inout_list):
print(i, c)
name = list(crappy.inout.inout_list.keys())[int(
input("What board do you want to use ?> "))]
sg = crappy.blocks.Generator([{
'type': 'sine',
'freq': .5,
'amplitude': 1,
'offset': .5,
'condition': 'delay=1000'
}],
cmd_label='cmd')
io = crappy.blocks.IOBlock(name,
labels=['t(s)', 'chan0'],
cmd_labels=['cmd'],
out_channels=0,
verbose=True)
crappy.link(sg, io)
g = crappy.blocks.Grapher(('t(s)', 'chan0'))
crappy.link(io, g)
crappy.start()
def evaluate(self,data):
self.hist.append(data)
if len(self.hist) >= self.n:
return self.hist.pop(0)
g1 = crappy.blocks.Generator([
dict(type='sine',freq=1,amplitude=1,condition=None)
],freq=100,cmd_label='cmd1')
g2 = crappy.blocks.Generator([
dict(type='cyclic_ramp',speed2=-1,speed1=1,
condition1='cmd2>1',condition2='cmd2<-1',cycles=1e30)
],freq=50,cmd_label='cmd2')
mul = crappy.blocks.Multiplex()
#crappy.link(g1,mul)
crappy.link(g1,mul,condition=Delay(50))
crappy.link(g2,mul)
graph = crappy.blocks.Grapher(('t(s)','cmd1'),('t(s)','cmd2'))
crappy.link(mul,graph)
save = crappy.blocks.Saver("example_multi.csv",labels=["t(s)", "cmd1", "cmd2"])
crappy.link(mul,save)
crappy.start()
