/ / os parmetros dos pneus:

larguraRoda = 5; / / A largura (ou a espessura) da roda na jante.

diametroTransversalPneu = 4; / / Dimetro transversal (CS) - Qual a espessura da
borracha de pneu?
diametroInternoPneu = 93; / / Dimetro interno (ID) - Qual a largura a abertur
a para dentro?
excertoPneu = 1,01; / / Porcentagem estiramento circunferencial (geral
mente 1 + 0-5%, por exemplo, 1,02) - Como

/ / propriedades Rim
alturaAro = 10; / / A altura da poro de aro da roda.
buracosSincronizados = 20; / / O nmero de orifcios de temporizao p
ara esculpir no aro
tempoSincronizacaoBuraco = [1,0.5,3]; / / A [dentro, meio fora] preenchimento pa
ra os buracos sincronismo
direcional = true; / / A codificador direcional torna d
ois conjuntos de slots, 90 graus fora de fase
/ / Parmetros Tread:
estiloPiso = "v-grooves"; / / nenhum, cruz, o-rings, v-grooves, praas, e
sferas, cylindersX,
/ / CylindersY, cylindersZ, pontos, caa-nqueis,
x, zigX, v
tamanhoArco = [90,1.5,1]; / / O tamanho de cada boto [em frente da roda,
ao longo do permetro, prodruding]
/ / Ou para v-grooves, [ngulo, profundidade, i
gnorado]
conjuntoPisoRadial = 15; / / Quantos conjuntos de passos para tornar e
m torno da roda (2 linhas por conjunto).
numeroArcos = 4; / / O nmero de botes para processar por linha.
distanciaEscalonada = 2; / / A distncia para compensar as linhas escalo
nadas.
espessuraLinha = 1; / / A espessura da linha para estilos "desenh
ados", como "x" e "zigX"
numMaxPneus = 3; / / Para o-rings/v-grooves, o nmero mximo de pn
eus por roda
espacoEntrePneus = 2; / / Para o-rings/v-grooves, o espao entre cada
pneu, se mais de um
/ / Parmetros relacionados com a Interveno de
estiloRaio = "retngulo"; / / Nenhum, risco biolgico, crculo, circlefit, diaman
te, linha, retngulo, espiral, preencher
insercaoRaio = [0,0]; / / A [exterior interior,] insero da rea de raio a p
artir da superfcie
numRaios = 7; / / Nmero de "raios". Defina esta opo para trs, se vo
c estiver fazendo o design de risco biolgico
larguraRaio = 3; / / Este o quo grande cada raio.
proporo = [1.5,1.0]; / / Proporo de borda, proporo de largura
curvatura = 0,66; / / Para "espiral", assim que os raios so curvey.
> 0, mas <= 1, onde
/ / 1 um meio crculo
reverter = false; / / Para "espiral", definindo-o como "true" inver
te o sentido das espirais
diametroExternoFuro = 13; / / Para "circlefit", o dimetro dos furos exterior
es, ou zero para nenhum
concavidade = [0,0]; / / Concavidade distncia da rea falou por [dentro,
fora] da roda
/ / Parmetros Hub:
incluirEixo = false; / / Coloque false para remover o hub e incluem a
penas o buraco dimetro do eixo.
diametroEixo = 15; / / O dimetro da poro do ncleo da roda
alturaEixo = 12; / / A altura total do cubo
posicaoZEixo = 0; / / A posio Z do cubo, os nmeros negativos a partir
da superfcie da roda
diametroCirculoInterno = 30; / / O dimetro do crculo interno slido sob o hub, ou
zero para nenhum.
baseRaioFaixa = 2; / / O raio do filete (parte arredondada) entre o
cubo ea roda.
superiorRaioFaixa = 2; / / O raio do filete (parte arredondada), na par
te superior do cubo.
apenasChanfre = false; / / Definir para true para usar chanfros (retas n
gulos de 45 graus) em vez de filetes.
//parametros de acessorios
diametroVeioMotor = 22; / / O dimetro do veio do motor
diametroPlanoVeioMotor = 3; / / O dimetro do veio do motor, no plano, ou shaf
tDiameter para no plana.
numParafusosFixacao = 1; / / O nmero de parafusos de fixao / porcas para ren
derizar, uniformemente espaados em torno do eixo
diametroParafuso = 3; / / O dimetro do parafuso de ajuste. 3 o padro par
a um parafuso M3.
porcaParafuso = [5,4, 2,3]; / / Tamanho [indiameter, espessura] do porca set
. A profundidade definida automaticamente.
diametroPorcaParafuso = 5,4; / / O "dimetro" da porca em cativeiro, de plano a
plano (o "in-" de dimetro)
espessuraPorca = 2,3; / / A espessura da porca cativo
deslocamentoPorca = 0; / / A distncia de deslocamento da porca a partir
do centro do material. - / + = In / out
diametroRosca = 0; / / O dimetro dos furos servo brao hounting, ou ze
ro se nenhum buraco
distanciaEntreRoscas1 = 25; / / Distncia atravs servo chifre de buraco em bura
co (0 a ignorar)
distanciaEntreRoscas2 = 21; / / Distncia atravs servo chifre de buraco em bura
co, rotao de 90 graus (0 a ignorar)
rotacaoTotalRoscas = 45; / / A rotao total de todos os furos de servo
tamanhoBracoRoscas = [4,1.6]; / / Tamanho [indiameter, profundidade] de servo
brao porca cativo, ou 0 (nenhum) para nenhum.
tamanhoPorca = [12.5,5.5]; / / Tamanho [indiameter, profundidade] de uma po
rca em cativeiro, ou 0 (nenhum) para nenhum.
/ / Parmetros de qualidade:
$ Fn = 50; / / Qualidade padro para a maioria das partes do
crculo.

// Algum geometria bsica pneu
diametroInterior = diametroInternoPneu;
diametroCentro = diametroInternoPneu + diametroTransversalPneu;
outroDiametro = diametroInternoPneu + ( diametroTransversalPneu *2 );
circunferenciaInterior = diametroInterior*PI;
circunferenciaCentro = diametroCentro*PI;
outraCircunferencia = outroDiametro*PI;
/ / Geometria pneu esticada
circunferenciaExcertoCentro = circunfereiaCentro * excertoPneu;
diametroExcertoCentro = circunferenciaExcertoCentro / PI;
diametroExcertoInterno = diametroExcertoCentro - diametroTransversalPneu;
diametroOutroExcerto = diametroExcertoCentro + diametroTransversalPneu;
circunferenciaExcertoInterno = diametroExcertoInterno * PI;
circunferenciaOutroExcerto = diametroOutroExcerto * PI;
// geometria da jante
diametroJante = diametroExcertoCentro;
raioJante = diametroJante / 2;
raioPneu = diametroTransversalPneu / 2;
raioEixo = diametroEixo / 2;
Geometria do arco da jante
outroDiametroArco = diametroJante + (2 * tamanhoArco [2]);
outraCircunferenciaArco = outroDiametroArco * PI;
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / Relatrio de algumas informaes bsicas para o usurio ...
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / Alguns dados do pneu, esticado e no esticado

echo (str ("dimetro transversal do pneu ", tireCSDiameter));
echo (str ("Tire estiramento circunferencial ", tireStretch));
echo (str ("pneu (no esticada): [interior, centro, exterior]"));
eco (str ("* Dimetro:", o dimetro interior, ",", centerDiameter, ",", outerDiamete
r));
echo (str ("* Circunferncia:" round2 (innerCircumference), ",", round2 (centerCir
cumference),
",", Round2 (outerCircumference)));
echo (str ("Tire esticada: [interior, centro, exterior]"));
echo (str ("* Dimetro:" round2 (innerDiameterStretched), ",", round2 (centerDiame
terStretched),
",", Round2 (outerDiameterStretched)));
echo (str ("* Circunferncia:" round2 (innerCircumferenceStretched), ",",
round2 (centerCircumferenceStretched), ",", round2 (outerCircumferenceSt
retched)));
echo (str ("Tire Knobbed: [exterior]"));
eco (str ("* Dimetro:", round2 (outerDiameterKnobbed)));
echo (str ("* Circunferncia:" round2 (outerCircumferenceKnobbed)));
echo (str ("Dimetro da roda ser", wheelDiameter));
/ / Aqui uma funo auxiliar que ir arredondar um valor com duas casas decimais.
funo round2 (valor) = round (valor * 100) / 100;
funo concaveRadius (wheelDiameter, profundidade) = (wheelDiameter / 2) / sen (2 *
atan (profundidade / (wheelDiameter / 2)));
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / Render a roda ...
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
roda ();
roda mdulo () {
/ / Nmero de pneus - Se a largura superior a 1,5 vezes com pneu CS, ento
/ / Podemos ter vrios pneus na roda, se definido.
tireDistance = tireCSDiameter + spaceBetweenTires;
numTires = min (maxTires, max (1, andar ((wheelWidth + (tireDistance) /
2) / tireDistance)));
echo (str ("Nmero de pneus ser", numTires));
Largura / / Roda definida acima , na verdade, a largura na borda. Vamos r
edefinir wheelWidth aqui
/ / E tomar os deslocamentos de superfcie falou em conta. Vamos adicionar
uma nova varivel para a largura da borda.
larguraJante = larguraRoda;
larguraRoda = larguraJante - insercaoRaio [0] - insercaoRaio [1];
diametroRaio = diametroJante - 2 * larguraJante;
union () {
/ / a jante
difference () {
jante (larguraJante, alturaJante, diametroJante);
/ / Retirar o sincronismo buracos
if (buracosSincronizado > 0) {
if (direcional) {
assign(alturaBuraco = (alturaJante - tem
poSincronizacaoBuraco [0] - tempoSincronizacaoBuraco [2] - tempoSincronizacaoBur
aco [1]) / 2) {
/ / orifcios externos
lucalBuracosSincronizados (burac
osSincronizados, alturaBuraco, larguraJante, (diametroJante / 2)- tempoSincroniz
acaoBuraco [2]);
/ / furos interiores
girar ([0,0,90 / timingHoles])
lucalBuracosSincronizados (burac
osSincronizados, holeHeight, rimWidth,
(diametroJante / 2) - te
mpoSincronizacaoBuraco [2] - holeHeight - tempoSincronizacaoBuraco [1]);
}
atribuir (len1 = outerCircumferenceStret
ched / (timingHoles * 2),
len2 = outerCircumferenc
eKnobbed / (timingHoles * 2)) {
echo (str ("Para o-rings, cada m
arca de sincronismo (mesma borda) ", round2 (len1), "mm (",
round2 (len1/25.4), "in)
."));
echo (str ("Para passos knobbed,
cada marca de sincronismo (mesma borda) mais ou menos", round2 (len2),
"Mm (", round2 (len2/25.
4), "in)."));
}
} Else {
placeTimingHoles (timingHoles, rimHeight
-timingHolePad [0]-timingHolePad [2],
rimWidth, (diametroJante / 2)-ti
mingHolePad [2]);
atribuir (len1 = outerCircumferenceStret
ched / (timingHoles),
len2 = outerCircumferenc
eKnobbed / (timingHoles)) {
echo (str ("Para o-rings, cada m
arca de sincronismo (mesma borda) ", round2 (len1), "mm (",
round2 (len1/25.4), "in)
."));
echo (str ("Para passos knobbed,
cada marca de sincronismo (mesma borda) mais ou menos", round2 (len2),
"Mm (", round2 (len2/25.
4), "in)."));
}
}
}
/ / Perfurar pneus
if ((treadStyle == "o-rings") | | (treadStyle == "v-groo
ves")) {
atribuir (medida = (numTires-1) * (tireDistance
/ 2)) {
for (x = [-extenso: tireDistance: extenso]
) {
traduzir ([0,0, x]) {
if (treadStyle == "o-rin
gs")
pneu (diametroJa
nte, tireCSDiameter);
else if (treadStyle == "
v-grooves")
vGroove (diametr
oJante, knobSize [0], knobSize [1]);
}
}
}
} Else if (treadStyle == "slots") {/ / perfurar ranhuras
se necessrio
atribuir (separao = (rimWidth-(numberOfKnobs * kno
bSize [0])) / (numberOfKnobs +1))
atribuir (dist = knobSize [0] + separao) {
traduzir ([0,0,-rimWidth / 2])
for (i = [0: numberOfKnobs-1]) {
traduzir ([0,0, separao + (dist *
i)])
diferena () {
cilindro (r = (diametroJ
ante / 2), h = knobSize [0]);
cilindro (r = (diametroJ
ante / 2)-knobSize [2], h = knobSize [0]);
}
}
}
}
}
/ / Traduzir raios e cubo para acomodar inseres
traduzir ([0,0, rimWidth / 2 - wheelWidth / 2 - spokeInset [0]])
{
/ / Os raios
diferena () {
unio () {
atribuir (d = diametroJante - (rimHeight
* 2)) {
if (spokeStyle == "encher") {
cilindro (h = wheelWidth
, r = d / 2, centro = true);
} Else if (spokeStyle == "Biohaz
ard") {
biohazardSpokes (d, whee
lWidth, numberOfSpokes);
} Else if (spokeStyle == "circle
fit") {
circlefitSpokes (d, hubD
iameter, wheelWidth, outerHoleDiameter);
} Else if (spokeStyle == "linha"
) {
lineSpokes (d, wheelWidt
h, numberOfSpokes, spokeWidth);
} Else if (spokeStyle == "retngul
o") {
rectangleSpokes (d, whee
lWidth, spokeWidth, proporo, numberOfSpokes);
} Else if (spokeStyle == "diaman
te") {
diamondSpokes (d, wheelW
idth, spokeWidth, proporo, numberOfSpokes);
} Else if (spokeStyle == "crculo"
) {
circleSpokes (d, wheelWi
dth, spokeWidth, proporo, numberOfSpokes);
} Else if (spokeStyle == "espira
l") {
spiralSpokes (d, wheelWi
dth, numberOfSpokes,
spokeWidth, curv
atura, reverso, spiralSpoke);
}
}
/ / Se h um crculo slido interior, adicion-l
o aqui.
if (innerCircleDiameter> 0) {
cilindro (h = wheelWidth, r = in
nerCircleDiameter / 2, centro = true);
}
}
/ / Esculpir concavidade
if (concavidade [0]> 0) {/ / dentro
traduzir ([0,0, concaveRadius (spokeDiam
eter, concavidade [0]) + wheelWidth / 2-concavidade [0]])
esfera (r = concaveRadius (spoke
Diameter, concavidade [0]));
}
if (concavidade [1]> 0) {/ / fora
traduzir ([0,0,-concaveRadius (spokeDiam
eter, concavidade [1]) - wheelWidth / 2 + concavidade [1]])
esfera (r = concaveRadius (spoke
Diameter, concavidade [1]));
}
/ / Esculpir um local para um centro de insero, se
necessrio
if (includeHub) {
traduzir ([0,0, hubHeight / 2 + wheelWid
th / 2 + hubZOffset - concavidade [0]])
cilindro (h = hubHeight, r = hub
Diameter / 2, centro = true);
} Else {
mountingHoles (shaftDiameter, wheelWidth
, concavidade, servoHoleDiameter,
servoHoleDistance1, servoHoleDis
tance2, servoArmRotation, servoNutTrap);
}
/ / Esculpir menor armadilha porca se necessrio -
no esculpir o buraco
if (outerNutTrap [0] * outerNutTrap [1]! = 0) {
traduzir ([0,0,-wheelWidth / 2 + outerNu
tTrap [1] / 2 -1])
porca (outerNutTrap [0], outerNu
tTrap [1] 1);
}
}
/ / O hub
if (includeHub) {
traduzir ([0,0, hubHeight / 2 + wheelWidth / 2 +
hubZOffset - concavidade [0]])
hub (hubHeight, hubDiameter, shaftDiamet
er, shaftFlatDiameter,
setScrewCount, setScrewTrap, set
ScrewDiameter, setScrewNutOffset,
hubZOffset, baseFilletRadius, to
pFilletRadius, chamferOnly);
}
}
/ / A banda de rodagem
if (treadStyle == "o-rings") {
para (x = [- (numTires-1) * (tireDistance / 2): tireDist
ance: (numTires-1) * (tireDistance / 2)])
traduzir ([0,0, x])
% De cor ("preto", 0,5) pneu (diametroJa
nte, tireCSDiameter);
} Else if (treadStyle == "slots") {
/ / No h necessidade de tornar qualquer coisa aqui ...
} Else {/ / O resto so todos os projetos de boto
placeKnobs (wheelWidth, diametroJante, treadStyle, knobS
ize, radialTreadSets, numberOfKnobs,
staggerOffset, linethickness);
}
}
}
/ / Constri no espao extra para melhor prestao
mountingHoles mdulo (shaftDiameter, wheelWidth, concavidade, servoHoleDiameter, s
ervoHoleDistance1,
servoHoleDistance2, servoArmRotation, servoNutTrap) {
NewWidth = wheelWidth-concavidade [0]-concavidade [1];
cilindro (r = shaftDiameter / 2, h = NewWidth +1, centro = true);
/ / Se estamos montando um servo ...
if (servoHoleDiameter> 0) {
traduzir ([0,0, -wheelWidth/2-1]) {
girar ([0,0, servoArmRotation])
holeSet (servoHoleDistance1, servoHoleDiameter,
wheelWidth 2, servoNutTrap + [0,1 concavidade + [1]]);
girar ([0,0, servoArmRotation 90])
holeSet (servoHoleDistance2, servoHoleDiameter,
wheelWidth 2, servoNutTrap + [0,1 concavidade + [1]]);
}
}
}
mdulo holeSet (distncia, dimetro, comprimento, nutTrap) {
if (distncia> 0) {
for (i = [distncia / 2: distncia: a distncia / 2]) {
traduzir ([i, 0, nutTrap [1] / 2]) {
captiveNut (nutTrap, dimetro, 0, comprimento nutT
rap-[1], 0);
}
}
}
}
placeTimingHoles mdulo (holeCount, holeHeight, wheelWidth, raio) {
traduzir ([0,0, - (wheelWidth +1) / 2]) {
for (i = [0: holeCount-1]) {
rodar (i * (360/holeCount), [0, 0, 1])
arco (holeHeight, wheelWidth +1, raio, graus = 180/holeC
ount);
}
}
}
placeKnobs mdulo (wheelWidth, diametroJante, treadStyle, knobSize, radialTreadSet
s, numberOfKnobs,
staggerOffset, linethickness) {
atribuir (knobDistance = knobSize [0] + ((wheelWidth - knobSize [0] * nu
mberOfKnobs - staggerOffset) /
(NumberOfKnobs-1))) {
doTreadSet (wheelWidth, diametroJante, treadStyle, knobSize, rad
ialTreadSets, numberOfKnobs,
knobDistance, linethickness);
girar ([180, 0, 180/radialTreadSets])
doTreadSet (wheelWidth, diametroJante, treadStyle, knobS
ize, radialTreadSets, numberOfKnobs,
knobDistance, linethickness);
}
}
/ / Processa metade da banda de rodagem. A outra metade processado rodado de 180
% para produzir o deslocamento cambalear
mdulo doTreadSet (wheelWidth, diametroJante, treadStyle, knobSize, radialTreadSet
s, numberOfKnobs,
knobDistance, linethickness) {
Raio = diametroJante / 2;
halfy = knobSize [1] / 2;
teta = atan (halfy / raio);
x = sqrt ((raio * raio) + (halfy * halfy));
y = x - raio;
foundationHeight = (y / cos (theta));
traduzir ([0,0, knobSize [0] / 2 - wheelWidth / 2]) {
for (i = [0: radialTreadSets-1],
j = [0: numberOfKnobs-1]) {
rodar (i * 360 / radialTreadSets, [0, 0, 1])
traduzir ([wheelDiameter / 2, 0, j * knobDistanc
e])
doKnob (treadStyle, knobSize, linethickn
ess, foundationHeight);
}
}
}
/ / quadrados, esferas, cylindersX, cylindersY, cylindersZ, pontos, cruz, x, zig
X, v
/ / Nyi: Zigy, vReverse
/ / DebugKnob ("v");
mdulo debugKnob (estilo) {
knobSize = [5,5,5];
linethickness = 1;
raio = 25;
halfy = knobSize [1] / 2;
teta = atan (halfy / raio);
x = sqrt ((raio * raio) + (halfy * halfy));
y = x - raio;
foundationHeight = (y / cos (theta));
/ / Roda
traduzir ([-25,0,0])
% Cilindro (r = 25, h = 10, centro = true);
/ / Extenses
traduzir ([knobSize [2] / 2,0,0])
girar ([90,90,90])
% Cubo (knobSize, centro = true);
/ / Foundation
traduzir ([-foundationHeight / 2,0,0])
girar ([90,90,90])
cor ("vermelho", 0,15)
* Cubo ([knobSize [0], knobSize [1], foundationH
eight], centro = true);
doKnob (estilo, knobSize, linethickness, foundationHeight);
}
mdulo doKnob (treadStyle, knobSize, linethickness, foundationHeight) {
/ / slots e o-rings no so boto projetos
/ / Retrgrada conhecer elementos uma vez que por isso no tem que ficar rep
etindo isso
newSize = [knobSize [2] + foundationHeight, knobSize [1], knobSize [0]];
newSizeTall = [2 * (knobSize [2] + foundationHeight), knobSize [1], knob
Size [0]];
render ()
if (treadStyle == "quadrados") {
traduzir ([newSize [0] / 2 - foundationHeight, 0,0])
cubo (newSize, centro = true);
} Else if (treadStyle == "esferas") {
traduzir ([-foundationHeight, 0,0])
diferena () {
escala (newSizeTall)
esfera (r = 0,5, centro = true);
traduzir ([-newSize [0] / 2,0,0])
cubo (newSize + [0,1,1], centro = true);
}
} Else if (treadStyle == "cylindersX") {
traduzir ([-foundationHeight, 0,0])
diferena () {
escala (newSizeTall)
girar ([0,0,90])
cilindro (r = 0,5, h = 1, centro = true)
;
traduzir ([-newSize [0] / 2,0,0])
cubo (newSize + [0,1,1], centro = true);
}
} Else if (treadStyle == "cylindersY") {
traduzir ([-foundationHeight, 0,0])
diferena () {
escala (newSizeTall)
girar ([90,0,0])
cilindro (r = 0,5, h = 1, centro = true)
;
traduzir ([-newSize [0] / 2,0,0])
cubo (newSize + [0,1,1], centro = true);
}
} Else if (treadStyle == "cylindersZ") {
traduzir ([newSize [0] / 2 foundationHeight, 0,0])
escala (newSize)
girar ([0,90,0])
cilindro (r = 0,5, h = 1, centro = true);
} Else if (treadStyle == "picos") {
traduzir ([(newSize [0]-foundationHeight) / 2,0,0])
escala (newSize)
girar ([0,90,0])
unio () {
cilindro (R1 = 0,5, r2 = 0, h = 1, centro = true);
}
} Else if (treadStyle == "cruz") {
traduzir ([newSize [0] / 2 foundationHeight, 0,0])
unio () {
cubo ([newSize [0], linethickness, newSize [2]], centro
= true);
cubo ([newSize [0], newSize [1], linethickness], centro
= true);
}
} Else if (treadStyle == "x") {
atribuir (= len sqrt (pow (newSize [2], 2) + pow (newSize [1], 2
)),
teta = atan (newSize [1] / newSize [2]))
traduzir ([newSize [0] / 2 foundationHeight, 0,0])
interseo () {
unio () {
girar ([theta, 0,0])
cubo ([newSize [0], linethickness, len],
centro = true);
girar ([-theta, 0,0])
cubo ([newSize [0], linethickness, len],
centro = true);
}
/ / Corte a caixa Tamanho
cubo (newSize, centro = true);
}
} Else if (treadStyle == "zigX") {
atribuir (Seglen = sqrt (pow (newSize [2] / 4, 2) + pow (newSize
[1] / 2, 2)),
teta = atan ((newSize [1] / 2) / (newSize [2] / 4)))
traduzir ([newSize [0] / 2 foundationHeight, 0,0])
interseo () {
union () {/ / estender Seglen assim padres de corresponde
r a padres vizinhos
traduzir ([0,-newSize [1] / 4,-newSize [2] / 2 +
newSize [2] / 8])
girar ([theta, 0,0])
cubo ([newSize [0], linethicknes
s, Seglen * 2], centro = true);
girar ([-theta, 0,0])
cubo ([newSize [0], linethickness, Segle
n * 2], centro = true);
traduzir ([0, newSize [1] / 4, newSize [2] / 2 -
newSize [2] / 8])
girar ([theta, 0,0])
cubo ([newSize [0], linethicknes
s, Seglen * 2], centro = true);
}
/ / Corte a caixa Tamanho
cubo (newSize, centro = true);
}
} Else if (treadStyle == "v") {
atribuir (Seglen = sqrt (pow (newSize [2] / 2, 2) + pow (newSize
[1], 2)),
teta = atan ((newSize [1]) / (newSize [2] / 2)))
traduzir ([newSize [0] / 2 foundationHeight, 0,0])
interseo () {
unio () {
traduzir ([0,0, newSize [2] / 4])
girar ([-theta, 0,0])
cubo ([newSize [0], linethicknes
s, Seglen], centro = true);
traduzir ([0,0,-newSize [2] / 4])
girar ([theta, 0,0])
cubo ([newSize [0], linethicknes
s, Seglen], centro = true);
}
/ / Corte a caixa Tamanho
cubo ([newSize [0], newSize [1], newSize [2]], centro = true
);
}
} Else if (treadStyle == "Zigy") {
/ / Ainda no implementado
} Else if (treadStyle == "vReverse") {
/ / Ainda no implementado
}
}
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / Falou Estilos ...
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
padro / / Diamantes raios
diamondSpokes mdulo (diametroJante, wheelWidth, largura de linha, proporo, numberof
Spokes) {
echo ("Diamantes de estilo ...");
interseo () {
cilindro (h = wheelWidth, r = diametroJante / 2, centro = true);

para (passo = [0: numberofSpokes-1]) {
rodar (um passo = * (360/numberofSpokes), v = [0, 0, 1])
diamondSpoke (diametroJante, wheelWidth, 'lineWidth, pro
poro);
}
}
}
mdulo diamondSpoke (diametroJante, wheelWidth, 'lineWidth, proporo) {
/ / Vamos fazer as linhas a espessura correta, mesmo aps as transformaes
/ / So feitos ... Talvez haja uma maneira melhor?
render ()
atribuir (perna = sqrt (2 * pow (diametroJante / 4,2))) / / rochas Eucli
des.
atribuir (p = (diametroJante / 2) * proporo [0], q = (diametroJante / 2) *
proporo [1])
atribuir (a = sqrt ((p * p) / 4 + (q * q) / 4))
atribuir (h = (p * q) / (2 * a))
atribuir (theta = 2 * asin (q / (2 * a)))
atribuir (prop = (2 * cos (teta / 2) * (h-(2 'lineWidth *))) / (sin (tet
a) * p)) {
traduzir ([p-/ 2, 0, 0]) {
diferena () {
escala ([proporo [0], a proporo [1], 1]) {
girar ([0,0,45])
cubo ([perna, perna, wheelWidth]
, centro = true);
}
escala ([prop, prop, 1]) {
escala ([proporo [0], a proporo [1], 1]) {
girar ([0,0,45]) / / Minha espos
a o eptome do awesomeness.
cubo ([perna, perna, whe
elWidth +1], centro = true);
}
}
}
}
}
}
/ / Crculos padro raios
circleSpokes mdulo (diametroJante, wheelWidth, largura de linha, proporo, numberofS
pokes) {
echo ("Estilo Circles ...");
interseo () {
cilindro (h = wheelWidth, r = diametroJante / 2, centro = true);

para (passo = [0: numberofSpokes-1]) {
rodar ([0, 0, * passo (360/numberofSpokes)])
circleSpoke (diametroJante, wheelWidth, 'lineWid
th, proporo);
}
}
}
mdulo circleSpoke (diametroJante, wheelWidth, 'lineWidth, proporo) {
render ()
atribuir (ox = (diametroJante / 2) * proporo [0], oy = (diametroJante / 2)
* proporo [1])
atribuir (ix = boi-('lineWidth * 2), iy = oy-(' lineWidth * 2)) {
traduzir ([-boi / 2, 0, 0]) {
diferena () {
escala ([proporo [0], a proporo [1], 1])
cilindro (r = diametroJante / 4, h = whe
elWidth, centro = true);
escala ([(ix / boi) * proporo [0], (iy / oy) * pro
poro [1], 1])
cilindro (r = diametroJante / 4, h = whe
elWidth +1, centro = true);
}
}
}
}
Padro raios / / Retngulo
rectangleSpokes mdulo (diametroJante, wheelWidth, largura de linha, proporo, number
ofSpokes) {
echo ("retngulos Style ...");
interseo () {
cilindro (h = wheelWidth, r = diametroJante / 2, centro = true);

para (passo = [0: numberofSpokes-1]) {
rodar (um passo = * (360/numberofSpokes), v = [0, 0, 1])
rectangleSpoke (diametroJante, wheelWidth, 'lineWidth, p
roporo);
}
}
}
mdulo rectangleSpoke (diametroJante, wheelWidth, 'lineWidth, proporo) {
render ()
atribuir (ox = (diametroJante / 2) * proporo [0], oy = (diametroJante / 2)
* proporo [1])
atribuir (ix = boi-('lineWidth * 2), iy = oy-(' lineWidth * 2)) {
traduzir ([-boi / 2, 0, 0]) {
diferena () {
cubo ([boi, oy, wheelWidth], centro = true);
cubo ([ix, iy, wheelWidth +1], centro = true);
}
}
}
}
/ / raios padro espiral
spiralSpokes mdulo (dimetro, wheelWidth, nmero, spokeWidth, curvatura, reverso) {
echo ("Spiral Style ...");
interseo () {
cilindro (h = wheelWidth, r = dimetro / 2, centro = true);
for (passo = [0: Nmero-1]) {
rodar (um passo = * (360/number), v = [0, 0, 1])
spiralSpoke (wheelWidth, spokeWidth, (dimetro / 4) * 1/cu
rvature, reverso);
}
}
}
mdulo spiralSpoke (wheelWidth, spokeWidth, spokeRadius, inverta = false) {
render ()
interseo () {
traduzir ([-spokeRadius, 0, 0]) {
diferena () {
cilindro (r = spokeRadius, h = wheelWidth, centr
o = true);
cilindro (r = spokeRadius-(spokeWidth / 2), h =
wheelWidth 1, centro = true);
}
}
if (reverso)
traduzir ([-spokeRadius,-spokeRadius / 2, 0])
cubo ([spokeRadius * 2, spokeRadius, wheelWidth
+1], centro = true);
outro
traduzir ([-spokeRadius, spokeRadius / 2, 0])
cubo ([spokeRadius * 2, spokeRadius, wheelWidth
+1], centro = true);
}
}
Padro raios / / Biohazard
biohazardSpokes mdulo (dimetro, largura, nmero) {
echo ("Biohazard Style ...");
scale = (dimetro / 2) / 88;
interseo () {
cilindro (h = largura, r = dimetro / 2, centro = true);
escala ([escala, escala, 1]) {
for (passo = [0: Nmero-1]) {
rodar (um passo = * (360/number), v = [0, 0, 1])
biohazardSpoke (largura);
}
}
}
}
mdulo biohazardSpoke (largura) {
render ()
traduzir ([-60, 0, 0])
diferena () {
traduzir ([10, 0, 0])
cilindro (h = largura, r = 50, centro = true);
traduzir ([-1, 0, 0]) / / compensar um pouco por isso colector
cilindro (h = largura 2, r = 40, centro = true);
}
}
Padro raios / / Circlefit
/ / Ainda precisa da matemtica para a colocao / dimensionamento dos furos exteriore
s ... deixe-me saber se voc descobrir isso e eu vou adicion-lo.
circlefitSpokes mdulo (dimetro, hubDiameter, largura, outerHoleDiameter) {
echo ("Circlefit Style ...");
preenchimento = 2;
paddedHoleRadius = (dimetro hubDiameter) / 4;
holeRadius = paddedHoleRadius - estofamento / 2;
hubRadius = hubDiameter / 2;
/ / Descobrir quantos crculos vai caber.
crculos = andar (360 / (2 * (asin (paddedHoleRadius / (paddedHoleRadius +
hubRadius)))));
diferena () {
cilindro (h = largura, r = dimetro / 2, centro = true);
for (i = [0: crculos-1]) {
rodar (i * (360/circles), [0, 0, 1])
traduzir ([+ hubRadius paddedHoleRadius, 0, 0])
cilindro (h = largura +1, r = holeRadius, centro = true
);
}
Buracos / / menores para conservar filamento
rodar (360/circles/2, [0, 0, 1])
for (i = [0: crculos-1]) {
rodar (i * (360/circles), [0, 0, 1])
traduzir ([diameter/2-outerHoleDiameter/2, 0, 0])
cilindro (h = largura +1, r = outerHoleDiameter / 2, ce
ntro = true);
}
}
}
Padro / / Linha de raios
lineSpokes mdulo (dimetro, wheelWidth, nmero, spokeWidth) {
echo ("Linhas Estilo ...");
interseo () {
cilindro (h = wheelWidth, r = dimetro / 2, centro = true);
for (passo = [0: Nmero-1]) {
rodar (um passo = * (360/number), v = [0, 0, 1])
lineSpoke (wheelWidth, spokeWidth);
}
}
}
mdulo lineSpoke (wheelWidth, spokeWidth) {
traduzir ([-60 / 2, 0, 0])
cubo ([60, spokeWidth, wheelWidth], centro = true);
}
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / Mdulos ...
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
/ / O cubo (a parte que segura a roda sobre o motor
hub mdulo (altura, dimetro, boreDiameter, shaftFlatDiameter, nozes, nutSize, setSc
rewDiameter, setScrewNutOffset = 0,
hubZOffset = 0, baseFilletRadius = 0, topFilletRadius = 0, chamferOnly =
false) {
hubWidth = (dimetro boreDiameter) / 2;
unio () {
diferena () {
/ / Forma hub principal
unio () {
diferena () {
unio () {
cilindro (h = altura, r = dimetro
/ 2, centro = true);
/ / Primeiro chanfro na base ...
rotate_extrude ()
traduzir ([dimetro / 2, -
(altura / 2)-hubZOffset, 0])
polgono (pontos =
[[0,0], [0, baseFilletRadius], [baseFilletRadius, 0]]);
}
/ / Chanfro cima ...
rotate_extrude ()
traduzir ([dimetro / 2, altura /
2,0])
polgono (pontos = [[0.5,0
.5], [-topFilletRadius-0,5, 0,5], [0,5,-topFilletRadius-0.5]]);
/ / Esculpir o fil fundo do chanfro
if (chamferOnly!) {
rotate_extrude () {
traduzir ([(dimetro / 2)
+ baseFilletRadius,
- (Altura (2 * b
aseFilletRadius)) / 2-hubZOffset, 0]) {
crculo (r = baseF
illetRadius);
}
}
}
}
/ / Adicionar o fil de volta ao topo do topo chan
fro
if (chamferOnly!) {
rotate_extrude () {
traduzir ([
(Dimetro / 2)-topFilletRa
dius,
(Altura (2 * topFilletRa
dius)) / 2,
0])
crculo (r = topFilletRadi
us);
}
}
}
/ / Remover o furo
diferena () {
cilindro (h = altura 1, r = boreDiameter / 2, ce
ntro = true);
traduzir ([(boreDiameter shaftFlatDiameter-1) /
2 + (boreDiameter / 2) - (boreDiameter - shaftFlatDiameter), 0,0])
cubo ([boreDiameter-shaftFlatDiameter +1
, boreDiameter, altura +2], centro = true);
}
/ / Remover a porca cativa
for (i = [0: nozes-1]) {
girar ([0,0, (360/nuts) * i])
traduzir ([boreDiameter / 2 + (dimetro-boreDiamet
er) / 4 + setScrewNutOffset,
0, altura / 2 - (altura + hubZOf
fset) / 2]) {
girar ([0, -90,0]) {
captiveNut (nutSize, setScrewDia
meter,
profundidade = altura /
2 +1, holeLengthTop = hubWidth / 2 + setScrewNutOffset + (boreDiameter-shaftFlat
Diameter),
holeLengthBottom = hubWi
dth + baseFilletRadius-setScrewNutOffset);
}
}
}
}
}
}
/ / A borda (a rea slida entre os raios e pneus)
borda do mdulo (largura, altura, dimetro) {
diferena () {
/ / Jante
cilindro (h = largura, r = dimetro / 2, centro = true);
/ / Punch out centro
cilindro (h = largura +1, r = dimetro / 2 - altura, centro = true
);
}
}
/ / O pneu, onde "dimetro" o dimetro do centro-a-centro (no ID ou OD)
mdulo de pneu (dimetro, csDiameter) {
render () {
rotate_extrude (convexidade = 10)
traduzir ([dimetro / 2, 0, 0])
crculo (r = csDiameter / 2, $ fn = 20);
}
}
/ / O V-grooves - almofadas a profundidade por um milmetro por isso torna bem qua
ndo usado para diferena
mdulo vGroove (dimetro, ngulo, profundidade) {
dist = tan (ngulo / 2) * (profundidade 1);
render () {
rotate_extrude (convexidade = 10)
traduzir ([dimetro / 2, 0, 0])
polgono ([[1, dist], [profundidade, 0], [1, dist-
]]);
}
}
/ / Este o mdulo porca cativa eu ??uso em vrios de meus projetos.
mdulo captiveNut (nutSize, setScrewHoleDiameter = 3,
profundidade = 10, holeLengthTop = 5, holeLengthBottom = 5)
{
render ()
unio () {
porca (nutSize);
if (profundidade> 0)
traduzir ([profundidade / 2,0,0])
cubo ([profundidade, nutSize [0], nutSize [1]],
centro = true);
traduzir ([0,0, - (nutSize [1] / 2)-holeLengthBottom])
cilindro (r = setScrewHoleDiameter / 2, h = nutSize [1]
+ + holeLengthTop holeLengthBottom, $ fn = 15);
}
}
/ / NutSize = [inDiameter, espessura]
porca mdulo (nutSize) {
lado = nutSize [0] * tan (180/6);
if (nutSize [0] * nutSize [1]! = 0) {
for (i = [0: 2]) {
rodar (i * 120, [0, 0, 1])
cubo ([lado, nutSize [0], nutSize [1]], centro =
true);
}
}
}
/ / Por isso no fcil em openSCAD? :/ Este o mesmo cdigo que eu uso na roda do codif
icador
arco mdulo (altura, profundidade, raio, graus) {
/ / Este morre uma morte horible se no for prestado aqui
/ / - Suga toda a memria e gira fora de controle
render () {
diferena () {
/ / Anel externo
rotate_extrude ($ fn = 100)
traduzir ([raio - altura, 0, 0])
quadrado ([altura, profundidade]);
/ / Meia Cut off
traduzir ([0, - (raio 1), - 0,5])
cubo ([raio 1, (raio 1) * 2, uma profundidade]);
/ / Tampa a outra metade, se necessrio
girar ([0,0,180 graus])
traduzir ([0, - (raio 1), - 0,5])
cubo ([raio 1, (raio 1) * 2, uma profundidade]);
}
}
}