projecto em openscad

5/23/2018 Projecto Em Openscad

1/19

/ / os parmetros dos pneus:

larguraRoda = 5; / / A largura (ou a espessura) da roda na jante.diametroTransversalPneu = 4; / / Dimetro transversal (CS) - Qual a espessura daborracha de pneu?diametroInternoPneu = 93; / / Dimetro interno (ID) - Qual a largura a abertura 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 temporizaara esculpir no arotempoSincronizacaoBuraco = [1,0.5,3]; / / A [dentro, meio fora] preenchimento para os buracos sincronismodirecional = true; / / A codificador direcional torna dois conjuntos de slots, 90 graus fora de fase

/ / Parmetros Tread:

estiloPiso = "v-grooves"; / / nenhum, cruz, o-rings, v-grooves, praas, esferas, cylindersX, / / CylindersY, cylindersZ, pontos, caa-nqueis,x, zigX, vtamanhoArco = [90,1.5,1]; / / O tamanho de cada boto [em frente da roda,ao longo do permetro, prodruding] / / Ou para v-grooves, [ngulo, profundidade, ignorado]conjuntoPisoRadial = 15; / / Quantos conjuntos de passos para tornar em 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 escalonadas.espessuraLinha = 1; / / A espessura da linha para estilos "desenhados", como "x" e "zigX"numMaxPneus = 3; / / Para o-rings/v-grooves, o nmero mximo de pneus por rodaespacoEntrePneus = 2; / / Para o-rings/v-grooves, o espao entre cadapneu, se mais de um

/ / Parmetros relacionados com a Interveno de

estiloRaio = "retngulo"; / / Nenhum, risco biolgico, crculo, circlefit, diam

te, linha, retngulo, espiral, preencherinsercaoRaio = [0,0]; / / A [exterior interior,] insero da rea de raio aartir da superfcienumRaios = 7; / / Nmero de "raios". Defina esta opo para trs, sc estiver fazendo o design de risco biolgicolarguraRaio = 3; / / Este o quo grande cada raio.proporo = [1.5,1.0]; / / Proporo de borda, proporo de larguracurvatura = 0,66; / / Para "espiral", assim que os raios so curvey.> 0, mas


2/19

reverter = false; / / Para "espiral", definindo-o como "true" inverte o sentido das espiraisdiametroExternoFuro = 13; / / Para "circlefit", o dimetro dos furos exteriores, ou zero para nenhumconcavidade = [0,0]; / / Concavidade distncia da rea falou por [dentro,fora] da roda

/ / Parmetros Hub:

incluirEixo = false; / / Coloque false para remover o hub e incluem apenas o buraco dimetro do eixo.

diametroEixo = 15; / / O dimetro da poro do ncleo da rodaalturaEixo = 12; / / A altura total do cuboposicaoZEixo = 0; / / A posio Z do cubo, os nmeros negativos a partda superfcie da rodadiametroCirculoInterno = 30; / / O dimetro do crculo interno slido sob o hub, zero para nenhum.

baseRaioFaixa = 2; / / O raio do filete (parte arredondada) entre ocubo ea roda.superiorRaioFaixa = 2; / / O raio do filete (parte arredondada), na parte superior do cubo.apenasChanfre = false; / / Definir para true para usar chanfros (retas ngulos de 45 graus) em vez de filetes.

//parametros de acessorios

diametroVeioMotor = 22; / / O dimetro do veio do motordiametroPlanoVeioMotor = 3; / / O dimetro do veio do motor, no plano, ou shaftDiameter para no plana.

numParafusosFixacao = 1; / / O nmero de parafusos de fixao / porcas para rderizar, uniformemente espaados em torno do eixodiametroParafuso = 3; / / O dimetro do parafuso de ajuste. 3 o padro pa 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 aplano (o "in-" de dimetro)espessuraPorca = 2,3; / / A espessura da porca cativodeslocamentoPorca = 0; / / A distncia de deslocamento da porca a partirdo centro do material. - / + = In / out

diametroRosca = 0; / / O dimetro dos furos servo brao hounting, ou zero se nenhum buracodistanciaEntreRoscas1 = 25; / / Distncia atravs servo chifre de buraco em buraco (0 a ignorar)distanciaEntreRoscas2 = 21; / / Distncia atravs servo chifre de buraco em buraco, rotao de 90 graus (0 a ignorar)

rotacaoTotalRoscas = 45; / / A rotao total de todos os furos de servotamanhoBracoRoscas = [4,1.6]; / / Tamanho [indiameter, profundidade] de servobrao porca cativo, ou 0 (nenhum) para nenhum.

tamanhoPorca = [12.5,5.5]; / / Tamanho [indiameter, profundidade] de uma porca em cativeiro, ou 0 (nenhum) para nenhum.

/ / Parmetros de qualidade:


3/19

$ Fn = 50; / / Qualidade padro para a maioria das partes docrculo.

// Algum geometria bsica pneu

diametroInterior = diametroInternoPneu;diametroCentro = diametroInternoPneu + diametroTransversalPneu;outroDiametro = diametroInternoPneu + ( diametroTransversalPneu *2 );circunferenciaInterior = diametroInterior*PI;circunferenciaCentro = diametroCentro*PI;

outraCircunferencia = outroDiametro*PI;

/ / Geometria pneu esticadacircunferenciaExcertoCentro = circunfereiaCentro * excertoPneu;diametroExcertoCentro = circunferenciaExcertoCentro / PI;diametroExcertoInterno = diametroExcertoCentro - diametroTransversalPneu;diametroOutroExcerto = diametroExcertoCentro + diametroTransversalPneu;circunferenciaExcertoInterno = diametroExcertoInterno * PI;circunferenciaOutroExcerto = diametroOutroExcerto * PI;

// geometria da jantediametroJante = diametroExcertoCentro;

raioJante = diametroJante / 2;raioPneu = diametroTransversalPneu / 2;raioEixo = diametroEixo / 2;

Geometria do arco da janteoutroDiametroArco = diametroJante + (2 * tamanhoArco [2]);outraCircunferenciaArco = outroDiametroArco * PI;

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / // / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / // / Relatrio de algumas informaes bsicas para o usurio .../ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /

/ / Alguns dados do pneu, esticado e no esticadoecho (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, ",", outerDiameter));echo (str ("* Circunferncia:" round2 (innerCircumference), ",", round2 (centerCircumference),

",", Round2 (outerCircumference)));

echo (str ("Tire esticada: [interior, centro, exterior]"));echo (str ("* Dimetro:" round2 (innerDiameterStretched), ",", round2 (centerDiameterStretched),

",", Round2 (outerDiameterStretched)));echo (str ("* Circunferncia:" round2 (innerCircumferenceStretched), ",",

round2 (centerCircumferenceStretched), ",", round2 (outerCircumferenceStretched)));

echo (str ("Tire Knobbed: [exterior]"));


4/19

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 redefinir wheelWidth aqui

/ / E tomar os deslocamentos de superfcie falou em conta. Vamos adicionaruma nova varivel para a largura da borda.

larguraJante = larguraRoda;larguraRoda = larguraJante - insercaoRaio [0] - insercaoRaio [1];

diametroRaio = diametroJante - 2 * larguraJante;

union () {

/ / a jantedifference () {

jante (larguraJante, alturaJante, diametroJante);

/ / Retirar o sincronismo buracosif (buracosSincronizado > 0) {

if (direcional) {assign(alturaBuraco = (alturaJante - tem

poSincronizacaoBuraco [0] - tempoSincronizacaoBuraco [2] - tempoSincronizacaoBuraco [1]) / 2) {

/ / orifcios externoslucalBuracosSincronizados (burac

osSincronizados, alturaBuraco, larguraJante, (diametroJante / 2)- tempoSincroniz

acaoBuraco [2]);

/ / furos interioresgirar ([0,0,90 / timingHoles])lucalBuracosSincronizados (burac

osSincronizados, holeHeight, rimWidth,(diametroJante / 2) - te

mpoSincronizacaoBuraco [2] - holeHeight - tempoSincronizacaoBuraco [1]);}atribuir (len1 = outerCircumferenceStret


5/19

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 pneusif ((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-rings")

pneu (diametroJante, tireCSDiameter);

else if (treadStyle == "v-grooves")

vGroove (diametroJante, knobSize [0], knobSize [1]);

}

}}

} Else if (treadStyle == "slots") {/ / perfurar ranhurasse necessrio

atribuir (separao = (rimWidth-(numberOfKnobs * knobSize [0])) / (numberOfKnobs +1))

atribuir (dist = knobSize [0] + separao) {traduzir ([0,0,-rimWidth / 2])for (i = [0: numberOfKnobs-1]) {

traduzir ([0,0, separao + (dist *


6/19

i)])diferena () {

cilindro (r = (diametroJante / 2), h = knobSize [0]);

cilindro (r = (diametroJante / 2)-knobSize [2], h = knobSize [0]);

}}

}}

}

/ / Traduzir raios e cubo para acomodar inserestraduzir ([0,0, rimWidth / 2 - wheelWidth / 2 - spokeInset [0]])

{/ / Os raiosdiferena () {

unio () {atribuir (d = diametroJante - (rimHeight

* 2)) {if (spokeStyle == "encher") {

cilindro (h = wheelWidth, r = d / 2, centro = true);

} Else if (spokeStyle == "Biohaz

ard") { biohazardSpokes (d, wheelWidth, numberOfSpokes);

} Else if (spokeStyle == "circlefit") {

circlefitSpokes (d, hubDiameter, wheelWidth, outerHoleDiameter);

} Else if (spokeStyle == "linha") {

lineSpokes (d, wheelWidth, numberOfSpokes, spokeWidth);

} Else if (spokeStyle == "retngulo") {

rectangleSpokes (d, wheelWidth, spokeWidth, proporo, numberOfSpokes);

} Else if (spokeStyle == "diamante") {

diamondSpokes (d, wheelWidth, spokeWidth, proporo, numberOfSpokes);

} Else if (spokeStyle == "crculo") {

circleSpokes (d, wheelWidth, spokeWidth, proporo, numberOfSpokes);

} Else if (spokeStyle == "espiral") {

spiralSpokes (d, wheelWi

dth, numberOfSpokes,spokeWidth, curv

atura, reverso, spiralSpoke);}

}

/ / Se h um crculo slido interior, adicioo aqui.

if (innerCircleDiameter> 0) {cilindro (h = wheelWidth, r = in


7/19

nerCircleDiameter / 2, centro = true);}

}

/ / Esculpir concavidadeif (concavidade [0]> 0) {/ / dentro

traduzir ([0,0, concaveRadius (spokeDiameter, concavidade [0]) + wheelWidth / 2-concavidade [0]])

esfera (r = concaveRadius (spokeDiameter, concavidade [0]));

}

if (concavidade [1]> 0) {/ / foratraduzir ([0,0,-concaveRadius (spokeDiameter, concavidade [1]) - wheelWidth / 2 + concavidade [1]])

esfera (r = concaveRadius (spokeDiameter, concavidade [1]));

}

/ / Esculpir um local para um centro de insero, senecessrio

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], outerNutTrap [1] 1);

}}

/ / O hubif (includeHub) {

traduzir ([0,0, hubHeight / 2 + wheelWidth / 2 +hubZOffset - concavidade [0]])

hub (hubHeight, hubDiameter, shaftDiameter, shaftFlatDiameter,

setScrewCount, setScrewTrap, setScrewDiameter, setScrewNutOffset,

hubZOffset, baseFilletRadius, topFilletRadius, chamferOnly);

}}

/ / A banda de rodagemif (treadStyle == "o-rings") {

para (x = [- (numTires-1) * (tireDistance / 2): tireDistance: (numTires-1) * (tireDistance / 2)])

traduzir ([0,0, x])


8/19

% De cor ("preto", 0,5) pneu (diametroJante, tireCSDiameter);

} Else if (treadStyle == "slots") {/ / No h necessidade de tornar qualquer coisa aqui ...

} Else {/ / O resto so todos os projetos de botoplaceKnobs (wheelWidth, diametroJante, treadStyle, knobS

ize, radialTreadSets, numberOfKnobs,staggerOffset, linethickness);

}}

}

/ / Constri no espao extra para melhor prestaomountingHoles mdulo (shaftDiameter, wheelWidth, concavidade, servoHoleDiameter, servoHoleDistance1,

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 nutTrap-[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/holeCount);

}}

}

placeKnobs mdulo (wheelWidth, diametroJante, treadStyle, knobSize, radialTreadSets, numberOfKnobs,

staggerOffset, linethickness) {


9/19

atribuir (knobDistance = knobSize [0] + ((wheelWidth - knobSize [0] * numberOfKnobs - staggerOffset) /

(NumberOfKnobs-1))) {

doTreadSet (wheelWidth, diametroJante, treadStyle, knobSize, radialTreadSets, numberOfKnobs,

knobDistance, linethickness);girar ([180, 0, 180/radialTreadSets])

doTreadSet (wheelWidth, diametroJante, treadStyle, knobSize, radialTreadSets, numberOfKnobs,

knobDistance, linethickness);

}}

/ / Processa metade da banda de rodagem. A outra metade processado rodado de 180% para produzir o deslocamento cambalearmdulo doTreadSet (wheelWidth, diametroJante, treadStyle, knobSize, radialTreadSets, 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, zigX, 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));

/ / Rodatraduzir ([-25,0,0])

% Cilindro (r = 25, h = 10, centro = true);/ / Extenses


10/19

traduzir ([knobSize [2] / 2,0,0])girar ([90,90,90])

% Cubo (knobSize, centro = true);/ / Foundationtraduzir ([-foundationHeight / 2,0,0])

girar ([90,90,90])cor ("vermelho", 0,15)

* Cubo ([knobSize [0], knobSize [1], foundationHeight], 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 repetindo 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);


11/19

} 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 Tamanhocubo (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 corresponder 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, Seglen * 2], centro = true);

traduzir ([0, newSize [1] / 4, newSize [2] / 2 -

newSize [2] / 8])girar ([theta, 0,0])

cubo ([newSize [0], linethickness, Seglen * 2], centro = true);

}

/ / Corte a caixa Tamanhocubo (newSize, centro = true);

}} Else if (treadStyle == "v") {


12/19

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], linethickness, Seglen], centro = true);

}

/ / Corte a caixa Tamanhocubo ([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 raiosdiamondSpokes mdulo (diametroJante, wheelWidth, largura de linha, proporo, numberSpokes) {

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, proporo);

}}

}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))


13/19

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 raioscircleSpokes mdulo (diametroJante, wheelWidth, largura de linha, proporo, numberopokes) {

echo ("Estilo Circles ...");interseo () {


para (passo = [0: numberofSpokes-1]) { rodar ([0, 0, * passo (360/numberofSpokes)])

circleSpoke (diametroJante, wheelWidth, 'lineWidth, 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) * proporo [1], 1])

cilindro (r = diametroJante / 4, h = wheelWidth +1, centro = true);

}}

}}

Padro raios / / Retngulo


14/19

rectangleSpokes mdulo (diametroJante, wheelWidth, largura de linha, proporo, numbofSpokes) {

echo ("retngulos Style ...");interseo () {


para (passo = [0: numberofSpokes-1]) { rodar (um passo = * (360/numberofSpokes), v = [0, 0, 1])

rectangleSpoke (diametroJante, wheelWidth, 'lineWidth, proporo);

}}}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 espiralspiralSpokes 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, centro = 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);


15/19

}}

Padro raios / / BiohazardbiohazardSpokes 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 colectorcilindro (h = largura 2, r = 40, centro = true);

}}

Padro raios / / Circlefit/ / Ainda precisa da matemtica para a colocao / dimensionamento dos furos exterios ... 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


16/19

ntro = true);}

}}

Padro / / Linha de raioslineSpokes 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 motorhub mdulo (altura, dimetro, boreDiameter, shaftFlatDiameter, nozes, nutSize, setScrewDiameter, setScrewNutOffset = 0,

hubZOffset = 0, baseFilletRadius = 0, topFilletRadius = 0, chamferOnly =false) {

hubWidth = (dimetro boreDiameter) / 2;

unio () {diferena () {

/ / Forma hub principalunio () {

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


17/19

.5], [-topFilletRadius-0,5, 0,5], [0,5,-topFilletRadius-0.5]]);

/ / Esculpir o fil fundo do chanfroif (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 chanfro

if (chamferOnly!) {rotate_extrude () {

traduzir ([(Dimetro / 2)-topFilletRa

dius,(Altura (2 * topFilletRa

dius)) / 2, 0])crculo (r = topFilletRadi

us);}

}}

/ / Remover o furodiferena () {

cilindro (h = altura 1, r = boreDiameter / 2, centro = true);

traduzir ([(boreDiameter shaftFlatDiameter-1) /

2 + (boreDiameter / 2) - (boreDiameter - shaftFlatDiameter), 0,0])cubo ([boreDiameter-shaftFlatDiameter +1

, boreDiameter, altura +2], centro = true);}

/ / Remover a porca cativafor (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, setScrewDiameter,

profundidade = altura /2 +1, holeLengthTop = hubWidth / 2 + setScrewNutOffset + (boreDiameter-shaftFlatDiameter),

holeLengthBottom = hubWidth + baseFilletRadius-setScrewNutOffset);

}}

}


18/19

}}

}

/ / A borda (a rea slida entre os raios e pneus)borda do mdulo (largura, altura, dimetro) {

diferena () {/ / Jantecilindro (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 quando usado para diferenamdulo 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);


19/19

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 doicador

arco mdulo (altura, profundidade, raio, graus) {/ / Este morre uma morte horible se no for prestado aqui/ / - Suga toda a memria e gira fora de controlerender () {

diferena () {/ / Anel externorotate_extrude ($ fn = 100)

traduzir ([raio - altura, 0, 0])quadrado ([altura, profundidade]);

/ / Meia Cut offtraduzir ([0, - (raio 1), - 0,5])

cubo ([raio 1, (raio 1) * 2, uma profundidade]);

/ / Tampa a outra metade, se necessriogirar ([0,0,180 graus])traduzir ([0, - (raio 1), - 0,5])

cubo ([raio 1, (raio 1) * 2, uma profundidade]);}

}}

projecto em openscad

Documents