Roulements d'hélice

Le roulement d'hélice (Propeller Bearing : Create Aeronautics n'est pas traduit, le bloc garde son nom anglais en jeu) fait une hélice des voiles collées devant lui : c'est ce qui fait avancer un navire de Create Aeronautics, le fait tourner, ou soulève un hélicoptère. Un ordinateur relié au roulement lit la poussée de l'hélice, la vitesse de l'air qu'elle souffle, et si elle tourne : de quoi vérifier que chaque moteur d'un navire marche, les comparer, ou savoir ce que donne vraiment un cran de manette des gaz.

Les deux roulements, le simple et le gyroscopique (Gyroscopic Propeller Bearing), ont le type de périphérique propeller_bearing. Contre l'ordinateur, un roulement s'appelle par sa face ("top"...) ; sur un Câble de données (Mini-ordinateur et plus récents), il reçoit un nom comme propeller_bearing@3,70,-8. peripheral.list("propeller_bearing") donne les noms de tous.

local helice = peripheral.find("propeller_bearing")
print("poussée " .. helice.thrust() .. ", air " .. helice.airflow() .. " m/s")

Aussi un bloc cinétique. Un roulement d'hélice est une machine de Create qui tourne : le roulement enveloppé a donc en plus les méthodes de Blocs cinétiques de Create, comme speed(), la vitesse de son arbre en tr/min. La vitesse elle-même se règle là d'où vient la rotation, souvent un Contrôleur de vitesse de rotation (kinetic.set_speed()).

Toutes les mesures d'un coup. Comme les capteurs, il a un read() (voir sensor.read()) dont la table contient thrust, airflow et active.

Quand le roulement a disparu, ses méthodes arrêtent le programme avec propeller bearing removed ; quand son chunk n'est pas chargé, avec peripheral is not loaded.

#Comment pousse une hélice

Quatre choses à savoir avant de lire les nombres :

1. Les voiles et la vitesse. La poussée grandit avec le nombre de voiles et avec la vitesse de l'hélice : voiles ^ 1.5 × tr/min × 0.2 aux réglages par défaut (configuration serveur propellerBearingThrust pour le 0.2). Deux fois plus vite donne deux fois plus de poussée ; quatre fois plus de voiles, huit fois plus. Les voiles sont les blocs que compte un moulin à vent (Voiles de moulin à vent, Cadres de voile de moulin à vent, laine, Symmetric Sails de Simulated).

local function poussee(voiles, rpm)
  return voiles ^ 1.5 * rpm * 0.2
end

print(poussee(4, 64))
print(poussee(16, 64))
print(poussee(16, 128))

102.4
819.2
1638.4

2. L'hélice met du temps à prendre sa vitesse. Sa vitesse suit celle de l'arbre, mais pas tout de suite : une petite hélice la rattrape vite, une grande (des dizaines de voiles) met une seconde ou deux. La poussée suit l'hélice : elle est donc en retard sur speed(), qui est celle de l'arbre.

3. Le signe est le sens. La poussée et le flux d'air sont positifs quand l'hélice souffle l'air au-delà de ses voiles et pousse le navire vers l'arrière du roulement, négatifs dans l'autre sens. Faire tourner l'arbre dans l'autre sens change le signe, tout comme le sens de poussée réglé sur le roulement.

4. Le navire reçoit moins quand il avance. thrust() est ce que donne l'hélice navire à l'arrêt, au niveau de la mer. Un navire qui avance déjà dans le sens où l'hélice le pousse reçoit moins (l'air bouge déjà), tout comme un navire haut perché, dans l'air raréfié (voir altitude_sensor.pressure()). Les Lunettes d'ingénieur montrent cette poussée réduite : elles peuvent donc afficher moins que thrust().

Le roulement d'hélice gyroscopique a les mêmes méthodes. Il incline son hélice vers le ciel, jusqu'à 12 degrés de son axe, pour garder un hélicoptère droit ; n'importe quel signal de redstone sur lui bloque l'hélice bien droite. L'inclinaison change la direction de la poussée, pas sa force.

#Mesures

local helices = {}
for _, nom in ipairs(peripheral.list("propeller_bearing")) do
  table.insert(helices, {nom = nom, poussee = math.abs(peripheral.wrap(nom).thrust())})
end
table.sort(helices, function(a, b) return a.poussee < b.poussee end)
for _, h in ipairs(helices) do
  print(string.format("%-28s %8.1f", h.nom, h.poussee))
end

local helice = peripheral.find("propeller_bearing")
print(string.format("air dans l'hélice : %.1f blocs/s", math.abs(helice.airflow())))

while true do
  local arretee = false
  for _, nom in ipairs(peripheral.list("propeller_bearing")) do
    if not peripheral.wrap(nom).active() then
      arretee = true
    end
  end
  rs.set("top", arretee)
  sleep(1)
end