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()