Une coquille :

Citation :
Des deux équations (en blue et rouge), on a :

Bonjour,

La trajectoire décrite par une bille s'apparente à une cycloïde qui est ici dégénérée en segment de droite car le rayon du cercle mobile fait la moitié du rayon du cercle externe.

Voir lien :

Pour démontrer cette propriété, une approche naturelle consiste à raisonner sur les vitesses. D'abord la vitesse M dans le référentiel de la roue mobile, et enfin la vitesse de Omega dans le référentiel du cercle fixe, puis d'appliquer le principe de composition des vitesses.
Il y a ensuite une équation supplémentaire car à ce stade tu as  2 inconnues (2 vitesses angulaires) : c'est le fait que le point de contact roue/cercle a une vitesse nulle (non-glissement). Cela permet de trouver une relation entre la vitesse angulaire de M dans le référentiel de la roue, et la vitesse de Omega dans le référentiel du cercle.

Je n'ai pas regardé le détail de ton calcul mais il est surprenant que n'aies pas besoin de la relation de non-glissement. Pour être plus précis : à supposer que ton raisonnement soit correct, cette hypothèse de non-glissement impose des choses entre ton omega et la dérivée de ton Phi_m.

_{* Modération > lien facilité *}

salut

il me semble que chaque bille fait simplement un aller retour sur un diamètre.

quand on fixe n'importe quelle bille, c'est du moins ce que je vois.

et l'ensemble des billes fait effectivement penser à un cercle qui tourne (sans frottement !!) à l'intérieur d'un grand cercle.

si on se fixe un point du cercle formé par les billes alors c'est plutôt une hypocycloïde :

voir aussi

Je trouve le mouvement des billes particulièrement gracieux ,ce qui
n'est pas le cas des formules correspondantes

Bonjour à tous

Je suis comme souvent ( parfois ? ) d'accord avec Dpi , se lancer dans des calculs sans savoir ce qu'il en est  , c'est bof . On croit voir des choses mais il faut avant tout poser les bases .

1°) Il y a 12 billes qui se promènent sur 24 diamètres régulièrement espacés .

2°) Apparemment chaque bille reste toujours sur le même diamètre dans un mouvement périodique qui est le même pour toutes les billes .

3°)  A chaque instant les 12 billes semblent rester sur un cercle de rayon constant .

Après il y a plein de questions que l'image animée laisse en suspens  ...

Plus simplement si on met 3 billes sur 6 diamètres et que les billes doivent rester sur un cercle de même rayon : on fait comment ?

Imod

Salut, merci à vous !

Imod, une petite simulation de ce cas

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# Paramètres
rayon = 1.5  # Rayon du mouvement des billes
nb_points = 3  # Nombre de billes (3 dans ce cas)
velocity = -0.5  # Vitesse angulaire individuelle des billes

rayon_global = 5  # Rayon du cercle sur lequel les diamètres sont répartis
vitesse_angulaire_globale = 0.5  # Vitesse angulaire globale du cercle mobile
temps = np.linspace(0, 20, 500)  # Temps pour l'animation

angles_initiaux = np.linspace(0, 2 * np.pi, 6, endpoint=False)  # 6 diamètres réguliers
angles_billes = angles_initiaux[:nb_points]  # On ne sélectionne que 3 angles pour les billes

# Configuration de la figure
fig, ax = plt.subplots(figsize=(6, 6))
dim_X = -rayon_global - rayon - 1
dim_Y = rayon_global + rayon + 1
ax.set_xlim(dim_X, dim_Y)
ax.set_ylim(dim_X, dim_Y)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Animation')
ax.grid(True)
ax.axis('equal')

# Points et traînées
points, = ax.plot([], [], 'ro', markersize=5)
trace = [ax.plot([], [], 'b-', lw=1)[0] for _ in range(nb_points)]
historique = [[] for _ in range(nb_points)]  # Historique pour les traînées

# Initialisation de l'animation
def init():
    points.set_data([], [])
    for traînée in trace:
        traînée.set_data([], [])
    return points, *trace

# Mise à jour de l'animation à chaque frame
def update(frame):
    angle_global = vitesse_angulaire_globale * temps[frame]
    centre_x = rayon_global * np.cos(angle_global)
    centre_y = rayon_global * np.sin(angle_global)
    
    angles = angles_billes + velocity * temps[frame]
    x = centre_x + rayon * np.cos(angles)
    y = centre_y + rayon * np.sin(angles)
    
    points.set_data(x, y)
    
    for i in range(nb_points):
        historique[i].append((x[i], y[i]))
        traînée_x, traînée_y = zip(*historique[i]) if historique[i] else ([], [])
        trace[i].set_data(traînée_x, traînée_y)
    
    return points, *trace

# Lancement de l'animation
if __name__ == "__main__":
    ani = FuncAnimation(fig, update, frames=len(temps), init_func=init, blit=True, interval=20)
    plt.show()

Bonjour,

Plutôt (si j'ai bien compris !) :

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation

# Paramètres
rayon = 5  # Rayon du mouvement des billes
nb_points = 3  # Nombre de billes (3 dans ce cas)

rayon_global = rayon/2  # Rayon du cercle sur lequel les billes sont réparties
vitesse_angulaire = 0.5  # Vitesse angulaire globale du cercle mobile
temps = np.linspace(0, 20, 500)  # Temps pour l'animation

angles_initiaux = np.linspace(0, 2 * np.pi, 6, endpoint=False)  # 6 diamètres réguliers
angles_billes = angles_initiaux[:nb_points]  # On ne sélectionne que 3 angles pour les billes
angles_trace = np.linspace(0, 2 * np.pi, 64, endpoint=False)  # 6 diamètres réguliers

# Configuration de la figure
fig, ax = plt.subplots(figsize=(6, 6))
dim_X = -rayon_global - rayon - 1
dim_Y = rayon_global + rayon + 1
ax.set_xlim(dim_X, dim_Y)
ax.set_ylim(dim_X, dim_Y)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_title('Animation')
ax.grid(True)
ax.axis('equal')

# Points et traînées
points, = ax.plot([], [], 'ro', markersize=5)
trace = [ax.plot([], [], 'b-', lw=1)[0] for _ in range(nb_points)]
cercle, = ax.plot([], [], 'b-')
historique = [[] for _ in range(nb_points)]  # Historique pour les traînées

# Initialisation de l'animation
def init():
    points.set_data([], [])
    cercle.set_data([], [])
    for traînée in trace:
        traînée.set_data([], [])
    return cercle, points, *trace

# Mise à jour de l'animation à chaque frame
def update(frame):
    angle = vitesse_angulaire * temps[frame]
      
    xC = rayon_global * (np.cos(angle) + np.cos(angles_trace))
    yC = rayon_global * (np.sin(angle) + np.sin(angles_trace))
    x = np.cos(angles_billes)*rayon* np.cos(-angle+angles_billes)
    y = np.sin(angles_billes)*rayon* np.cos(-angle+angles_billes)
    
    points.set_data(x, y)
    cercle.set_data(xC, yC)
    
    for i in range(nb_points):
        historique[i].append((x[i], y[i]))
        traînée_x, traînée_y = zip(*historique[i]) if historique[i] else ([], [])
        trace[i].set_data(traînée_x, traînée_y)
    
    return cercle, points, *trace

# Lancement de l'animation
if __name__ == "__main__":
    ani = FuncAnimation(fig, update, frames=len(temps), init_func=init, blit=True, interval=20)
    plt.show()

Effectivement, j'ai inversé les deux raisons..

Peu importe, les deux résultats sont amazing !

Merci

*Rayons