Capteurs de Create Aeronautics

Lit toutes les valeurs d'un capteur en un seul appel, et les renvoie dans une table dont les clés sont les noms de ses méthodes.

Tous les capteurs de cette page l'ont (et le brûleur à air chaud aussi). Les clés de la table sont :

Une mesure qui vaut nil est tout simplement absente de la table : un capteur optique qui ne voit rien n'a ni clé distance ni clé block.

local gyro = peripheral.find("gimbal_sensor")
local m = gyro.read()
print("X " .. m.angle_x .. "  Z " .. m.angle_z)

Deux bonnes raisons de la préférer dans une boucle : un appel coûte moins que deux ou trois, et toutes les valeurs vont ensemble. Avec des appels séparés, un long programme peut être mis en pause par son budget d'instructions entre deux d'entre eux, et la seconde valeur vient alors d'un tick plus tard.

Comme read n'existe que sur les capteurs, elle permet aussi de les reconnaître parmi les autres appareils. Ce programme liste tous les capteurs que l'ordinateur atteint, avec toutes leurs mesures :

for _, nom in ipairs(peripheral.list()) do
  local p = peripheral.wrap(nom)
  if p and p.read then
    print(nom)
    for cle, valeur in pairs(p.read()) do
      print("  " .. cle, valeur)
    end
  end
end

La hauteur du capteur dans le monde, en blocs : la coordonnée Y du centre du bloc.

Au sol, un capteur posé sur un bloc en Y 64 est lui-même en Y 65 : il lit donc 65.5. Sur un navire en vol, il lit la vraie hauteur du navire dans le monde, où qu'il soit. C'est la mesure que tient un pilote automatique d'altitude (voir Maintien d'altitude d'un dirigeable).

local alt = peripheral.find("altitude_sensor")
print(string.format("Hauteur : %.1f", alt.height()))

Une alarme d'altitude basse : une lampe sur le dessus de l'ordinateur s'allume sous Y 90.

local alt = peripheral.find("altitude_sensor")
while true do
  rs.set("top", alt.height() < 90)
  sleep(0.5)
end

La vitesse de montée se déduit de deux mesures : la différence de hauteur divisée par le temps écoulé entre elles.

local alt = peripheral.find("altitude_sensor")
local avant = alt.height()
sleep(1)
local montee = alt.height() - avant
print(string.format("montée %+.1f blocs/s", montee))

Voir aussi altitude_sensor.pressure() vehicle.position()

La pression de l'air là où se trouve le capteur : 1 au niveau de la mer, de moins en moins à mesure que l'on monte.

Par défaut, l'air se raréfie en douceur avec la hauteur : environ 0.71 en Y 150, 0.58 en Y 200, et 0 en haut du monde. Sous le niveau de la mer, elle dépasse 1. Les Lunettes d'ingénieur montrent la même valeur en pourcentage. Un pack de données peut changer la courbe d'une dimension.

La pression compte, car les ballons portent moins dans l'air raréfié : un navire qui flotte sans peine en Y 100 peut ne pas réussir à dépasser Y 250. Pour l'afficher en pourcentage :

local alt = peripheral.find("altitude_sensor")
print(string.format("Air : %.0f %%", alt.pressure() * 100))

L'inclinaison du navire autour de son axe X (l'axe est-ouest), en degrés : le « nez en l'air, nez en bas » d'un navire qui vole vers le nord ou le sud.

0 veut dire à plat. Au-dessus de 0, le côté sud est plus bas que le côté nord ; en dessous de 0, c'est le côté nord qui est plus bas.

local gyro = peripheral.find("gimbal_sensor")
local x = gyro.angle_x()
if x > 1 then
  print("côté sud bas de " .. x .. " degrés")
elseif x < -1 then
  print("côté nord bas de " .. -x .. " degrés")
else
  print("à plat du nord au sud")
end

Voir aussi gimbal_sensor.angle_z()

L'inclinaison du navire autour de son axe Z (l'axe nord-sud), en degrés : à quel point il penche sur le côté.

0 veut dire à plat. Au-dessus de 0, le côté est est plus bas que le côté ouest ; en dessous de 0, c'est le côté ouest qui est plus bas.

Les deux angles font un niveau à bulle. La bulle file vers le côté haut, comme sur un vrai niveau, et passe au jaune puis au rouge quand le navire penche davantage. Le dessin prend la table que renvoie read() : on l'essaie donc ici avec une mesure tapée à la main (le côté sud bas de 2,5 degrés, le côté ouest de 4) :

local function niveau(m)
  gfx.clear("black")
  term.clear()
  local cx, cy, r = 153, 90, 70
  gfx.circle(cx, cy, r, "gray", 2)
  gfx.circle(cx, cy, 12, "light_gray")
  gfx.line(cx - r, cy, cx + r, cy, "gray")
  gfx.line(cx, cy - r, cx, cy + r, "gray")
  -- le nord en haut : l'est bas pousse la bulle à l'ouest, le sud bas la pousse au nord
  local bx = cx - math.max(-60, math.min(60, m.angle_z * 6))
  local by = cy - math.max(-60, math.min(60, m.angle_x * 6))
  local pente = math.sqrt(m.angle_x ^ 2 + m.angle_z ^ 2)
  local couleur = "lime"
  if pente > 5 then
    couleur = "red"
  elseif pente > 1 then
    couleur = "yellow"
  end
  gfx.circle(bx, by, 9, couleur, true)
  term.set_cursor(1, 1)
  term.write(string.format("X %+.1f", m.angle_x))
  term.set_cursor(1, 2)
  term.write(string.format("Z %+.1f", m.angle_z))
  gfx.text(cx - 1, cy - r - 9, "N", "white")
end

niveau({angle_x = 2.5, angle_z = -4})

Écran

Sur le navire, donnez-lui le vrai capteur plusieurs fois par seconde (avec la fonction niveau ci-dessus dans le même fichier) :

local gyro = peripheral.find("gimbal_sensor")
while true do
  niveau(gyro.read())
  sleep(0.2)
end

Voir aussi gimbal_sensor.angle_x()

La vitesse du navire le long de l'axe du capteur de vitesse (Velocity Sensor), en blocs par seconde (Aeronautics écrit m/s : c'est la même chose).

Le capteur ne mesure que le long de son propre axe, celui de son hélice : posé dans la longueur du navire, il donne la vitesse d'avancement ; posé debout, la vitesse de montée. Le signe indique le sens sur cet axe : positif dans un sens, négatif dans l'autre. Avancez une fois pour voir quel signe donne votre capteur.

Sous 0,05 bloc par seconde, il lit 0, et il lit toujours 0 hors d'un navire assemblé. Son panneau de réglage (la vitesse du signal maximal) ne change que sa sortie de redstone.

local vitesse = peripheral.find("velocity_sensor")
print(string.format("%.1f blocs/s", math.abs(vitesse.velocity())))

Un régulateur de croisière : les hélices tournent par un Contrôleur de vitesse de rotation derrière l'ordinateur, et le programme les accélère ou les ralentit pour tenir 10 blocs par seconde. set_speed veut un nombre entier, d'où math.floor. Si votre capteur lit une vitesse négative quand le navire avance, écrivez -vitesse.velocity().

local vitesse = peripheral.find("velocity_sensor")
local moteur = peripheral.wrap("back")   -- Contrôleur de vitesse de rotation des hélices
local CROISIERE = 10
local rpm = 64
while true do
  local v = vitesse.velocity()
  rpm = math.max(0, math.min(256, rpm + (CROISIERE - v) * 2))
  moteur.set_speed(math.floor(rpm))
  sleep(0.5)
end

Voir aussi vehicle.speed() vehicle.velocity()

Indique si le faisceau touche un bloc à sa portée.

local oeil = peripheral.find("optical_sensor")
if oeil.hit() then
  print("quelque chose devant")
end

Voir aussi optical_sensor.distance() optical_sensor.block()

La distance du bloc, en blocs, mesurée du centre du capteur au point où le faisceau touche le bloc. nil quand le faisceau ne touche rien.

Pointé vers le bas sous un navire, c'est la hauteur au-dessus du sol, que le capteur d'altitude ne donne pas : pratique pour se poser en douceur.

local oeil = peripheral.find("optical_sensor")
local d = oeil.distance()
if d then
  print(string.format("sol à %.1f blocs dessous", d))
else
  print("pas de sol à portée")
end

Voir aussi optical_sensor.hit() optical_sensor.range()

L'id du bloc que touche le faisceau, comme "minecraft:oak_log" ou "create:andesite_casing". nil quand le faisceau ne touche rien.

Un capteur pointé vers le bas trouve l'aire d'atterrissage, un carré de béton jaune :

local oeil = peripheral.find("optical_sensor")
if oeil.block() == "minecraft:yellow_concrete" then
  print("juste au-dessus de l'aire d'atterrissage")
end

Le faisceau traverse les fluides, sauf si un objet contenant un fluide est dans l'emplacement de filtre : avec un seau d'eau, il s'arrête sur l'eau (block() donne "minecraft:water") et plus rien d'autre ne compte.

Voir aussi optical_sensor.hit()

La plus grande distance qu'atteint le faisceau, en blocs : le panneau de réglage du capteur. Un capteur neuf commence au maximum du serveur, 15 blocs sauf si la configuration serveur optical_sensor_max_range en décide autrement.

local oeil = peripheral.find("optical_sensor")
print("faisceau : " .. oeil.range() .. " blocs")

Voir aussi optical_sensor.set_range()

Change la longueur du faisceau, comme si l'on tournait son panneau de réglage. La valeur est gardée entre 1 et le maximum du serveur (15 par défaut), et la fonction ne renvoie rien : lisez range() pour voir ce qui a été retenu.

Le nombre doit être entier : oeil.set_range(7.5) arrête le programme avec bad argument #1 to 'set_range' (number has no integer representation). Arrondissez-le d'abord avec math.floor.

Un faisceau court ignore ce qui est loin, par exemple pour une alarme qui ne s'intéresse qu'aux 6 derniers blocs :

local oeil = peripheral.find("optical_sensor")
oeil.set_range(6)
print(oeil.range())
oeil.set_range(1000)
print(oeil.range())   -- le maximum du serveur, 15 par défaut

Une alerte d'obstacle. Un capteur sur la proue regarde devant, et l'ordinateur fait sonner une cloche (ou allume une lampe) sur sa face du dessus quand quelque chose est à moins de 8 blocs. read() prend les trois valeurs du même instant :

local oeil = peripheral.find("optical_sensor")
while true do
  local m = oeil.read()
  local danger = m.hit and m.distance < 8
  rs.set("top", danger)
  term.clear()
  term.set_cursor(1, 1)
  if danger then
    print("OBSTACLE " .. m.block .. " à " .. m.distance)
  else
    print("la voie est libre")
  end
  sleep(0.25)
end

La même mesure dessinée en jauge : la barre est le faisceau, remplie jusqu'à l'obstacle, rouge quand il est proche. Ici avec une mesure tapée à la main, un arbre à 6,4 blocs devant :

local function radar(m)
  gfx.clear("black")
  term.clear()
  term.set_cursor(2, 2)
  term.write("CAPTEUR DE PROUE, faisceau " .. m.range .. " blocs")
  gfx.rect(10, 40, 286, 30, "gray", 2)
  if m.hit then
    local w = math.floor(282 * m.distance / m.range)
    local couleur = "lime"
    if m.distance < 8 then
      couleur = "red"
    end
    gfx.rect(12, 42, w, 26, couleur, true)
    term.set_cursor(2, 10)
    term.write(string.format("%s à %.1f blocs", m.block, m.distance))
  else
    term.set_cursor(2, 10)
    term.write("la voie est libre")
  end
end

radar({hit = true, distance = 6.4, block = "minecraft:oak_log", range = 15})

Écran

Voir aussi optical_sensor.range()

La direction de la cible, en degrés de 0 à 360, mesurée à plat dans le plan de la table. Elle tourne avec le navire : quand le navire tourne, l'angle change.

Pour une table posée sur un sol, sur un navire qui n'a pas tourné depuis sa construction, 0 pointe vers l'est (+X), 90 vers le sud (+Z), 180 vers l'ouest et 270 vers le nord : la même convention que math.atan2 sur une carte. Sans objet, ou avec un objet qui ne pointe nulle part, elle lit 0.

local nav = peripheral.find("navigation_table")
print("cible à " .. math.floor(nav.angle()) .. " degrés")

Voir aussi navigation_table.distance() math.atan2()

La distance de la table à la cible, en blocs, en ligne droite.

La table la mesure environ deux fois par seconde, seulement quand un objet est posé dessus : sans objet, la valeur reste où elle était. Elle vaut -1 quand l'objet n'a pas de cible dans cette dimension (une carte sans repère, une boussole de récupération dans un autre monde).

local nav = peripheral.find("navigation_table")
local d = nav.distance()
if d < 0 then
  print("pas de cible")
elseif d < 20 then
  print("arrivé !")
else
  print("encore " .. math.floor(d) .. " blocs")
end

Un écran de navigation. Une flèche dans une rose des vents, le nord en haut, et la distance à côté : comme 0 est l'est et 90 le sud, la pointe de la flèche est au cos et au sin de l'angle, exactement comme sur une carte vue du dessus. Ici avec une mesure tapée à la main :

local function boussole(m)
  gfx.clear("black")
  term.clear()
  local cx, cy, r = 90, 85, 70
  gfx.circle(cx, cy, r, "gray", 2)
  gfx.text(cx - 1, cy - r + 6, "N", "light_gray")
  gfx.text(cx + r - 10, cy - 2, "E", "light_gray")
  gfx.text(cx - 1, cy + r - 10, "S", "light_gray")
  gfx.text(cx - r + 8, cy - 2, "O", "light_gray")
  local a = m.angle * math.pi / 180
  local tx = cx + math.floor((r - 16) * math.cos(a) + 0.5)
  local ty = cy + math.floor((r - 16) * math.sin(a) + 0.5)
  gfx.line(cx, cy, tx, ty, "yellow", 3)
  gfx.circle(tx, ty, 5, "yellow", true)
  gfx.circle(cx, cy, 3, "white", true)
  term.set_cursor(30, 7)
  term.write("CIBLE")
  term.set_cursor(30, 9)
  if m.distance < 0 then
    term.write("aucune")
  else
    term.write(math.floor(m.distance) .. " blocs")
  end
  term.set_cursor(30, 11)
  term.write(math.floor(m.angle) .. " degrés")
end

boussole({angle = 305, distance = 412.6})

Écran

En jeu, appelez boussole(nav.read()) dans une boucle, comme pour le niveau à bulle.

Voir aussi navigation_table.angle()

L'angle vers lequel le roulement tourne sa structure, en degrés. La structure le suit physiquement, avec un peu de retard.

L'angle grandit (ou diminue, selon le sens) à mesure que la roue dentée tourne, et repart après un tour complet : il reste entre -360 et 360. angle % 360 le ramène entre 0 et 360. Il vaut 0 tant que le roulement n'est pas assemblé.

local roulement = peripheral.find("swivel_bearing")
print(string.format("vise %.1f degrés", roulement.target_angle() % 360))

Tourner une tourelle vers un cap : un Contrôleur de vitesse de rotation derrière l'ordinateur entraîne doucement la roue dentée du roulement jusqu'à ce que l'angle soit à moins de 3 degrés du but, puis s'arrête. Avec sa roue dentée à 8 tr/min, le roulement tourne de 2,4 degrés par tick : la boucle, qui vérifie à chaque tick, ne peut pas sauter par-dessus la fenêtre de 6 degrés.

local roulement = peripheral.find("swivel_bearing")
local moteur = peripheral.wrap("back")   -- Contrôleur de vitesse de rotation de la roue dentée
local BUT = 90

local function ecart(angle)
  return (BUT - angle + 180) % 360 - 180
end

moteur.set_speed(8)
repeat
  sleep(0.05)
until math.abs(ecart(roulement.target_angle())) < 3
moteur.set_speed(0)

De combien le ressort est remonté en ce moment, en degrés.

local ressort = peripheral.find("torsion_spring")
print("remonté à " .. ressort.angle() .. " sur " .. ressort.limit() .. " degrés")

Voir aussi torsion_spring.limit()

La limite d'angle réglée sur le panneau du ressort, en degrés : 90 sur un ressort neuf, de 1 à 360.

Voir aussi torsion_spring.set_limit()

true tant que le ressort bouge (son angle a changé pendant le dernier tick), false quand il est au repos.

local ressort = peripheral.find("torsion_spring")
while ressort.running() do
  sleep(0.1)
end
print("le ressort est au repos")

Voir aussi torsion_spring.set_limit()

Change la limite d'angle, seulement quand le ressort est au repos. Quand il tourne, rien ne change et la fonction renvoie false, comme le périphérique ComputerCraft de Simulated : changer la plage au milieu d'un mouvement le ferait sauter.

La valeur est gardée entre 1 et 360. Comme pour tout argument entier, 90.5 arrête le programme avec bad argument #1 to 'set_limit' (number has no integer representation).

Comme elle peut refuser, réessayez jusqu'à ce qu'elle accepte. Une trappe entraînée par un ressort s'ouvre de 90 degrés pour la cargaison, de 30 pour aérer :

local ressort = peripheral.find("torsion_spring")

local function ouvrir_a(degres)
  while not ressort.set_limit(degres) do
    sleep(0.1)   -- il bouge encore : on attend qu'il se repose
  end
end

ouvrir_a(90)
print("limite : " .. ressort.limit())

Voir aussi torsion_spring.running() torsion_spring.limit()