path: root/blender/diferencial.py

# -*- coding: utf-8 -*-
"""DIFERENCIAL - por que las dos ruedas pueden girar a distinta velocidad.

Todas las piezas se generan por codigo y se mueven con la cinematica exacta del
mecanismo:  w_izq + w_der = 2 * w_jaula, y el satelite gira sobre su eje a
(w_der - w_izq)/2 respecto de la jaula. El pinon y la corona respetan su
relacion: 14 y 43 dientes, con semiangulos de cono que suman 90 grados.
"""
import math, os, sys
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
import bpy
from mathutils import Vector
from base import *

NOMBRE = "diferencial"
EJE_X = 1.32          # donde van las ruedas
R_RUEDA = 0.52
OMEGA = 1.45          # rad/s de la jaula
RADIO_GIRO = 3.9
TROCHA = 1.70
INCL = -0.72          # bien diagonal: en 9:16 es lo que aprovecha el alto

N_COR, N_PIN = 43, 14          # relacion 3,07:1, como un diferencial de calle
G_COR, G_PIN = 72.0, 18.0      # los semiangulos suman 90: es la condicion de engrane
N_LAT = 16
X_COR = -0.50                  # apice comun de corona y pinon: lejos de los satelites
D_I, D_O = 0.70, 1.00          # la cara dentada, igual en los dos
P_FASE = math.pi / 2       # para que el diente caiga en el hueco
P_ESP = -0.62             # mano contraria a la corona
P_SIG = 1.0

# el conjunto mide 3,68 de punta a punta; inclinado 41 grados eso son 2,77 de
# ancho y 2,41 de alto, que es lo que fija estos numeros
ENCUADRE = [(0, 6.2), (2, 5.0), (3, 4.2), (4, 5.6), (5, 4.6),
            (6, 5.0), (7, 5.6), (8, 5.6), (9, 5.8), (10, 5.2)]
DIR_CAM = Vector((0.30, -0.93, 0.21)).normalized()


def alto_en(T, f):
    tabla, altos, v = dict(ENCUADRE), [], ENCUADRE[0][1]
    for i in range(len(T.beats)):
        v = tabla.get(i, v)
        altos.append(v)
    i = 0
    for k in range(len(T.beats)):
        if f >= T.rango(k)[0]:
            i = k
    ini, fin = T.rango(i)
    p = min(1.0, (f - ini) / max(1.0, (fin - ini) * 0.55))
    return mezcla(altos[i - 1] if i else altos[0], altos[i], p)


def construir(T):
    sc = escena()
    mundo_estudio(0.65)                      # lo que refleja el acero
    cam = camara((0, -6, 0), (0, 0, 0), lente=50)
    cam.data.sensor_fit = 'VERTICAL'
    cam.data.sensor_height = 36.0

    luz("key", 'AREA', (-3.4, -4.6, 4.4), 1400, "blanco", tam=6.0, mira=(0, 0, 0))
    luz("fill", 'AREA', (4.2, -3.2, -1.6), 420, "#BFD4FF", tam=5.0, mira=(0, 0, 0))
    luz("rim", 'AREA', (-0.8, 4.6, 2.8), 900, "blanco", tam=4.0, mira=(0, 0, 0))

    M = {
        "acero": metal("acero", "#B7BEC9", rug=0.22),
        "acero2": metal("acero2", "#9BA3B0", rug=0.30),
        "fundido": metal("fundido", "#5E6774", rug=0.62, met=0.85),
        "eje_i": metal("eje_i", "#C2C8D2", rug=0.24),
        "eje_d": metal("eje_d", "#C2C8D2", rug=0.24),
        "goma": material("goma", "#1E222C", rug=0.52),
        "alu": metal("alu", "#CBD3DE", rug=0.15),
        "freno": metal("freno", "#79818E", rug=0.45, met=0.9),
    }

    # --- vista de arriba: el auto doblando --------------------------------
    piso = bpy.data.objects.new("suelo_g", None)
    bpy.context.collection.objects.link(piso)
    arcos, ruedas_a = [], []
    for k, (rr, c) in enumerate(((RADIO_GIRO - TROCHA / 2, "rosa"),
                                 (RADIO_GIRO + TROCHA / 2, "verde"))):
        pts = []
        for i in range(120):
            th = -0.62 + 1.24 * i / 119.0
            pts.append((-RADIO_GIRO + rr * math.cos(th), rr * math.sin(th), 0.0))
        cu = curva_poly(f"arco{k}", [pts], grosor=0.045, radios=[[0.0] * 120],
                        mat=material(f"m_arco{k}", c, emis=2.4, rug=0.5))
        cu.parent = piso
        arcos.append((cu, pts))
        r = rueda_completa(f"ra{k}", M, R=R_RUEDA, r=0.185, ancho=0.28)
        r.parent = piso
        ruedas_a.append(r)
    eje_a = cilindro("eje_a", 0.075, TROCHA, M["acero2"])
    eje_a.parent = piso
    patina = curva_poly("patina", [[(0, 0, 0)] * 60], grosor=0.11,
                        radios=[[0.0] * 60], mat=material("m_pat", "blanco", emis=3.4))
    patina.parent = piso

    # --- el diferencial ----------------------------------------------------
    dif = bpy.data.objects.new("dif", None)
    bpy.context.collection.objects.link(dif)
    dif.scale = (0, 0, 0)

    jaula = bpy.data.objects.new("jaula", None)
    bpy.context.collection.objects.link(jaula)
    jaula.parent = dif
    # caja de la jaula: dos bridas anulares y dos paredes curvas sobre el eje del
    # perno. Los lados +-Y quedan abiertos: por ahi se ven los engranajes, que es
    # como se ve una caja de diferencial de verdad
    # todo lo de la jaula queda por dentro de r=0.52: el pinon nunca baja de
    # r=0.59, y asi la jaula puede girar sin pasarle por encima
    for sx in (0.58, -0.58):
        br = anillo_plano(f"brida{sx}", 0.13, 0.52, 0.08, M["fundido"])
        br.rotation_euler = (0, math.pi / 2, 0)
        br.location = (sx, 0, 0)
        br.parent = jaula
    for k, centro in enumerate((math.pi / 2, -math.pi / 2)):
        pared = sector_anillo(f"pared{k}", 0.43, 0.52, 1.16,
                              centro - 0.62, centro + 0.62, M["fundido"])
        pared.rotation_euler = (0, math.pi / 2, 0)
        pared.parent = jaula
    perno = cilindro("perno", 0.062, 1.00, M["acero2"])
    perno.parent = jaula

    corona = engranaje_conico("corona", (1, 0, 0), N=N_COR, gamma=G_COR,
                              d_i=D_I, d_o=D_O, alto=0.042, mat=M["acero"],
                              espiral=0.62, espesor=0.14, hueco=0.58,
                              por_diente=24)
    corona.location = (X_COR, 0, 0)
    corona.parent = jaula
    tornillos("bulones", 10, 0.78, -0.11, largo=0.10, r_t=0.035,
              mat=M["acero2"], padre=jaula)

    lat = {}
    for nom, eje, sx in (("izq", (-1, 0, 0), -1), ("der", (1, 0, 0), 1)):
        g = bpy.data.objects.new(f"lat_{nom}", None)
        bpy.context.collection.objects.link(g)
        g.parent = dif
        eng = engranaje_conico(f"eng_{nom}", eje, N=N_LAT, gamma=45.0,
                               d_i=0.26, d_o=0.50, alto=0.042, mat=M["acero"],
                               espiral=0.30, espesor=0.12, hueco=0.09)
        eng.parent = g
        # semieje escalonado + brida
        for (largo, radio, x0) in ((0.48, 0.110, 0.50), (EJE_X - 0.82, 0.080, 0.95)):
            se = cilindro(f"se_{nom}_{radio}", radio, largo, M[f"eje_{nom[0]}"])
            se.rotation_euler = (0, math.pi / 2, 0)
            se.location = (sx * x0, 0, 0)
            se.parent = g
        brida = anillo_plano(f"bw_{nom}", 0.09, 0.22, 0.07, M["acero2"])
        brida.rotation_euler = (0, math.pi / 2, 0)
        brida.location = (sx * (EJE_X - 0.20), 0, 0)
        brida.parent = g
        rue = rueda_completa(f"rue_{nom}", M, R=R_RUEDA, r=0.185, ancho=0.28)
        rue.location = (sx * EJE_X, 0, 0)
        rue.parent = g
        lat[nom] = g

    sat = []
    for k, eje in enumerate(((0, 0, 1), (0, 0, -1))):
        g = bpy.data.objects.new(f"sat{k}", None)
        bpy.context.collection.objects.link(g)
        g.parent = jaula
        eng = engranaje_conico(f"eng_s{k}", eje, N=N_LAT, gamma=45.0,
                               d_i=0.26, d_o=0.50, alto=0.042, mat=M["acero2"],
                               espiral=-0.30, espesor=0.12, hueco=0.09, fase=math.pi)
        eng.parent = g
        if k == 0:
            p = esfera(f"testigo{k}", 0.050, material("m_test", "ambar", emis=3.0))
            p.location = (0.30, 0.0, 0.42)
            p.parent = g
        sat.append(g)

    entrada = bpy.data.objects.new("entrada", None)
    bpy.context.collection.objects.link(entrada)
    entrada.parent = dif
    # misma cara que la corona, espiral de mano contraria y fase para que el
    # diente caiga en el hueco
    pinon = engranaje_conico("pinon", (0, -1, 0), N=N_PIN, gamma=G_PIN,
                             d_i=D_I, d_o=D_O, alto=0.042, mat=M["acero"],
                             espiral=P_ESP, espesor=0.12, hueco=0.07,
                             fase=P_FASE, por_diente=24)
    pinon.location = (X_COR, 0, 0)
    pinon.parent = entrada
    cardan = cilindro("cardan", 0.095, 1.30, M["acero2"])
    cardan.rotation_euler = (math.pi / 2, 0, 0)
    cardan.location = (X_COR, -1.50, 0)
    cardan.parent = entrada
    horquilla = anillo_plano("horquilla", 0.10, 0.24