coulombViscousFriction

Friction statique : terme visqueux Gain*u plus terme de Coulomb signe Offset*sign(u).

📝Syntaxe

Type de bloc : coulombViscousFriction

📥Arguments d'entrée

Paramètre	Description
ports d entree	1 port(s) d entree declare(s).

📤Arguments de sortie

Paramètre	Description
ports de sortie	1 port(s) de sortie declare(s).

📄Description

Friction statique : terme visqueux Gain*u plus terme de Coulomb signe Offset*sign(u).

Module	`nflow_blocks`
Bibliotheque	Non lineaire
Type	`coulombViscousFriction`
Libelle	Coulomb & Viscous Friction

Description

Modelise une caracteristique de friction statique combinant un terme visqueux proportionnel a l'entree (Gain) et un terme de Coulomb de magnitude fixe (Offset) opposant le sens du mouvement : y = Gain*u + Offset*sign(u). Comme sign(0) = 0, la sortie vaut exactement 0 au repos. Deux segments paralleles avec un saut de 2*Offset a l'origine. Scalaire ou vecteur (element par element).

Ports

Entree(s)

Port	Role	Cote	Position
Port_1	Signal numerique lu par le bloc.	gauche	x=0, y=40

Sortie(s)

Port	Role	Cote	Position
Port_1	Signal numerique produit par le bloc.	droite	x=80, y=40

Parametres

Parametre	Valeur par defaut
`Gain`	1
`Offset`	1

Caracteristiques du bloc

Type de bloc	coulombViscousFriction
Famille	Non lineaire
Taille rendue	80 x 80
Phases	ALGEBRAIC
Etat interne ou historique	non
Type de donnees du signal	valeurs numeriques double

Algorithmes

ALGEBRAIC : y = Gain*u + Offset*sign(u), element par element sur la largeur d'entree.

Equation ou regle

$$y = \text{Gain}\cdot u + \text{Offset}\cdot \operatorname{sign}(u)$$

Capacites etendues

Sources d implementation

Generation de code : prise en charge pour C et Rust.

Manifestmodules/nflow_blocks/libraries/nonlinear/library.json

{
  "id": "builtin.nonlinear",
  "title": "Non-Linear",
  "version": "1.0.0",
  "format": "nflow-2",
  "metadata": {
    "author": "Allan CORNET",
    "created": "2026-03-21",
    "tool": "Nelson nflow"
  },
  "comment": "Blocks for non-linearities",
  "license": "LGPL-3.0",
  "builtin": true,
  "blocks": [
    {
      "type": "saturation",
      "icon": "saturation.svg",
      "label": "Saturation",
      "phases": [
        "ALGEBRAIC"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "LowerLimit": -1,
        "UpperLimit": 1
      },
      "render": {
        "type": "image",
        "src": "saturation.svg"
      }
    },
    {
      "type": "hysteresis",
      "label": "Relay",
      "icon": "hysteresis.svg",
      "phases": [
        "INIT",
        "OUTPUT",
        "UPDATE"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "uHigh": 1,
        "uLow": -1,
        "yHigh": 1,
        "yLow": 0
      },
      "render": {
        "type": "image",
        "src": "hysteresis.svg"
      }
    },
    {
      "type": "rate",
      "label": "Rate Lim.",
      "icon": "rate.svg",
      "phases": [
        "INIT",
        "OUTPUT",
        "UPDATE"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "RisingSlewLimit": 1,
        "FallingSlewLimit": 1
      },
      "render": {
        "type": "image",
        "src": "rate.svg"
      }
    },
    {
      "type": "backlash",
      "label": "Backlash",
      "icon": "backlash.svg",
      "phases": [
        "INIT",
        "OUTPUT",
        "UPDATE"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "BacklashWidth": 1
      },
      "render": {
        "type": "image",
        "src": "backlash.svg"
      }
    },
    {
      "type": "deadZone",
      "label": "Dead Zone",
      "icon": "deadZone.svg",
      "phases": [
        "ALGEBRAIC"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "LowerValue": -1,
        "UpperValue": 1
      },
      "render": {
        "type": "image",
        "src": "deadZone.svg",
        "svgMode": "element",
        "preserveAspectRatio": "none",
        "x": 0,
        "y": 0,
        "width": 80,
        "height": 80
      }
    },
    {
      "type": "quantizer",
      "label": "Quantizer",
      "icon": "quantizer.svg",
      "phases": [
        "ALGEBRAIC"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "QuantizationInterval": 1
      },
      "render": {
        "type": "image",
        "src": "quantizer.svg",
        "svgMode": "element",
        "preserveAspectRatio": "none",
        "x": 0,
        "y": 0,
        "width": 80,
        "height": 80
      }
    },
    {
      "type": "hitCrossing",
      "icon": "hitCrossing.svg",
      "label": "Hit Crossing",
      "phases": [
        "INIT",
        "OUTPUT",
        "UPDATE"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "HitCrossingOffset": 0,
        "HitCrossingDirection": "either"
      },
      "render": {
        "type": "image",
        "src": "hitCrossing.svg"
      }
    },
    {
      "type": "coulombViscousFriction",
      "label": "Coulomb & Viscous Friction",
      "icon": "coulombViscousFriction.svg",
      "phases": [
        "ALGEBRAIC"
      ],
      "width": 80,
      "height": 80,
      "inputs": [
        {
          "x": 0,
          "y": 40,
          "side": "left"
        }
      ],
      "outputs": [
        {
          "x": 80,
          "y": 40,
          "side": "right"
        }
      ],
      "defaultParams": {
        "Gain": 1,
        "Offset": 1
      },
      "render": {
        "type": "image",
        "src": "coulombViscousFriction.svg",
        "svgMode": "element",
        "preserveAspectRatio": "none",
        "x": 0,
        "y": 0,
        "width": 80,
        "height": 80
      }
    }
  ]
}

Runtimemodules/nflow_blocks/src/cpp/nonlinear/coulombViscousFriction.cpp

//=============================================================================
// Copyright (c) 2016-present Allan CORNET (Nelson)
//=============================================================================
// This file is part of Nelson.
//=============================================================================
// LICENCE_BLOCK_BEGIN
// SPDX-License-Identifier: LGPL-3.0-or-later
// LICENCE_BLOCK_END
//=============================================================================
// coulombViscousFriction: a static friction characteristic combining a viscous
// term proportional to the input (Gain) and a Coulomb term of fixed magnitude
// opposing the direction of motion (Offset). y = Gain*u + Offset*sign(u), so
// y(0) = 0 (sign(0) = 0). Scalar or vector (element-wise); C / Rust codegen.
//=============================================================================
#include "SimEngineTypes.hpp"
#include "BlockRegistry.hpp"
#include "FieldNames.hpp"
#include "NFlowBlockDescriptor.hpp"
#include <cmath>
#include "nonlinear_blocks.hpp"
//=============================================================================
bool
Nelson::NFlow::handleCoulombViscousFriction(SimCtx& ctx, const Block& b, Phase phase)
{
    if (phase != Phase::ALGEBRAIC) {
        return false;
    }
    if (!hasInput(ctx, b.nid, 0)) {
        return false;
    }
    nflow::BlockDescriptor bd(b, ctx.variables);
    const double gain = bd.paramDouble("Gain", 1.0);
    const double offset = bd.paramDouble("Offset", 1.0);
    SigView uv = getInputSig(ctx, b.nid, 0);
    return emitElementwise(ctx, b.nid, [&](int i) {
        const double u = sigAt(uv, i);
        const double s = (u > 0.0) ? 1.0 : ((u < 0.0) ? -1.0 : 0.0);
        return gain * u + offset * s;
    });
}
//=============================================================================
Nelson::NFlow::BlockCodegenTemplate
Nelson::NFlow::getCodeGenCCoulombViscousFriction()
{
    BlockCodegenTemplate t;
    t.step = "{ double u = {in0};\n"
             "  double s = (u > 0.0) ? 1.0 : ((u < 0.0) ? -1.0 : 0.0);\n"
             "  out_{id} = {param:Gain:1.0} * u + {param:Offset:1.0} * s; }";
    return t;
}
//=============================================================================
Nelson::NFlow::BlockCodegenTemplate
Nelson::NFlow::getCodeGenRustCoulombViscousFriction()
{
    BlockCodegenTemplate t;
    t.step
        = "out_{id} = {param:Gain:1.0} * {in0} + {param:Offset:1.0} * "
          "(if {in0} > 0.0_f64 { 1.0_f64 } else if {in0} < 0.0_f64 { -1.0_f64 } else { 0.0_f64 });";
    return t;
}
//=============================================================================

💡Exemples

Gain = 2, Offset = 3 : entree 2 -> 7, entree -2 -> -7, entree 0 -> 0.

d.blocks={ struct('id','c','type','constant','inputs',0,'outputs',1,'params',struct('Value',2)), struct('id','f','type','coulombViscousFriction','inputs',1,'outputs',1,'params',struct('Gain',2,'Offset',3)), struct('id','w','type','toWorkspace','inputs',1,'outputs',0,'params',struct('VariableName','y','SaveFormat','Array')) };
d.connections={ struct('from','c','to','f','fromIndex',0,'toIndex',0), struct('from','f','to','w','fromIndex',0,'toIndex',0) };
d.sampleTime=0.1; d.duration=0.2; d.solver='discrete'; d.variables=struct();
r=jsondecode(__nflow_simulate__(jsonencode(d)));

🔗Voir aussi

deadZone saturation

🕔Historique des versions

Version	Description
1.0.0	initial version

Modifier cette page sur GitHub