Software-in-the-Loop (SIL) simulation — all software, simulated hardware: Worked examples

5.5.22 · D3 · Coding › Embedded Systems & Real-Time Software › Software-in-the-Loop (SIL) simulation — all software, simula

Shuru karne se pehle, ek promise: har symbol use se pehle earn kiya jaata hai. Yeh hain sirf ingredients, ek baar define kiye gaye:

Definition Hamari vocabulary (ek baar define karo, har jagah reuse karo)

$n$ — tick counter: ek seedha whole number $0, 1, 2, 3, \dots$ jo label karta hai ki hum kaunse controller step par hain. Tick $n = 0$ start hai, $n = 1$ ek $Δ t$ baad hai, aur aise hi aage. Koi bhi symbol jis par chhota subscript $n$ ho (jaise $v_{n}$ ya $u_{n}$ ) ka matlab hai "us cheez ki value tick $n$ par". Toh $v_{0}$ pehle tick par speed hai, $v_{1}$ ek tick baad ki speed hai.
$v$ — motor ki speed. Socho "wheel kitna fast spin karta hai", revolutions per second (rev/s) mein measure kiya jaata hai. Plant model is number ko track karta hai.
$v_{ref}$ — target speed jo hum chahte hain. Controller ka poora kaam hai $v$ ko $v_{ref}$ ke paas laana.
$e = v_{ref} - v$ — error. Literally "hum kitna off hain?" Agar $e > 0$ toh hum bahut slow hain; agar $e < 0$ toh bahut fast hain; agar $e = 0$ toh perfect hain.
$u$ — control command jo software bhejta hai (ek PWM duty, ek number jo code har tick compute karta hai).
$Δ t$ — time step: do controller ticks ke beech kitne seconds guzarte hain. Agar controller 100 Hz par run karta hai toh $Δ t = 1/100 = 0.01$ s.
$K$ — gain: ek fixed dial software ke andar jo kehta hai "error ke har unit ke liye, itna hard push karo". Bada $K$ = aggressive; chhota $K$ = gentle. Yeh sirf controller mein hota hai, plant mein kabhi nahi.
$τ$ (Greek "tau") — plant ka time constant: physical motor kitna sluggish hai. Bada $τ$ matlab react karne mein bahut time lagta hai.

Formula Woh do equations jinhe hum poori page simulate karte rahenge

Controller (software under test): $u_{n} = K (v_{ref} - v_{n}) = K e_{n}$ Subscript ko zor se padho: "command $u$ tick $n$ par equals gain times error tick $n$ par". Yeh ek proportional controller hai — output, error ke proportional hai. Hum proportional use karte hain (integral ya derivative nahi) kyunki yeh sabse simple tool hai jo "kis direction mein aur kitna hard push karun?" ka jawab deta hai aur yeh neeche har case expose karne ke liye kaafi hai.

Plant (simulated motor), Euler method se discretise kiya gaya: $v_{n + 1} = v_{n} + (u_{n} - v_{n}) \frac{Δ t}{τ}$ Yahan $v_{n + 1}$ ka matlab hai "agले tick par speed" — hum ise is tick ki speed $v_{n}$ mein ek chhoti change add karke banate hain. Yahan $K$ kyun nahi? $K$ controller ka dial hai aur sirf upar controller equation mein appear karta hai. Plant ek plain first-order lag hai: uski rate of change hai "(command $u_{n}$ ) minus (current speed $v_{n}$ )", scaled by kitna sluggish hai ( $Δ t / τ$ ). $K$ ko dono equations mein daalna secretly gain ko square kar dega — ek classic bug. Use ek jagah rakho.

Euler kyun? Euler sabse plain rule hai "ek continuous cheez ko ek tick aage step karo": new value = old value + rate × time step. Hum ise precisely isliye choose karte hain kyunki iska failure mode (blow up karna jab $Δ t$ bahut bada ho) ek case hai jo hume dikhana zaroor hai — Example 5 dekho.

Scenario matrix

Har SIL simulation jo tum kabhi run karoge woh in cells mein se ek mein aata hai. Neeche ke examples cell ke saath labelled hain jo woh cover karte hain.

Cell	Case class	Kya special banata hai	Covered by
A	Nominal, $e > 0$ (bahut slow)	Happy path: upar converge karna	Example 1
B	Sign flip, $e < 0$ (bahut fast)	Command negative jaani chahiye	Example 2
C	Zero input, $e = 0$	Degenerate: kuch nahi hilna chahiye	Example 3
D	Degenerate hardware model ( $τ \to 0$ )	Instant plant — limiting behaviour	Example 4
E	Numerical instability ( $Δ t$ bahut bada)	Solver diverge karta hai — ek simulation bug, code bug nahi	Example 5
F	Real-world word problem	Braking-distance stopping question	Example 6
G	Exam-style twist	"SIL pass hua lekin hardware fail hua" — abstraction error	Example 7

Running examples ke liye (jab tak koi cell override na kare) hum fix karte hain: $K = 0.5$ , $τ = 0.2$ s, $Δ t = 0.01$ s.

Figure s01 — closed SIL loop. Layout ka sketch: left par ek lavender rounded box jis par likha hai "Software under test — $u_{n} = K (v_{ref} - v_{n})$ ", aur right par ek mint rounded box jis par likha hai "Simulated plant — $v_{n + 1} = v_{n} + (u_{n} - v_{n}) Δ t / τ$ ". Ek coral arrow right ki taraf point karta hai software se plant ki taraf "command $u_{n}$ " carry karte hue; ek lavender arrow neeche loop karta hai, left ki taraf plant se software ki taraf point karta hua "sensed speed $v_{n}$ " carry karte hue. Ek chhota butter-coloured arrow software box mein upar se drop karta hai, " $v_{ref}$ = target enters here" mark kiya hua. Neeche caption padhta hai: software kabhi nahi jaanta ki plant fake hai — woh bas $v_{n}$ read karta hai. Jab tum har example padho, trace karo ki numbers kis arrow se travel karti hain.

Figure — Software-in-the-Loop (SIL) simulation — all software, simulated hardware

Example 1 — Cell A: nominal, motor bahut slow hai

Step 1 — Error $e_{0}$ compute karo. $e_{0} = v_{ref} - v_{0} = 10 - 0 = 10$ Yeh step kyun? Controller tab tak act nahi kar sakta jab tak woh jaane "kitna off hai". Error software ka single input hai.

Step 2 — Controller command $u_{0}$ compute karta hai. $u_{0} = K e_{0} = 0.5 \times 10 = 5$ Yeh step kyun? Yeh literally production code ki woh line hai jo test ho rahi hai: u = K * (v_ref - v). Positive error → positive push. Sahi hai.

Step 3 — Plant ek Euler step aage badhta hai. $v_{1} = v_{0} + (u_{0} - v_{0}) \frac{Δ t}{τ} = 0 + (5 - 0) \frac{0.01}{0.2} = 5 \times 0.05 = 0.25$ Yeh step kyun? Yeh simulated hardware react kar raha hai. Plant command $u_{0}$ directly use karta hai (extra $K$ nahi) — dhyan karo software kabhi yeh equation nahi dekhta, woh sirf resulting $v_{1}$ next tick par dekhta hai. Yahi "in-the-loop" feedback hai.

Answer: $v_{1} = 0.25$ rev/s.

Recall Kya tumhara forecast sahi tha?

Yeh sirf $0.25$ se upar jata hai, 10 ke paas nahi ::: Sahi — chhote $Δ t$ ke saath Euler gently nudge karta hai; convergence mein bahut saare ticks lagte hain, isliye hum simulate karte hain instead of eyeball karne ke.

Verify: Sign check — motor bahut slow tha ( $e > 0$ ), aur $v$ increase hua ( $0 \to 0.25$ ). Units check: $(u_{0} - v_{0})$ rev/s mein hai, $Δ t / τ$ dimensionless hai (s/s), toh increment rev/s hai. ✓

Example 2 — Cell B: sign flip, motor bahut fast hai

Step 1 — Error ab negative hai. $e_{0} = 10 - 20 = - 10$ Yeh step kyun? Hume reader ko woh case dikhana hai jahan input ka sign flip hota hai — parent contract demand karta hai har sign. Negative error matlab "bahut fast".

Step 2 — Command sign flip karta hai. $u_{0} = 0.5 \times (- 10) = - 5$ Yeh step kyun? Ek sahi proportional controller automatically apna push reverse karta hai. Agar tumhare code mein koi abs() ya unsigned type bug hota, SIL use yahin pakad leta — sim accelerate karta rehta braking ke bajaaye.

Step 3 — Plant step. $v_{1} = 20 + (u_{0} - v_{0}) \frac{Δ t}{τ} = 20 + (- 5 - 20) (0.05) = 20 + (- 25) (0.05) = 20 - 1.25 = 18.75$ Yeh step kyun? Negative command $v$ ko neeche drag karta hai. Target ki taraf motion confirm hua.

Answer: $u_{0} = - 5$ , $v_{1} = 18.75$ rev/s.

Verify: Symmetry sanity check Example 1 ke against — Ex 1 mein error $+ 10$ tha; yahan $- 10$ hai, toh command exactly negate hua ( $+ 5$ vs $- 5$ ). ✓ Aur $v$ decrease hua, "bahut fast" ke liye sahi. ✓

Example 3 — Cell C: zero / degenerate input

Step 1 — Error zero hai. $e_{0} = 10 - 10 = 0$ Yeh step kyun? Degenerate input woh hai jahan do inputs cancel hote hain. Hume confirm karna hai ki software exactly $0$ form karta hai yahan — ek subtraction bug ya floating-point residue ek tiny nonzero error ke roop mein dikhega, aur yahi jagah hum use pakdenge.

Step 2 — Command zero hai. $u_{0} = 0.5 \times 0 = 0$ Yeh step kyun? Zero error matlab zero push hona chahiye. Yeh degenerate input hai jo har controller ko handle karna chahiye. Ek divide-by-error bug ya NaN yahan surface hoga.

Step 3 — Plant step. $v_{1} = 10 + (u_{0} - v_{0}) \frac{Δ t}{τ} = 10 + (0 - 10) (0.05) = 10 + (- 10) (0.05) = 10 - 0.5 = 9.5$ Yeh step kyun? Hum plant ko advance karte hain even though command zero hai, precisely yeh reveal karne ke liye ki "no command" ka matlab no motion nahi hai — $- v_{n}$ drag term phir bhi act karta hai. Yahi example ka poora point hai, isliye hum step run karte hain instead of assume karne ke ki kuch nahi hota.

Answer: $v_{1} = 9.5$ rev/s (yeh target se neeche drift karta hai).

Verify: True equilibrium plug karo: $v$ stay karne ke liye humein chahiye $u - v = 0$ with $u = K e = K (v_{ref} - v)$ , i.e. $K (v_{ref} - v) = v$ . Solve karne par: $v_{e q} = \frac{K v _{ref}}{1 + K} = \frac{0.5 \times 10}{1.5} = \frac{10}{3} \approx 3.33$ . Toh loop $10/3$ par settle hota hai, 10 par nahi — offset confirm karta hai. ✓

Example 4 — Cell D: degenerate hardware, $τ \to 0$ (instant motor)

Step 1 — Ratio inspect karo. $\frac{Δ t}{τ} = \frac{0.01}{τ}$ Jaise $τ \to 0$ , yeh ratio $\to \infty$ ho jaata hai. Yeh step kyun? Poora update $Δ t / τ$ se scale hota hai. Ek limiting input ko symbolically inspect karna chahiye, sirf numerically nahi.

Step 2 — Command restate karo, phir ek concrete chhota $τ = 0.005$ lo. Pehle controller output exactly waise hi recompute karo jaise Example 1 mein, kyunki hum same state se start karte hain: $e_{0} = v_{ref} - v_{0} = 10 - 0 = 10, u_{0} = K e_{0} = 0.5 \times 10 = 5$ Ab shrunken time constant ke saath ek plant step run karo: $\frac{Δ t}{τ} = \frac{0.01}{0.005} = 2, v_{1} = v_{0} + (u_{0} - v_{0}) \frac{Δ t}{τ} = 0 + (5 - 0) (2) = 10$ Yeh step kyun? Hume dikhana chahiye, assume nahi karna, ki $u_{0} = 5$ kahan se aata hai — yahi controller line $u_{0} = K (v_{ref} - v_{0})$ hai Example 1 se. Ek concrete degenerate value phir danger dikhata hai explode hone se pehle: ek step already target tak jump kar deta hai aur true continuous answer ko overshoot kar dega.

Step 3 — Failure mode pehchano. Jab $Δ t / τ > 1$ hota hai, ek Euler step true continuous answer ko overshoot karta hai, aur jab yeh 2 tak pahunchta hai simulation oscillating aur blow up karne ki edge par hoti hai. Ek "faster" (chhota $τ$ ) motor ko accurate rehne ke liye chhota $Δ t$ chahiye.

Answer: Jaise $τ \to 0$ , discrete plant unstable ho jaata hai unless $Δ t$ sath mein shrink ho; "instant motor" ek degenerate model hai jise SIL time step refine kiye bina faithfully simulate nahi kar sakta.

Verify: Euler ki stability for $v_{n + 1} = v_{n} (1 - Δ t / τ) + \dots$ require karti hai $∣1 - Δ t / τ ∣ < 1$ , i.e. $Δ t / τ < 2$ . $τ = 0.005$ par: $Δ t / τ = 2$ — exactly unstable boundary par. ✓

Example 5 — Cell E: numerical instability, ek simulation bug nahi code bug

Step 1 — Growth factor compute karo. $\frac{Δ t}{τ} = \frac{0.5}{0.2} = 2.5 (> 2!)$ Yeh step kyun? Example 4 se hum jaante hain $> 2$ matlab unstable hai. Hum deliberately cliff ke past hain, toh hum expect karte hain agale steps diverge karein.

Step 2 — Tick 1. $v_{1} = 0 + (u - v_{0}) \frac{Δ t}{τ} = 0 + (5 - 0) (2.5) = 12.5$ Yeh step kyun? Hum oversized ratio ke saath pehla Euler step lete hain yeh dekhne ke liye ki ek single update kitna badly overshoot karta hai — $12.5$ already sensible resting value se blast off ho jaata hai.

Step 3 — Tick 2. $v_{2} = 12.5 + (5 - 12.5) (2.5) = 12.5 + (- 7.5) (2.5) = 12.5 - 18.75 = - 6.25$ Yeh step kyun? Overshot $v_{1}$ ko back feed karte hain. Kyunki usne overshoot kiya, correction term sign flip karta hai aur over-correct karta hai, $v$ ko negative fling karta hai. Yeh dikhata hai ki divergence bad step size ka ek feedback effect hai, one-off nahi.

Step 4 — Tick 3. $v_{3} = - 6.25 + (5 - (- 6.25)) (2.5) = - 6.25 + (11.25) (2.5) = - 6.25 + 28.125 = 21.875$ Yeh step kyun? Ek baar aur repeat karne par dikhta hai ki swing growing hai ( $12.5 \to - 6.25 \to 21.875$ ), settle nahi ho raha. Teen ticks minimum hain yeh prove karne ke liye ki amplitude increase ho rahi hai instead of lucky bounce ke.

Figure s02 — stable vs unstable Euler. Layout ka sketch: ek set of axes, horizontal axis "tick number $n$ ", vertical axis "simulated speed $v_{n}$ (rev/s)". Ek mint curve with round markers smoothly climb karti hai aur 5 ke paas level off hoti hai — yeh safe run hai ( $Δ t = 0.01$ , ratio $0.05$ ). Ek coral curve with square markers violently zig-zag karti hai: uske points $12.5$ par hain (tick 1), phir $- 6.25$ (tick 2), phir $21.875$ (tick 3), har swing pehle se bada — yeh divergent run hai ( $Δ t = 0.5$ , ratio $2.5$ ) jo humne abhi haath se compute kiya. Ek legend "stable" (mint) aur "diverges" (coral) distinguish karta hai. Dhyan karo coral markers exactly hamare teen computed numbers par land karte hain.

Answer: $v_{1} = 12.5, v_{2} = - 6.25, v_{3} = 21.875$ — divergent oscillation solver ki wajah se, SUT ki nahi.

Verify: Upar teen values, aur $Δ t / τ = 2.5 > 2$ instability predict karta hai. ✓

Example 6 — Cell F: real-world word problem

Step 1 — Stopping-distance formula recall karo. $d_{stop} = \frac{v ^{2}}{2 a}$ Yeh step kyun? Hum $v^{2} / (2 a)$ use karte hain kyunki yeh exactly jawaab deta hai "constant deceleration ke under zero speed tak pahunchne mein kitna door?" — energy se derive kiya gaya: car ko kinetic-energy-per-mass $\frac{1}{2} v^{2}$ per metre $a$ ki rate par shed karna hai.

Step 2 — Plug in karo (units: m/s aur m/s²). $d_{stop} = \frac{3 0 ^{2}}{2 \times 6} = \frac{900}{12} = 75 m$ Yeh step kyun? Actual numbers substitute karna abstract formula ko concrete distance mein turn karta hai jise hum gap ke against compare kar sakte hain. Units: $(m/s)^{2} / (m/s^{2}) = m$ . ✓

Step 3 — Gap se compare karo. $d_{stop} = 75$ m lekin obstacle $50$ m par hai. Margin $= 50 - 75 = - 25$ m. Yeh step kyun? Margin tab hi meaningful hai jab (available gap) minus (needed distance) ho; negative result unambiguous "collision" signal hai.

Answer: Nahi — car ko 75 m chahiye lekin sirf 50 m available hai; woh 25 m se fail karti hai. Controller ko pehle ya zyada hard brake karna chahiye.

Verify: 50 m par maximum safe speed solve karo: $v_{m a x} = 2 a d = 2 \times 6 \times 50 = 600 \approx 24.49$ m/s. Kyunki $30 > 24.49$ , collision confirm. ✓

Example 7 — Cell G: exam twist ("SIL pass hua, hardware fail hua")

Step 1 — SIL command (fresh data $v_{n} = 8$ ). $e_{n}^{SIL} = v_{ref} - v_{n} = 10 - 8 = 2, u_{n}^{SIL} = K e_{n}^{SIL} = 0.5 \times 2 = 1$ Yeh step kyun? SIL ne zero delay model kiya, toh woh current true speed $v_{n}$ use karta hai — yeh "ideal" command hai jis par code verify kiya gaya.

Step 2 — Hardware command (stale data $v_{n - 2} = 6$ ). $e_{n}^{HW} = v_{ref} - v_{n - 2} = 10 - 6 = 4, u_{n}^{HW} = K e_{n}^{HW} = 0.5 \times 4 = 2$ Yeh step kyun? Real ADC 2-tick-old data deta hai. Wahi code line run hoti hai, lekin uska input stale $v_{n - 2}$ hai, toh hum $8$ ki jagah $6$ ke saath recompute karte hain yeh dekhne ke liye ki hardware actually kya karta hai.

Step 3 — Dono commands compare karo. $u_{n}^{HW} - u_{n}^{SIL} = 2 - 1 = 1$ Yeh step kyun? Subtract karne se delay ka pure effect isolate hota hai — ek full unit extra, unwanted push — jo woh number hai jo abstraction error quantify karta hai.

Answer: SIL kehta hai $u = 1$ ; real hardware kehta hai $u = 2$ . Extra unit woh invisible timing bug hai jo SIL miss kar gaya.

Verify: Difference $u^{HW} - u^{SIL} = 0.5 (4 - 2) = 1$ , aur hardware SIL ne predict kiya usse double push karta hai. ✓

Wrap-up: matrix, filled

Recall Kis example ne kaunsa cell cover kiya?

A→Ex1, B→Ex2, C→Ex3, D→Ex4, E→Ex5, F→Ex6, G→Ex7 ::: Har cell of the scenario matrix ab ek fully worked, verified example ke saath hai.

Parent topic par wapas jao.