Modeling and Simulation of Physical Systems for Hobbyists
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Subtitle |
| |
| Title of Series | ||
| Number of Parts | 165 | |
| Author | ||
| License | CC Attribution 4.0 International: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal purpose as long as the work is attributed to the author in the manner specified by the author or licensor. | |
| Identifiers | 10.5446/39339 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
| |
| Keywords |
35C3 Refreshing Memories23 / 165
2
5
6
7
8
9
10
11
12
13
15
16
17
22
26
29
30
31
33
37
38
39
40
44
45
48
49
53
54
55
57
59
60
62
65
66
69
70
72
73
74
77
80
82
83
84
85
86
87
89
92
94
100
104
105
106
107
108
111
113
114
115
116
117
119
121
122
123
124
127
132
133
136
139
141
143
144
145
146
148
149
150
154
155
156
157
158
159
160
161
162
163
164
165
00:00
Model theorySimilarity (geometry)Scientific modellingComputer simulationProjective planeMusical ensembleThresholding (image processing)PhysicalismPhysical systemLecture/Conference
00:46
System programmingSimulationPhysical systemWebsiteBitLecture/Conference
01:21
Computer hardwareModel theoryMathematicsSimulationSystem programmingComputer fontContext awarenessModel theoryBitWordVideo gamePhysicalismComputer hardwarePhysical systemDescriptive statisticsMechanism designRoboticsComputer simulationNichtlineares GleichungssystemQuicksortState of matterSoftwareComputerMultiplication signCalculationMathematicsSound effectLink (knot theory)Different (Kate Ryan album)Computer animationMeeting/Interview
03:23
SimulationModel theoryPhysical systemComputer hardwareSoftwareUniverse (mathematics)10 (number)MathematicsBitGradientLevel (video gaming)Roundness (object)Uniformer Raum
04:07
SimulationComputer hardwareComputer simulationPhysical systemMultiplication signView (database)Point (geometry)SoftwareGoodness of fitGame controllerComputer programmingInverses PendelRoboticsComputer animation
06:03
SimulationAtomic nucleusVariable (mathematics)Stack (abstract data type)Electric currentComputer fileImage warpingVideo game consoleLeakCodeComputer simulationGame controllerComputer hardwareMereologyBitRoboticsPower (physics)SoftwareSource codeComputer animation
07:10
SimulationComponent-based software engineeringFree variables and bound variablesComputer hardwareModel theoryComputer simulationSoftware testingVirtualizationComputer hardwareReal numberFree variables and bound variablesComputer animationLecture/ConferenceMeeting/Interview
07:50
Level (video gaming)VelocityLine (geometry)ParabolaMessage passingSound effectState observerSlide ruleDifferent (Kate Ryan album)PlotterNetwork topologyFile formatGravitationDrag (physics)Model theoryMeasurementFrequencyDiagram
09:27
Modal logicModel theoryPoint (geometry)VelocityLevel (video gaming)Flow separationProjective planeComputer simulationAddress spaceMultiplication signPhysical systemLecture/ConferenceMeeting/Interview
10:09
VelocityDisintegrationPosition operatorBit rateIntelMultiplication signVelocityPoint (geometry)CASE <Informatik>Different (Kate Ryan album)Nichtlineares GleichungssystemPosition operatorFunctional (mathematics)INTEGRALBitDistanceDerivation (linguistics)MathematicsDifferential (mechanical device)Measurement
12:33
DisintegrationComputer simulationVelocityPosition operatorBitComputer simulationRight anglePoint (geometry)Derivation (linguistics)State of matterFunctional (mathematics)Multiplication signLecture/Conference
13:16
Euler methodIntegerNichtlineares GleichungssystemArithmetic meanFrequencyFinitismusMultiplicationMultiplication signPoint (geometry)CASE <Informatik>Limit (category theory)SoftwareIntegerComputerSubject indexingMeta elementLoop (music)MathematicianVirtual machineSpreadsheetEuler methodComputer animation
15:01
VelocityPosition operatorPrice indexLogical constantTendonLink (knot theory)Optical disc drivePosition operatorVelocityMultiplication sign2 (number)Execution unitSoftwareParabolaWell-formed formulaoutputShape (magazine)SpacetimePlotterBitCurveTrailLine (geometry)Subject indexingFrequencyLogical constantMetreMoment (mathematics)INTEGRALMathematicsSign (mathematics)Time evolutionRight angleIntegraltafelPoint (geometry)Computer animation
19:41
Euler methodUsabilityIntegerBuildingBlock (periodic table)Auto mechanicArithmetic meanBlock (periodic table)BuildingMechanism designNichtlineares GleichungssystemQuicksortRoboticsComputerLecture/Conference
20:19
Auto mechanicBlock (periodic table)BuildingWeightSpring (hydrology)Mechanism designRevision controlMassCue sportsComputer simulationSpring (hydrology)BitModel theoryMultiplication signForcing (mathematics)Stiff equationSound effectoutputVelocityNichtlineares GleichungssystemRoboticsDampingRotationWeightPhysical law2 (number)Lecture/ConferenceMeeting/Interview
22:14
VelocityPrice indexPosition operatorSpring (hydrology)MassSpring (hydrology)GravitationMusical ensembleComputer animation
22:48
WeightSpring (hydrology)LaceAuto mechanicBuildingBlock (periodic table)Price indexPosition operatorVelocityForcing (mathematics)Euclidean vectorBitGravitationPhysical systemSpring (hydrology)Multiplication signSet (mathematics)MetreRandomizationParameter (computer programming)MassStiff equationLecture/ConferenceComputer animation
24:10
WeightSpring (hydrology)Auto mechanicBuildingBlock (periodic table)Position operatorVelocityLogical constantPrice indexIRIS-TSpring (hydrology)Square numberMassMultiplication sign2 (number)MetreSign (mathematics)QuicksortLecture/ConferenceComputer animation
24:45
WeightBuildingAuto mechanicBlock (periodic table)Spring (hydrology)Position operatorPrice indexVelocityThermodynamic equilibriumPosition operatorMultiplication signBitMathematicsDifferential equationPhysicalismLecture/ConferenceComputer animation
25:18
Position operatorPrice indexVelocitySpring (hydrology)Logical constantMassFrequencyModel theorySpreadsheetAuto mechanicBlock (periodic table)BuildingModel theoryComputerMechanism designMultiplication signComputer simulationError messageSpring (hydrology)Position operatorMass2 (number)Complex (psychology)BitInfinityDifferential equationTheoryFeedbackSound effectOscillationMessage passingCalculationVelocityEuler methodSlide ruleINTEGRALRight angleComputer animation
29:35
Position operatorPrice indexOnline helpSlide ruleNichtlineares GleichungssystemSound effectCASE <Informatik>WebsiteComputer animation
30:17
Menu (computing)Online helpBlock (periodic table)BuildingDiagramModel theoryLogical constantFrequencyComplex (psychology)Nichtlineares GleichungssystemVisualization (computer graphics)WebsiteRight anglePhysical systemEstimatorPoint (geometry)2 (number)Block (periodic table)Multiplication signBlock diagramError messageComputer animation
31:17
DiagramBlock (periodic table)Model theoryLogical constantFrequencyComplex (psychology)Nichtlineares GleichungssystemVisualization (computer graphics)Block diagramBitMeasurementPhysicalismTrailBlock (periodic table)Model theoryPhysical systemOrdinary differential equationOpen setGoodness of fitEngineering drawingDiagram
32:12
DiagramBlock (periodic table)Model theoryLogical constantFrequencyComplex (psychology)Nichtlineares GleichungssystemVisualization (computer graphics)Nichtlineares GleichungssystemImage resolutionDifferential equationRecurrence relationTrailVariable (mathematics)Visualization (computer graphics)Multiplication signSoftwareEngineering drawingDiagram
33:00
Representation (politics)Model theoryNichtlineares GleichungssystemDifferential (mechanical device)Numerical analysisEuler methodRückwärtsdifferentiationsmethodeSimultaneous localization and mappingMacro (computer science)ModemMenu (computing)Commercial Orbital Transportation ServicesMessage passingJava appletMultiplication signGraphical user interfaceFreewareSoftwareOpen setFormal languageComputer programmingModel theoryComputer animation
33:41
Electric currentComputer fileVariable (mathematics)Stack (abstract data type)Thread (computing)MathematicsQuadrilateralLine (geometry)SynchronizationThetafunktionComputer-generated imageryControl flowMultitier architectureAlpha (investment)Computer simulationCodeThread (computing)Visualization (computer graphics)State of matterReal-time operating systemQuicksortLoop (music)HoaxThetafunktionINTEGRALMereologyMultiplication signGame controllerPoint (geometry)Sign (mathematics)CASE <Informatik>Equaliser (mathematics)BitSound effectLine (geometry)Revision controlSocial classDifferent (Kate Ryan album)Positional notationMoment <Mathematik>Euler methodFunctional (mathematics)Source code
35:43
NumberMultiplication signMusical ensemble
36:18
NumberCodeComputer fileDrop (liquid)Link (knot theory)Drag (physics)Planning1 (number)Lecture/ConferenceMeeting/Interview
37:05
Peg solitaireStiff equationSpring (hydrology)Model theoryMassFrequencyDivisorDrag (physics)Drop (liquid)Roundness (object)InternetworkingGoodness of fitComputer animationLecture/Conference
37:47
Semiconductor memoryCartesian closed categoryMusical ensembleDiagram
Transcript: English(auto-generated)
00:19
This talk will be modeling and simulation of physical systems for hobbyists.
00:25
Manuel Eipel wanted to lower the threshold entry, entry thresholds for the subject. And so explaining modeling and simulation techniques that help even small projects for makers and hobbyists.
00:41
So please welcome Manuel for the talk about modeling and simulation of physical systems for hobbyists. Thank you for the kind introduction, and welcome everybody. Actually, I forgot to say that all examples that I will show in this talk
01:03
can be downloaded on the website of the talk. So if you want to try it out already right now, while I'm actually going to show the examples, you can do so. So let's get started by taking about this title a little bit
01:24
to see what is meant by the individual words. And by this, I have a rough outline of what we're going to talk about. So first, modeling in this context means to create
01:41
a mathematical description of a system. So we look at the physics of, for example, a robot that we want to build, or a mechanism. Then we extract the different physical effects, look at the equations that are represented in these effects,
02:05
put it all together, and then we obtain a mathematical description. And simulation then means that once we have this system, this model, we are going to use the computer to perform calculations
02:22
from one time step to the next. So to basically extrapolate from an initial state of the system to how the behaviour is going to be in time. In this talk, I want to talk about physical systems,
02:40
so hardware that we can create, and not some sort of fictional physics for computer games or something, but really something like a mobile robot, a small drone, or similar, that, yes, as a maker, you want to create.
03:02
And I'm addressing this talk to hobbyists. I don't want to reduce the knowledge and competence of hobbyists, but only say by this that the resources that we're going to use in this talk
03:23
are all commonly available tools and not simulation software that you have to buy for tens of thousands of euros. And I'm not exaggerating about it. So, maybe a quick round. Who did math courses at university level?
03:43
Okay, yes, that's quite a lot. So, actually, I prepared the talk to address it to everybody who had 10th grade school math. So, it might be a bit familiar to you already,
04:01
but then you can help your neighbours who have difficulties. So let's get started. What's the motivation behind doing simulation? Why do we want to simulate something? So imagine with your friend you want to build a small self-managing robot like this.
04:23
So it's a very easy design, two wheels left and right, which have one motor, each wheel has one motor. And then there's a rod going up with a camera fixed on top so that you actually have a higher point of view so that you see something.
04:43
And this is actually an inverted pendulum, so if you build it like this without a controller, it will just fall over. But, yes, it's quite easy to implement, at least hardware-wise.
05:02
So, you want to build this with your friend, and you say, okay, I'm good at programming, but I am not so good with the mechanical aspects. So your friend says, okay, no problem, I will build the hardware. But then you're stuck, okay, you don't have the hardware yet, so how do you want to develop the software if you don't have the hardware?
05:24
And this is where simulation can help, for example. So, in the time that your friend is building the hardware, you can already start the software, you just have your simulator,
05:40
you recreate the hardware while it's absent, and then you can program your controller, everything that you want, and once the hardware is ready, you keep the controller, you throw away the simulator, and ideally, then the system is complete.
06:03
So I built a small simulator for this example in Python. You can also download the code. So you see here, the simulation is already running, but it's perfectly balanced, so it's not dropping yet, but if I push it a little bit from the side, it will tip over,
06:21
because I didn't activate the controller yet, so it's like if you have your robot without power, if you push it a little bit, it will tip over. So now I can activate the controller and then push it a little bit, and then you see that the controller will actually bring it back. So the controller is the part that you will implement in software,
06:42
and the hardware is basically this part, the tipping over part is the hardware that your friend will build, and let's see, I can even make it drive around, just as one example of what you can simulate with the method that we're going to see.
07:05
Okay, the problem is I don't have that much time, so we're not going to go all the way. I will start with the very basic models,
07:21
and then we see how far we go. So, to summarise the motivation, simulation can be used as a placeholder, so while the hardware is built, you have the simulator and then you exchange it, or it can be used as a virtual test bench, for example, for scenarios where you don't necessarily want the real hardware
07:46
because it's risky behaviour and it can be damaged. Okay, now, one step back, modelling, what is it, and what are the basic formations?
08:01
So imagine our friend Newton here under his apple tree, and now we cut the apple loose, and we ask ourselves, okay, what's going to happen? We can look at that at different levels of detail, like from a very simple level to a very detailed level. At the simple level, you can say, okay, the apple moves down,
08:21
so you see on the plot the line just goes down, constant velocity. Then, well, this is an observation that you can make very easily just by looking at it. You don't need to measure anything. Then, at the more detailed level, you see that, if you make a more precise measurement,
08:42
actually, your apple is accelerating, so you have this parabolic curve. Because of the gravitation, the apple becomes faster and faster. And then, if you go at an even more detailed level, you notice that there is actually aerodynamic drag,
09:02
so it won't accelerate infinitely, but it will eventually reach a saturation velocity. This is, for example, when a skydiver is falling from the sky. Yeah, then you clearly notice this effect over a longer period.
09:23
So the take-home message that I want to show with this slide is that, actually, depending on the question that you want to look at with your modelling and your simulation, you should choose an appropriate level of detail,
09:42
so as simple as possible and as detailed as necessary. And this might actually change for the same system, so at one point in time, you might be interested in this starting behaviour, so you need the acceleration, and at another point in your project, you might be interested only at what happens here at saturation velocity.
10:08
Okay, now we go one step further back in the mathematical methods, so differentiation and integration, because this is very essential,
10:22
many physical measures are linked to each other through differentiation or integration. For example, if you take the position x, velocity v and acceleration a, then if you differentiate x, you get velocity v,
10:41
and if you differentiate that again, then you get the acceleration a, and the other way around, by integration, then you obtain velocity again and the position. So you might remember this equation from school for calculating the derivative. So, basically, the derivative is defined as the ratio of the function you want to differentiate
11:09
at two points in time, point t plus h and t, so the difference of this divided by the distance in time, so the h.
11:24
And if you then have this corner case where h goes towards zero, you actually obtain the derivative at the point t, so in this case, the velocity at the point t. Now, if you take this equation and you modify it a little bit,
11:43
so you multiply by h and you add the x of t, then you obtain this equation, which is one way of calculating the integration, so x in this case at the point t plus h in time, so you see that it depends on the x of t,
12:06
so a little bit earlier in time, and it also depends on the velocity, so the derivative of x, a bit earlier in time, multiplied by h. And again, if you take this corner case where h goes towards zero,
12:25
then you obtain x of t plus h. So this means, actually, by integrating, we can look a tiny little bit into the future because the derivative is always running ahead in time
12:42
of the function that was differentiated. If you integrate it backwards, you can look a bit into the future, and that's exactly what we want to do in simulated animation, right? We want to say, okay, we have an initial state at point t,
13:03
and then we're interested to know what happens at point t plus a little bit. So, in the following, we're always going to integrate for the simulation and not differentiate. The only problem now, this corner case definition,
13:21
that's nice for mathematicians, but it's not really useful for computations. We cannot write this in software. So what we're going to do is we're going to use the so-called Euler method, and this simply means that we replace this corner case limit of h
13:41
going towards zero of h by a finite value ts, which is often called the sampling period. So finite means we just take a small but defined value and not this limit thingy.
14:01
And then, with ts, we're actually only going to calculate the points in time at integer multiples of ts. So we call k the index, and then we calculate the points in time
14:22
at t equals k times ts. So this is discretisation. And, yes, so we transform this equation into this one. We do it by ts, and we obtain this nice equation,
14:41
which is x of k plus one equals x of k plus v of k times ts. So this is something that we can easily implement in software. We just have a for loop, and every time we do that. Any questions? So I'm going to show you a simple example in spreadsheet,
15:05
just to show that, well, it's pretty independent of what software you use. So let's define some constants here on the left side. We take a sampling period of one millisecond.
15:23
Let's put the unit here so we have it in seconds. Then we have the index here, we call it k. We have the time here, we call it t. And we're interested in the position, we call it x, and in the velocity, we call it v.
15:40
So, and now every line here will be one point in time. So we begin at time zero, and everything is zero. Like this. Let's get a bit more space here. Okay, so now we have this formula. So we need a k plus one, that's not a problem.
16:03
We just say, okay, the next k is equal to the previous k plus one. And the time, oh, no, I covered this formula. The time we say is equal to this index k times the sampling period.
16:23
So we use these dollar signs so it doesn't change if we copy paste it. And then we have the integration formula, so the x is the previous x times the previous v, times the previous velocity, again, multiplied by the sampling period.
16:43
Like this. Again, with the dollar signs. And now, okay, it would be boring if the velocity is zero all the time, so let's put a velocity of 0.5 metres per second, for example. And now we want the next moment in time,
17:03
so we just do the same operation over and over again. So I just copy paste the lines, and this is now the time evolution. For example, I can now plot position over time.
17:21
I just add this plot. I tell it to take the time on the x-axis and take the position on the y-axis. Okay. Insert it here. All right. So, yes, it's not very exciting, but it's exactly what we expect
17:44
if we integrate a constant over time. So we just obtain a straight curve. So let's add the acceleration now.
18:01
We call it a. Okay, we start the acceleration from the beginning, like this, and now what we do is we actually use the same formula that we used for the position, so this one. We also use it for the velocity.
18:21
We copy paste it, and then we can copy this line, and now, if we want, we can repeat this a bit longer.
18:41
Okay. So you see now we have a constant acceleration. We integrate two times, so we get the position as a parabola shape like this. Actually, I could have added a negative acceleration just to have the drop from before. So this is already quite useful.
19:00
If we now say that the acceleration input is not a constant, but, for example, we have the acceleration input from a sensor, from an acceleration sensor, then just by using this method which doesn't rely on any knowledge of the shape of the acceleration,
19:25
so we can just give it random input, and it will always integrate it. So if we have the sensor input from the accelerometer, and we integrate it twice, then we can keep track of our position. Okay, but now we want to model something,
19:42
so we don't have an accelerometer yet, so where do we get the acceleration from? Okay, one warning, always keep the sampling period small. We're going to discuss later on what small means. Okay, so some building blocks.
20:01
I can obviously not summarise all physical equations that exist, but I will show some mechanics and electromechanics that are useful, like for mobile robots, if you have a motor turning something with gears maybe, and then a sort of lever mechanism, for example.
20:23
So we start from the simplest version, so a moving mass, just imagine a billiard ball, for example, which has a mass m and a velocity v, and now if we want to change this movement, we need a force f.
20:43
Again, this is our friend Newton telling us that, and this is the second law of motion, so the force that we need is proportional to the mass times the acceleration. Okay, I need to accelerate a little bit as well, because time is running out.
21:04
So, yeah, actually I have the same equation that you have for linear motions, you also have for rotational motions, which is the right side, and then you can also have the weight, so this is what we had in the Apple example,
21:23
so the force from the weight is just the mass times the rotational constant, and other effects that you can have are, for example, spring force and viscous damping. These two are actually not only useful if you truly have a spring damper mechanism,
21:44
like you would have a suspension, for example, but it's also useful if you, for example, want to model a heart contact. Like, yeah, I had in the beginning, in the simulation example,
22:01
the robot tipping over and falling on the ground, so you just put the stiffness quite high and the damping as well, and you will obtain this effect of a contact. So let's see if we now combine this.
22:21
For example, we want to have, just for the sake of the example, a small mass spring damper, so we put the gravitation here, we put the spring here, and the damper here.
22:42
Yeah, damper. And what I didn't say here is that this F is not necessarily one force, but it's the resultant force, so this is actually a vector addition. So you take all forces together,
23:01
and then this is the F which drives your acceleration. So this is what I'm going to do here. Okay, some from here to there. And then I need some constants, so for the gravitation I need the mass, so let's say two kilos.
23:22
It's a bit heavy, but okay, let's make it half a kilo. And then let's say the spring stiffness, we just put 100 Newton per meter. And the damper, let's put 10. So of course this setting of the parameters,
23:46
now I do a bit random, but ideally you would look at your system when you design it and then calculate these values so that they correspond to what you are actually building. Now I just make a simple example so I pick them at random.
24:06
Okay, so then we have the gravitation. We said gravitation was, if we look here, m times g. Okay, so I also need the g. So that's the well-known 9.81 meter per second square.
24:26
So that's the mass, yeah, the mass times this. We again add the dollar signs.
24:41
And then we have the spring, so the spring is, I set the x zero at zero, so the x zero is the equilibrium position. So we had minus, okay, times position.
25:04
And now what you see here, what I didn't say, but if you know a little bit about physics and math, you would see that this is actually a differential equation that we're going to solve here. But, yeah, you don't need to worry too much right now
25:21
because the new method is taking care of that. So we also need the damping here times velocity.
25:50
And now I'm just going to copy it all the way down so that I have like 60 seconds.
26:01
It takes a bit longer because, yeah, it's a lot. Okay, and actually what you see here is that what I said before
26:20
about the sampling period was a problem right now because we're actually doing an error in the method in the integration. So normally, because we have this feedback loop
26:42
in the differential equation, it's not a problem because if there is an error, then it will be compensated in the feedback loop. But if the sampling period is too big, then this error is actually, yeah, multiplied and then you get this instability behavior.
27:03
So I can also show it with a bit bigger effect. Like if I take only one hundredth of a second, then you see here if you look at the values, it's actually going to infinity. So my simulation is not robust.
27:21
And this means that the sampling period is just too big and the simulation is becoming unstable. So now I picked a smaller value, which of course is a problem because now I'm only simulating six seconds
27:42
instead of 60, but you see that here is a trade-off to make between model complexity and precision, which means more computation resources are needed and the robustness of the simulation.
28:12
Sorry? Okay, so the question was whether this was a resignation.
28:29
Yeah, right. But, in theory, this, okay, maybe I made an error in my calculations. Let me show you the one that I prepared.
28:47
Okay, I'm just going to take the one where I prepared it properly because obviously I made an error in the calculations. So this is the effect that you are expecting, right?
29:04
So you start at a certain position, then you have an oscillation through the spring, which is bringing back the mass, wants to bring back the mass to the centre, and then you have a damping, so it slowly fades out.
29:22
Okay, actually, I'm also running out of time. I wanted to also treat some electric principles and electromechanics to show an electric motor. I can quickly show it to you in the slides.
29:45
So the nice thing of the electric motor example is that it shows how to solve problems and that's why you actually have two equations which are entangled with each other. And you can also see in this example
30:04
the effect of taking into account one physical principle or ignoring it, in this case, the effect of the coil. So, as I said, you can download it from the website
30:20
and then have a look at it, if you're interested. Right, so this brings me already to the end of the talk. Just some tips and tricks to summarize. So, as I said, the sampling period needs to be small. As a rough estimate, I usually take around 100 times faster
30:43
than the system time constant. So for a mechanical system, usually one millisecond is okay. I don't know why now. Well, I had an error before. But one millisecond usually works fine. If you have the electric motor with the coil,
31:01
then you need to reduce the sampling period maybe to 10 microseconds or even less. It depends on the system time constant, as I said. Then, as a second point, use block diagrams. So this is what I mean by block diagrams.
31:21
It helps you to keep track of which physical measures influence which other physical measures. Well, it's a bit difficult to read maybe in the beginning, but you get used to it, and then it's really useful.
31:40
And then, if you want to be sure about what you're doing or you're having more complex models, maybe use some specialised tools, for example SciPy, which has a good ordinary differential equation solver, or Open Modelica with OM Edit, where you can basically just compose your system as you find it.
32:02
You just add a block for the spring, you add another block for the damper, and then it takes care of that. Or SciLab with XCoS, where basically you use this block diagram method to define your equations instead of writing them down.
32:21
And so, as I said, they have better differential equation solving. They're also more efficient because often they use variable time step. So they see, okay, when it's critical to reduce the sampling period and when it's less critical. And also very helpful are the data logging and visualisation tools
32:46
that come with the software, otherwise it sometimes really cumbersome to track, to keep track of all your variables and then plot them nicely.
33:02
Okay, so, actually, I think I accelerated that much, but I still have some time, so I can maybe show you how this works in OM Edit, which is also free software. And it's basically a graphical tool to use Open Modelica.
33:23
And Open Modelica itself is a modelling, programming, well, let's say definition language. Okay, something is not working because it's not starting as it should.
33:41
Okay, then I can show you the Python code of the simulator that I showed in the beginning, so this one. So what I did here was to define two classes just to have them run in different threads, one thread for the simulation
34:01
and another one for the visualisation. And actually the simulation part is pretty simple and then the visualisation part takes more lines of code. So you see here that there's a reset function where you just define the initial state and then if you look at the simulation part itself,
34:24
you find again what we had before. So there's a simulation loop here. I do a busy idle just to, well, here's the busy idle, just to have a sort of fake real-time. And then here you see the Euler method integration.
34:44
So in this case, it's just a bit contracted with the plus equal notation, but basically it means theta equals theta plus omega times the sampling period. And then once more for the rotational speed.
35:08
Then the different torque effects, so in this case that's the rotational version and not the linear version. And then at some point there's the controller.
35:22
I didn't separate it nicely in this example, but usually you should. And the same again for the linear motions. So I got the sign that time is up, and I would be happy to take some questions. Yeah, time is up, but we're not letting you go yet.
35:49
Because we do have time for questions. Out in the room there are microphones. Please, if you have any questions, stand behind one of the microphones and I will call out the microphone number and you can ask a question.
36:12
Please don't be shy. It seems like there are a lot of you that are quite knowledgeable about the subject. You can stand up behind the microphones. We have a question from microphone number four.
36:23
Yes, hello, and thanks for the talk. I would like to ask if you have the code somewhere available. Yes, as I said, all the examples that I showed are on the side of the talk itself. So if you go in the file plan,
36:41
then there are links to where you can download these files. Are there any other examples on Landsomware? Not from me. I mean, there are probably millions of examples, but for this talk I just created these ones.
37:01
I just have one more for the drop of drag, which you also find. But, yes, so this is drop of drag. So this is your chance if you want to ask any questions
37:22
and share the answer to your question with the rest of us. Please get up to one of the microphones. Are there any questions from the internet? There is no signal from the signal angels. Is there a question from the internet?
37:42
Good, well, let's give Manuel a big round of applause. Thank you for his talk.
Recommendations
Series of 24 media