✍ diale.org

Webpage of Tiago Charters de Azevedo

Início/Start Arquivo/Archive AdNauseum Notas/Notes Contact me RSS


Suporte para Breadboard DIY

... para montagens de electrónica.

2017/05/24-14:04:07

Introdução

A iniciação no DIY para montagem e estudo de efeitos para guitarra, baixo ou outros instrumentos electrónicos tem sempre uma custo inicial elevado, isto porque é necessário adquirir alguma material que inclui ferramentas, transístores, circuitos integrados, transformadores, resistências, condensadores , etc, e, normalmente, uma breadboard. A breadboard é uma ferramenta de estudo e experimentação importante. Permite montar uma versão provisória de um circuito sem danificar os componentes utilizados e utiliza-los numa outra futura construção. Uma das dificuldades na montagem e avaliação de um circuito para ser usado com um instrumento musical é a necessidade de levar a montagem até ao amplificador para ser testado, para ver como soa, ou então testa-lo com um amplificador de bancada. Não é raro a breadboard cair ao chão durante os testes, puxa-se um fio, ou as fichas são pesadas e puxam a montagem que já estava a escorregar na mesa das sala ou da cozinha desmontando tudo e levando ao curto-circuito final. Assim é importante a utilização de um suporte para acomodar a breadboard na sua tarefa de teste e experimentação. Nas páginas seguintes descreve-se a construção de uma base para breadboard, não só a breadboard mas o suporte para ligar os cabos e ligação ao amplificador, alimentação, potenciómetros, etc.

A construção é relativamente simples não sendo preciso máquinas sofisticadas. São apenas necessárias ferramentas básicas: furador (eléctrico ou manual), limas (para acertar a dimensão dos furos e limar as arestas de corte da calha de alumínio), serra para metal e ferro de soldar. Caso o leitor queira montar uma engenhoca destas é sempre bom, para cortar o investimento inicial no hobby, pedir a um amigo que o ajude na construção. Dá tanto trabalho fazer uma como duas!

Uma casa para a breadboard

Material

Calhas metálicas: medição e corte

Comecemos então por marcar 20cm, o comprimento do perfil de alumínio, com um esquadro metálico e uma caneta de acetato. A calha tem 43.5mmx 23.5mm com comprimento total de 1.5m. Usei um esquadro metálico para marcar e medir, mas uma régua de plástico serve perfeitamente.

Faço as mesmas medições para as duas calhas. As arestas cortantes serão limadas durante o acabamento. depois de feitos os furos.

Uma tábua de 20cmx20cm tem as dimensões certas para acomodar o resto da montagem e adapta-se bem ao uso que se lhe quer dar. Qualquer tipo de madeira serve.

Aquela que vou usar já foi usada noutras montagens provisórias e tem uma espessura de 1.5cm e um bom peso para suportar o objectivo das suas funções. Poderíamos usar MDF, acrílico ou qualquer outro material isolante.

Calhas metálicas: furação

Optei por fazer 7 furos distanciados de 3cm (1cm das extremidades), pode parecer excessivo mas nunca se sabe o que o futuro nos reserva em futuras montagens e fica já tudo furado para não ter depois de as desmontar.

Depois de marcados a caneta os pontos marco com um punção os locais de furação (neste caso um parafuso de aço, uma broca velha também serve).

Usei uma broca de 8mm de modo conseguir colocar as todas fichas, potenciómetros e um interruptor (que dá sempre jeito). Como os jacks têm um diâmetro maior, com uma lima aumenta-se sucessivamente o diâmetro testando as dimensões entre umas quantas limadelas.

A imagem seguinte mostra um conjunto básico de coisas que podemos ligar: dois jacks, potenciómetro, ficha de alimentação e um interruptor. Note-se que já estão feitos os furos na parte inferior da calha para fixação na base de madeira.

Montagem e soldaduras

Mesmo antes de soldar os fios, e depois de lixadas e aparafusadas as calhas, podemos ver que a coisa se começa a compor. Usei uma lixa fina de metal para dar o acabamento final (lixa de água, uma lixa fina de madeira também pode ser usada, deita-se a lixa fora no fim) e uma lima para acertar as arestas cortantes nos topos de cada calha.

Costumo usar fio de telefone ou de cabo rede para as montagens na breadboard, o metro linear é barato e é possível encontra-lo em todas as lojas de bricolage a qualquer hora do dia, não vá aparecer uma vontade súbita de montar qualquer coisa e faltar material, e num metro temos disponíveis muitas cores (as cores são nossas amigas) que são óptimas e muito úteis para as montagens na breadboard. Apenas é necessário paciência para desenrolar o fio.

Optei por colocar o led directamente na breadboard mas sem dificuldade se monta na parte frontal da geringonça.

Um botão comprado na saudosa Dimofel et voilá, a engenhoca pronta a ser usada para testes e invenções!

Considerações finais

A montagem de circuitos numa breadboard é simples, permite de uma forma simples experimentar e confirmar circuitos e ideias que de outra forma não seria possível sem danificar e inutilizar componentes electrónicos. Outras abordagens de construção e design são possíveis!

Boas construções!

Etiquetas/Tags: diy, electronic, breadboard, audio

Paradroid: how I did it

Steps to build a 2.5D Paradroid for 3D printing

2017/05/03-14:11:33

It all started when I found some drawings of the character of the infamous computer game from the 80's.

The next step was obvious to me, just build a raster graphics of the beast using GNU/Octave. As is the original image needed some modification on order to be 3d-printed.

A=[1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1;
1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1;
1 1 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1;    
1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1;
1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1;
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1;    
1 1 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 0 1;
1 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 0 0 0;
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0;
0 0 1 1 1 0 0 1 0 0 1 1 1 0 0 1 1 1 0 0 0;
0 0 1 1 1 0 0 1 0 0 1 1 1 0 0 1 1 1 0 0 0;
0 0 1 1 1 0 0 1 0 0 1 1 1 0 0 1 1 1 0 0 0;
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 1 1 1 0 0 0;
1 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 1 1 0 0 0;    
1 1 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 1 1 0 1;
1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1;
1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1;    
1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1];
imshow(A)

print -deps -color paradroid.eps
print -dpng -color paradroid.png

So added some extra squares to get the job done.

Then used the Inkscape-to-OpenSCAD plugin and got the final 3d model, after some editing on the output code.

And it prints nicely with a resolution of 0.2mm and a 20% infill.

You can get it here: https://www.youmagine.com/designs/paradroid-ornament-key-chain

Share and enjoy!

Etiquetas/Tags: paradroid, 3d, 3dprinting, 3dprint, game, math

Números pseudo-aleatórios em LISP

Implementação em LISP de um gerador de números pseudo-aleatórios

2017/04/19-17:34:32

Uma das formas de gerar números com uma distribuição uniforme num intervalo é usando o método de congruências lineares1. Vejamos então como implementar um gerador de números pseudo-aleatórios que gera números inteiros entre 0 e m com uma distribuição uniforme latex2png equation.

A ideia é gerar uma sucessão de números com a forma latex2png equation onde2

latex2png equation

Ao valor de latex2png equation dá-se o nome de semente porque é o primeiro termo da sucessão e é usado como input para o termo seguinte. Note-se que para um mesmo latex2png equation obtém-se sempre o mesmo latex2png equation.

A sucessão de números assim obtida tem período latex2png equation e o intervalo de variação dos valores da sucessão pode ser ajustado ao intervalo latex2png equation através de

latex2png equation

A maneira mais directa é escrever

(defun rand (a c m x)
  (mod (+ (* a x) c) m))
e obtém-se
> (rand 24298 99991 199017 0)

99991

Esta não é a maneira preferível de obter um número aleatório. Queremos obter um número simplesmente fazendo (rand), mas para isso, temos de ter uma maneira de guardar os sucessivos termos da sucessão de modo a que sirvam de sementes para os termos seguintes. Assim vamos definir a variável

(defvar *r-seed* 0)
que inicializa a sucessão de sementes (ou dos próprios números pseudo-aleatórios). Esta é uma variável global e por isso está enquadrada por *. Definimos um substituto para a função anterior como
(defun rand1 ()
  (let ((a 24298)
        (c 99991)
        (m 199017))
    (cond ((<= *r-seed*  199017)
           (setf *r-seed* (mod (+ (* a *r-seed*) c) m)))
          (t
           (setf *r-seed* 0)))))
onde agora os parâmetros a, c e m são locais e estão definidos dentro da função. Assim
> (rand1)

99991

A função rand1 é simples de perceber. Depois de inicializar as quantidades a, c e m verifica se *r-seed* é menor ou igual a 199017, se sim altera o valor de *r-seed* para o novo termo da sucessão através de

(setf *r-seed* (mod (+ (* a *r-seed*) c) m))
se não
(setf *r-seed* 0)

De modo a gerar números aleatórios entre latex2png equation define-se a função

(defun rand (&optional alpha beta)
  (let ((m 199017))
    (cond ((not (and alpha beta))
           (float (/ (rand1) m)))
          (t
           (+ (* (float (/ (rand1) m)) (- beta alpha)) alpha)))))
com dois argumentos opcionais alpha e beta; se não forem dados (rand) gera números com uma distribuição uniforme no intervalo latex2png equation:
> (rand)

0.55237997

> (rand 0 2)

1.1378727

Ref:

1. D. Knuth, TAOCP

2. Master Library da TI Programable 58/59

Etiquetas/Tags: LISP, números pseudo-aleatórios

Dwarf guitar amplifier

... pics

2017/04/18-15:37:35

Found these pics of a guitar amplifier from the 70's, lovely!

Etiquetas/Tags: guitar, amp, amplifier, dwarf, DIY

OpenSCAD mode for emacs

... my hack.

2017/03/01-12:44:47

;;scad.el --- Major mode for editing SCAD files
;;; scad.el --- Major mode for editing SCAD files

;; Original author: Len Trigg <lenbok@gmail.com>
;; Maintainer: This hack is maintained by tca  <tca@diale.org>
;; Created:    20141107
;; Modified:   20141107
;; Keywords:   OpenSCAD, emacs, mode
;; URL:        http://diale.org/scad.el.html
;; Version:    0.1
;; Comments: Added a bunch of skeletons and keymaps.
;;
;; This program is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2 of the License, or
;; (at your option) any later version.
;; 
;; This program is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; 
;; You should have received a copy of the GNU General Public License
;; along with this program; see the file COPYING.  If not, write to
;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;
;;; Commentary:
;;
;; This is a major-mode to implement the SCAD constructs and
;; font-locking for openscad
;;; Code:

;;;###autoload

(add-to-list 'auto-mode-alist '("\\.scad$" . scad-mode))

(defcustom scad-command
  '"~/Downloads/openscad-2014.03/local_inst/bin/openscad"
  "Path to openscad executable"
  :type 'string)

(defcustom scad-keywords
  '("return" "true" "false")
  "SCAD keywords."
  :type 'list
  :group 'scad-font-lock)

(defcustom scad-functions
  '("cos" "acos" "sin" "asin" "tan" "atan" "atan2"  
    "abs" "sign" "rands" "min" "max" 
    "round" "ceil" "floor" 
    "pow" "sqrt" "exp" "log" "ln"
    "str" 
    "lookup" "version" "version_num" "len" "search"
    "dxf_dim" "dxf_cross")
    "SCAD functions."
  :type 'list
  :group 'scad-font-lock)

(defcustom scad-modules
  '("child" "children" "echo" "assign" "for" "intersection_for" "if" 
    "else" "cube" "sphere" "cylinder" "polyhedron" "square" "circle" 
    "polygon" "scale" "rotate" "translate" "mirror" "multmatrix" "union"
    "difference" "intersection" "render" "color" "surface" 
    "dxf_linear_extrude" "linear_extrude" "dxf_rotate_extrude" 
    "rotate_extrude" "import_stl" 
    "import_off" "import_dxf" "import" "group" 
    "projection""minkowski" "glide" "subdiv" "hull" "resize")
    "SCAD modules."
  :type 'list
  :group 'scad-font-lock)

(defcustom scad-operators
  '("+" "-" "*" "/" "%" 
    "&&" "||" "!" 
    "<" "<=" "==" "!=" ">" ">="
    "?" ":" "=")
  "SCAD operators."
  :type 'list
  :group 'scad-font-lock)

;; "C-c letter"  are reserved for users

(defvar scad-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map "\t" 'scad-indent-line)
    (define-key map (kbd "C-c C-v") 'scad-open-current-buffer)
    (define-key map (kbd "C-c C-c") 'scad-output-stl)

    ;; s for solid
    (define-key map (kbd "C-c C-s c") 'scad-cylinder)
    (define-key map (kbd "C-c C-s u") 'scad-cube)
    (define-key map (kbd "C-c C-s y") 'scad-cylinder)
    (define-key map (kbd "C-c C-s p") 'scad-polyhedron)

    ;; b for Boolean
    (define-key map (kbd "C-c C-b u") 'scad-union)
    (define-key map (kbd "C-c C-b d") 'scad-difference)
    (define-key map (kbd "C-c C-b i") 'scad-intersection)

    ;; t for transformations
    (define-key map (kbd "C-c C-t t") 'scad-translate)
    (define-key map (kbd "C-c C-t r") 'scad-rotate)
    (define-key map (kbd "C-c C-t s") 'scad-scale)
    (define-key map (kbd "C-c C-t z") 'scad-resize)
    (define-key map (kbd "C-c C-t m") 'scad-mirror)
    (define-key map (kbd "C-c C-t x") 'scad-multmatrix)
    (define-key map (kbd "C-c C-t c") 'scad-color)
    (define-key map (kbd "C-c C-t h") 'scad-hull)
    (define-key map (kbd "C-c C-t k") 'scad-minkowski)

    ;; s for syntax
    (define-key map (kbd "C-c C-s m") 'scad-module)
    (define-key map (kbd "C-c C-s f") 'scad-function)
    (define-key map (kbd "C-c C-s i") 'scad-include)
    (define-key map (kbd "C-c C-s u") 'scad-use)

    ;; m for math
    ;; Is this really needed;)

    ;; f for functions
    (define-key map (kbd "C-c C-f l") 'scad-lookup)
    (define-key map (kbd "C-c C-f r") 'scad-str)
    (define-key map (kbd "C-c C-f c") 'scad-chr)
    (define-key map (kbd "C-c C-f s") 'scad-search)
    (define-key map (kbd "C-c C-f n") 'scad-version-num)
    (define-key map (kbd "C-c C-f n") 'scad-norm )
    (define-key map (kbd "C-c C-f c") 'scad-cross)
    (define-key map (kbd "C-c C-f m") 'scad-parent-module)

    ;; o for others
    (define-key map (kbd "C-c C-o r") 'scad-render)
    (define-key map (kbd "C-c C-o f") 'scad-for)
    (define-key map (kbd "C-c C-o t") 'scad-intersection-for)
    (define-key map (kbd "C-c C-o i") 'scad-if)
    (define-key map (kbd "C-c C-o a") 'scad-assign)
    (define-key map (kbd "C-c C-o m") 'scad-import)
    (define-key map (kbd "C-c C-o x") 'scad-linear-extrude)
    (define-key map (kbd "C-c C-o o") 'scad-rotate-extrude)
    (define-key map (kbd "C-c C-o s") 'scad-surface)
    (define-key map (kbd "C-c C-o p") 'scad-projection)
    (define-key map (kbd "C-c C-o c") 'scad-children)

    ;; p for on the plane
    (define-key map (kbd "C-c C-p c") 'scad-circle)
    (define-key map (kbd "C-c C-p s") 'scad-square)
    (define-key map (kbd "C-c C-p p") 'scad-polygon)

    (define-key map [return] 'newline-and-indent)
    map)
  "Keymap for `scad-mode'.")

(defvar scad-mode-syntax-table
  (let ((st (make-syntax-table)))
    ;; support comment style: “// ...” 
    ;; support comment style: “/* ... */” 
    (modify-syntax-entry ?\/ ". 124b" st)
    (modify-syntax-entry ?\n "> b" st)
    (modify-syntax-entry ?* ". 23" st)

    ;; Extra punctuation
    (modify-syntax-entry ?+  "." st)
    (modify-syntax-entry ?-  "." st)
    (modify-syntax-entry ?%  "." st)
    (modify-syntax-entry ?<  "." st)
    (modify-syntax-entry ?>  "." st)
    (modify-syntax-entry ?&  "." st)
    (modify-syntax-entry ?:  "." st)
    (modify-syntax-entry ?|  "." st)
    (modify-syntax-entry ?=  "." st)
    (modify-syntax-entry ?\;  "." st)

    ;; _ allowed in word (alternatively "_" as symbol constituent?)
    (modify-syntax-entry ?_  "w" st) st)
  "Syntax table for `scad-mode'.")

(defvar scad-keywords-regexp (regexp-opt scad-keywords 'words))
(defvar scad-modules-regexp (regexp-opt scad-modules 'words))
(defvar scad-functions-regexp (regexp-opt scad-functions 'words))
(defvar scad-operators-regexp (regexp-opt scad-operators))

(defvar scad-font-lock-keywords
  `(
    ("\\(module\\|function\\)[ \t]+\\(\\sw+\\)" (1 'font-lock-keyword-face nil) (2 'font-lock-function-name-face nil t))
    ("\\(use\\|include\\)[ \t]*<\\([^>]+\\)>" (1 'font-lock-preprocessor-face nil) (2 'font-lock-type-face nil t))
    ("<\\(\\sw+\\)>" (1 'font-lock-builtin-face nil))
    ("$\\(\\sw+\\)" (1 'font-lock-builtin-face nil))
    (,scad-keywords-regexp . font-lock-keyword-face)
    (,scad-modules-regexp .  font-lock-builtin-face)
    (,scad-functions-regexp .  font-lock-function-name-face)
    ;(,scad-operators-regexp .  font-lock-operator-face) ;; This actually looks pretty ugly
    ;("\\(\\<\\S +\\>\\)\\s *(" 1 font-lock-function-name-face t) ;; Seems to override other stuff (e.g. in comments and builtins)
    )
  "Keyword highlighting specification for `scad-mode'.")

;(defvar scad-imenu-generic-expression ...)
;(defvar scad-outline-regexp ...)

;;;###autoload
(define-derived-mode scad-mode fundamental-mode "SCAD"
  "A major mode for editing SCAD files."
  :syntax-table scad-mode-syntax-table
  (set (make-local-variable 'font-lock-defaults) '(scad-font-lock-keywords))
  (set (make-local-variable 'indent-line-function) 'scad-indent-line)
                                        ;(set (make-local-variable 'imenu-generic-expression) scad-imenu-generic-expression)
                                        ;(set (make-local-variable 'outline-regexp) scad-outline-regexp)
  ;; set comment styles for scad mode
  (set (make-local-variable 'comment-start) "//")
  (set (make-local-variable 'comment-end) "")
  (set (make-local-variable 'block-comment-start) "/*")
  (set (make-local-variable 'block-comment-end) "*/"))


;; From: http://stackoverflow.com/questions/14520073/add-words-for-dynamic-expansion-to-emacs-mode
(defun scad-prime-dabbrev ()
  "Makes a hidden scad-mode buffer containing all the scad keywords, so dabbrev expansion just works."
  (unless (get-buffer " *scad words*")
    (with-current-buffer (get-buffer-create " *scad words*")
      (scad-mode)
      (insert "module function use include")  ; Explicitly add these -- they're not in the below vars
      (insert (mapconcat 'identity (append scad-keywords scad-functions scad-modules) " ")))))

(add-hook 'scad-mode-hook 'scad-prime-dabbrev)

;;; Indentation, based on http://www.emacswiki.org/emacs/download/actionscript-mode-haas-7.0.el

(defun scad-indent-line ()
  "Indent current line of SCAD code."
  (interactive)
  (let ((savep (> (current-column) (current-indentation)))
        (indent (max (scad-calculate-indentation) 0)))
    (if savep
        (save-excursion (indent-line-to indent))
      (indent-line-to indent))))

(defun scad-calculate-indentation ()
  "Return the column to which the current line should be indented."
  (save-excursion
    (scad-maybe-skip-leading-close-delim)
    (let ((pos (point)))
      (beginning-of-line)
      (if (not (search-backward-regexp "[^\n\t\r ]" 1 0))
          0
        (progn
          (scad-maybe-skip-leading-close-delim)
          (+ (current-indentation) (* standard-indent (scad-count-scope-depth (point) pos))))))))

(defun scad-maybe-skip-leading-close-delim ()
  (beginning-of-line)
  (forward-to-indentation 0)
  (if (looking-at "\\s)")
      (forward-char)
    (beginning-of-line)))

(defun scad-face-at-point (pos)
  "Return face descriptor for char at point."
  (plist-get (text-properties-at pos) 'face))

(defun scad-count-scope-depth (rstart rend)
  "Return difference between open and close scope delimeters."
  (save-excursion
    (goto-char rstart)
    (let ((open-count 0)
          (close-count 0)
          opoint)
      (while (and (< (point) rend)
                  (progn (setq opoint (point))
                         (re-search-forward "\\s)\\|\\s(" rend t)))
        (if (= opoint (point))
            (forward-char 1)
          (cond
           ;; Don't count if in string or comment.
           ((scad-face-at-point (- (point) 1)))
           ((looking-back "\\s)")
            (setq close-count (+ close-count 1)))
           ((looking-back "\\s(")
            (setq open-count (+ open-count 1)))
           )))
      (- open-count close-count))))

(defun scad-open-current-buffer ()
  (interactive)
  (call-process scad-command nil 0 nil (buffer-file-name)))

(defun scad-output-stl ()
  (interactive)
  (async-shell-command (concat  scad-command " -o " (buffer-file-name) ".stl "
                              (buffer-file-name))))

;; Skeleton for easy editing
;; 3D
(define-skeleton scad-sphere
  "Insert sphere."
  "Sphere:"
  "sphere:(" str ");")

(define-skeleton scad-cube
  "Insert cube."
  "Cube:"
  "cube:(" str ");")

(define-skeleton scad-cylinder
  "Insert cylinder."
  "Cylinder:"
  "cylinder(" str ");")

(define-skeleton scad-polyhedron
  "Insert polyhedron."
  "Polyhedron:"
  "polyhedron(" str ");")

;; 2D

(define-skeleton scad-circle
  "Insert square."
  "Square:"
  "square(" str ");")

(define-skeleton scad-square
  "Insert square ."
  "Square:"
  "square(" str ");")

(define-skeleton scad-polygon
  "Insert polygon."
  "Polygon:"
  "Polygon(" str ");")

;; Transformations

(define-skeleton scad-translate
  "Insert translate."
  "translate:"
  "translate(" str "){"_"}")

(define-skeleton scad-rotate
  "Insert rotate."
  "rotate:"
  "rotate(" str "){"_"}")

(define-skeleton scad-scale
  "Insert scale."
  "Scale:"
  "scale(" str "){"_"}")

(define-skeleton scad-resize
  "Insert resize."
  "Resize:"
  "resize(" str "){"_"}")

(define-skeleton scad-mirror
  "Insert mirror."
  "Mirror:"
  "mirror(" str "){"_"}")

(define-skeleton scad-multmatrix
  "Insert multmatrix."
  "Multmatrix:"
  "multmatrix:(" str "){"_"}")

(define-skeleton scad-color
  "Insert color."
  "Color:"
  "color(" str "){"_"}")

(define-skeleton scad-hull
  "Insert hull."
  "Hull:"
  "hull(" str "){"_"}")

(define-skeleton scad-minkowski
  "Insert minkowski."
  "Minkowski:"
  "minkowski(){"_"}")

;; Boolean

(define-skeleton scad-union
  "Insert union."
  "Union:"
  "union(){}")

(define-skeleton scad-difference
  "Insert difference."
  "Difference:"
  "difference(){"_"}")

(define-skeleton scad-intersection
  "Insert intersection."
  "Intersection:"
  "intersection(){"_"}")

;; Syntax

(define-skeleton scad-module
  "Insert module."
  "Module:"
  "module " str "("_"){}")

(define-skeleton scad-function
  "Insert function."
  "Function:"
  "function " str "("_"){}")

(define-skeleton scad-include
  "Insert include."
  "Include:"
  "include <" str ".scad>")

(define-skeleton scad-use
  "Insert use."
  "Use:"
  "use <" str ".scad>")

;; Other

(define-skeleton scad-render
  "Insert render."
  "Render:"
  "render(){"_"}")


(define-skeleton scad-translate
  "Insert translate."
  "translate:"
  "translate(" str "){"_"}")

(define-skeleton scad-rotate
  "Insert rotate."
  "rotate:"
  "rotate(" str "){"_"}")

(define-skeleton scad-scale
  "Insert scale."
  "Scale:"
  "scale(" str "){"_"}")

(define-skeleton scad-resize
  "Insert resize."
  "Resize:"
  "resize(" str "){"_"}")

(define-skeleton scad-mirror
  "Insert mirror."
  "Mirror:"
  "mirror(" str "){"_"}")

(define-skeleton scad-multmatrix
  "Insert multmatrix."
  "Multmatrix:"
  "multmatrix:(" str "){"_"}")

(define-skeleton scad-color
  "Insert color."
  "Color:"
  "color(" str "){"_"}")

(define-skeleton scad-hull
  "Insert hull."
  "Hull:"
  "hull(" str "){"_"}")

(define-skeleton scad-minkowski
  "Insert minkowski."
  "Minkowski:"
  "minkowski(){"_"}")

;; Boolean

(define-skeleton scad-union
  "Insert union."
  "Union:"
  "union(){}")

(define-skeleton scad-difference
  "Insert difference."
  "Difference:"
  "difference(){"_"}")

(define-skeleton scad-intersection
  "Insert intersection."
  "Intersection:"
  "intersection(){"_"}")

;; Syntax

(define-skeleton scad-module
  "Insert module."
  "Module:"
  "module " str "("_"){}")

(define-skeleton scad-function
  "Insert function."
  "Function:"
  "function " str "("_"){}")

(define-skeleton scad-include
  "Insert include."
  "Include:"
  "include <" str ".scad>")

(define-skeleton scad-use
  "Insert use."
  "Use:"
  "use <" str ".scad>")

;; Other

(define-skeleton scad-render
  "Insert render."
  "Render:"
  "render(){"_"}")

(define-skeleton scad-for
  "Insert for."
  "For:"
  "for  (i=" str ")" "{" _ "}")
  

;; (define-skeleton scad-
;;   "Insert ."
;;   ":"
;;   "(" str ");")


(provide 'scad)
;;; scad-mode.el ends here

Enjoy.

Etiquetas/Tags: emacs, openscad

Guitar fuzzbox under 3$

Craig Anderton, Popular Electronics, January 1967

2017/02/10-14:03:34

Etiquetas/Tags: fuzz, guitar, audio

Uma aproximação ou conveniência

... dizer que a ciência é uma aproximação da realidade.

2017/01/23-12:52:54

Dizer que as afirmações da ciência não são a verdade mas a uma aproximação à verdade corresponde a atribuir o mesmo estatuto da ciência a outras actividades intelectuais não científicas tais como religiões, crenças, ideologias etc.

Uma afirmação é verdadeira se está de acordo com os factos que descreve, caso contrário é falsa, não há aproximações.

O facto de o mundo poder ser descrito, bem descrito, por uma certa teoria científica nada diz acerca do mundo ou como ele é realmente, mas diz-nos no entanto alguma coisa sobre ele, i.e., que pode ser bem descrito por essa teoria científica e não outra.

Atribuir à ciência o mero estatuto de uma actividade de produção de afirmações aproximadas à verdade legitima outro tipo de afirmações que, com semelhantes argumentos interiores a elas, podem ser tomadas como afirmações verdadeiras, aproximadas ou não, ou mesmo considerar-se possuir-se a totalidade da verdade num sistema formal imaginado.

Na base da toda a visão moderna do mundo reside a ilusão de que as chamadas de leis da natureza são explicações dos fenómenos naturais. Assim ficamos com a ideia de que as leis da natureza são como coisas inatacáveis, da mesma forma o faziam os antigos com Deus e o Destino. E ambos estão certos e errados. Mas os antigos eram mais claros, reconheciam um fim claro, enquanto o sistema moderno torna-a como se tudo estivesse explicado.

Etiquetas/Tags: ciência, verdade, Wittgenstein

Wharfedale 15 woofer

... que tenho aqui em casa

2017/01/14-16:23:40

Finalmente consegui descobrir qual o altifalante que tinha aqui para casa (era do meu avô): um Wharfedale de 15 polegadas. Precisa de um restauro mas o cone e a spider parecem estar em boas condições!

Etiquetas/Tags: Wharfedale, 15'', woofer, W15/cs

Pavilhões acústicos: ideias e construções

... para alunos de design e outros mini engenheiros

2016/12/15-15:24:21

Espiral de Cornut

Paper horns

Impressão 3D

(em actualização)

Etiquetas/Tags: acústica, pavilhões, altifalantes

Vaso 3D

... obtido por rotação em torno de um eixo

2016/11/27-13:47:37

A visualização tridimensional é um ingrediente importante na comunicação e estudo da matemática. Figuras e modelos expressam ideias e antecipam o estabelecimento de um formalismo matemático mais rigoroso. Embora a imaginação visual não substitua o conceito de demonstração dá-nos uma prova visual convincente e permite construir uma intuição sobre os resultados a perseguir e ideias a aprofundar.

A figura seguinte mostra a modelação 3D de uma "jarra" construída através da rotação em torno de um eixo.

Ao contrário do que acontece com outros tipos de software, os softwares usados em matemática permitem de uma forma muito económica a modelação e construção de estruturas não triviais, especificando simplesmente a expressão que as definem.

phi=(1+sqrt(5))/2;

n=100;

r=40;
l=152;
mu=3;
mv=2;
a=.25;
b=a/phi;
lambda=1.5;

nu=.2;
[u,v]=meshgrid([linspace(0,2*pi,n) 2*pi/n],linspace(0,l,n));

x=r*cos(u).*abs(cos(u)).^nu.*(1+a*cos(mu*u+mv*pi*v/l).^5+b*cos(mv*2*pi*v/l));
y=r*sin(u).*abs(sin(u)).^nu.*(1+a*cos(mu*u+mv*phi*pi*v/l).^5+b*cos(mv*2*pi*v/l));
z=v;

simplef2stl("vase.stl",x,y,z)

Depois de impresso o resultado é muito apelativo!

... e não é uma curva.

Função para gerar STL em GNU/Octave

## Author: Tiago Charters de Azevedo 
## Maintainer: Tiago Charters de Azevedo 

## Copyright (c) - 2016 Tiago Charters de Azevedo

## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 3, or (at your option)
## any later version.

## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.

## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 51 Franklin Street, Fifth Floor,
## Boston, MA 02110-1301, USA.

function simplef2stl(filename,x,y,z)
  fid=fopen(filename,'w');
  title_str=sprintf('%s',datestr(now));
  fprintf(fid,'solid %s\r\n',title_str);

  zmin=min(min(z));
  z=z-zmin;
  nfacets=0;
  nx=size(z,1);
  ny=size(z,2);
  for i=1:nx-1;
    for j=1:ny-1
      p1=[x(i,j) y(i,j) z(i,j)];
      p2=[x(i,j+1) y(i,j+1) z(i,j+1)];
      p3=[x(i+1,j+1) y(i+1,j+1) z(i+1,j+1)];
      writefacet(fid,p1,p2,p3);

      p1=[x(i+1,j+1) y(i+1,j+1) z(i+1,j+1)];
      p2=[x(i+1,j) y(i+1,j) z(i+1,j)];
      p3=[x(i,j) y(i,j) z(i,j)];        
      writefacet(fid,p1,p2,p3);
    end
  end
  fprintf(fid,'endsolid');
  fclose(fid);
end  
  
function num=writefacet(fid,p1,p2,p3)
    n=normal(p1,p2,p3);
    fprintf(fid,'facet normal %.7E %.7E %.7E\r\n',n(1),n(2),n(3));
    fprintf(fid,'outer loop\r\n');        
    fprintf(fid,'vertex %.7E %.7E %.7E\r\n',p1);
    fprintf(fid,'vertex %.7E %.7E %.7E\r\n',p2);
    fprintf(fid,'vertex %.7E %.7E %.7E\r\n',p3);
    fprintf(fid,'endloop\r\n');
    fprintf(fid,'endfacet\r\n');
end

function n=normal(p1,p2,p3)
  v1=p2-p1;
  v2=p3-p1;
  v3=cross(v1,v2);
  n=v3./sumsq(v3);
end

Etiquetas/Tags: 3d, print, reprap, GNU/Octave, STL

Palavras chave/keywords: página pessoal, blog

Criado/Created: NaN

Última actualização/Last updated: 24-05-2017 [14:04]


GNU/Emacs

1999-2017 (ç) Tiago Charters de Azevedo

São permitidas cópias textuais parciais/integrais em qualquer meio com/sem alterações desde que se mantenha este aviso.

Verbatim copying and redistribution of this entire page are permitted provided this notice is preserved.