def __init__(self, **kwargs):
        Node.__init__(self)
        self.start_pos = Point(kwargs['start'])
        self.end_pos = Point(kwargs['end'])

        self.layer = kwargs.get('layer', 'F.SilkS')
        self.width = kwargs.get('width', 0.15)  # TODO: better variation to get line width

        rect_line = RectLine(**kwargs)
        rect_line._parent = self

        rect_fill = RectFill(**kwargs)
        rect_fill._parent = self

        self.virtual_childs = [rect_line, rect_fill]
Example #2
0
    def _init_switch(self):

        # set attributes
        if self.hotswap is True:
            self.setAttribute('smd')

        # create fab outline
        self.append(
            RectLine(start=[-self.choc_w / 2, -self.choc_h / 2],
                     end=[self.choc_w / 2, self.choc_h / 2],
                     layer='F.Fab',
                     width=0.1))

        # create silkscreen
        self.append(
            RectLine(start=[-self.choc_w / 2, -self.choc_h / 2],
                     end=[self.choc_w / 2, self.choc_h / 2],
                     layer='F.SilkS',
                     width=0.12,
                     offset=0.1))

        # create courtyard
        self.append(
            RectLine(start=[-self.choc_w / 2, -self.choc_h / 2],
                     end=[self.choc_w / 2, self.choc_h / 2],
                     layer='F.CrtYd',
                     width=0.05,
                     offset=0.25))

        if self.hotswap is True:
            # socket outline
            # TODO: this outline is incorrect
            polyline_base = [
                [6.75, -2.25],
                [6.25, -1.75],
                [3.5, -1.75],
                [1.25, -4],
                [-1.25, -4],
                [-1.75, -4.5],
            ]

            polyline_base2 = [
                [-1.75, -7.5],
                [-1.25, -8],
                [1.25, -8],
                [3.5, -5.75],
                [6.25, -5.75],
                [6.75, -5.25],
            ]

            # create fab outline (socket)
            self.append(
                PolygoneLine(polygone=polyline_base, layer='B.Fab', width=0.1))
            self.append(
                PolygoneLine(polygone=polyline_base2, layer='B.Fab',
                             width=0.1))

            # create silkscreen (socket)
            # TODO: offset 0.1
            self.append(
                PolygoneLine(polygone=polyline_base,
                             layer='B.SilkS',
                             width=0.12))
            self.append(
                PolygoneLine(polygone=polyline_base2,
                             layer='B.SilkS',
                             width=0.12))

            # create courtyard (socket)
            # TODO: offset 0.25
            polyline = polyline_base + polyline_base2
            polyline.append(polyline_base[0])
            self.append(
                PolygoneLine(polygone=polyline, layer='B.CrtYd', width=0.05))

        # create pads
        if self.hotswap is True:
            if self.hotswap_plated is True:
                self.append(
                    Pad(number=1,
                        type=Pad.TYPE_THT,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[0, -5.9],
                        size=[3.6, 3.6],
                        drill=3.05,
                        layers=['*.Cu', 'B.Mask']))
                self.append(
                    Pad(number=2,
                        type=Pad.TYPE_THT,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[5, -3.8],
                        size=[3.6, 3.6],
                        drill=3.05,
                        layers=['*.Cu', 'B.Mask']))

                self.append(
                    Pad(number=1,
                        type=Pad.TYPE_SMT,
                        shape=Pad.SHAPE_ROUNDRECT,
                        at=[-2.85, -6],
                        size=[3.85, 2.5],
                        round_radius_exact=0.25,
                        layers=['B.Cu']))
                self.append(
                    Pad(number=2,
                        type=Pad.TYPE_SMT,
                        shape=Pad.SHAPE_ROUNDRECT,
                        at=[7.85, -3.8],
                        size=[3.85, 2.5],
                        round_radius_exact=0.25,
                        layers=['B.Cu']))

                self.append(
                    Pad(type=Pad.TYPE_SMT,
                        shape=Pad.SHAPE_ROUNDRECT,
                        at=[-3.5, -6],
                        size=[2.55, 2.5],
                        round_radius_exact=0.25,
                        layers=['B.Mask', 'B.Paste']))
                self.append(
                    Pad(type=Pad.TYPE_SMT,
                        shape=Pad.SHAPE_ROUNDRECT,
                        at=[8.5, -3.8],
                        size=[2.55, 2.5],
                        round_radius_exact=0.25,
                        layers=['B.Mask', 'B.Paste']))

                self.append(
                    Pad(type=Pad.TYPE_THT,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[-5, 5.15],
                        size=[2.6, 2.6],
                        drill=1.6,
                        layers=['*.Cu', 'B.Mask']))

            else:
                self.append(
                    Pad(type=Pad.TYPE_NPTH,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[0, -5.9],
                        size=[3.05, 3.05],
                        drill=3.05,
                        layers=['*.Cu', '*.Mask']))
                self.append(
                    Pad(type=Pad.TYPE_NPTH,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[5, -3.8],
                        size=[3.05, 3.05],
                        drill=3.05,
                        layers=['*.Cu', '*.Mask']))

                self.append(
                    Pad(number=1,
                        type=Pad.TYPE_SMT,
                        shape=Pad.SHAPE_ROUNDRECT,
                        at=[-3.5, -6],
                        size=[2.55, 2.5],
                        round_radius_exact=0.25,
                        layers=['B.Cu', 'B.Mask', 'B.Paste']))
                self.append(
                    Pad(number=2,
                        type=Pad.TYPE_SMT,
                        shape=Pad.SHAPE_ROUNDRECT,
                        at=[8.5, -3.8],
                        size=[2.55, 2.5],
                        round_radius_exact=0.25,
                        layers=['B.Cu', 'B.Mask', 'B.Paste']))

                self.append(
                    Pad(type=Pad.TYPE_NPTH,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[-5, 5.15],
                        size=[1.6, 1.6],
                        drill=1.6,
                        layers=['*.Cu', '*.Mask']))
        else:
            self.append(
                Pad(number=1,
                    type=Pad.TYPE_THT,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[0, -5.9],
                    size=[2.2, 2.2],
                    drill=1.2,
                    layers=['*.Cu', 'B.Mask']))
            self.append(
                Pad(number=2,
                    type=Pad.TYPE_THT,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[5, -3.8],
                    size=[2.2, 2.2],
                    drill=1.2,
                    layers=['*.Cu', 'B.Mask']))

        if self.switch_type == 'V1':
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[0, 0],
                    size=[3.45, 3.45],
                    drill=3.45,
                    layers=['*.Cu', '*.Mask']))
        else:  # V2 or V1V2
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[0, 0],
                    size=[5.05, 5.05],
                    drill=5.05,
                    layers=['*.Cu', '*.Mask']))

        if self.switch_type in ['V1', 'V1V2']:
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[-5.5, 0],
                    size=[1.9, 1.9],
                    drill=1.9,
                    layers=['*.Cu', '*.Mask']))
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[5.5, 0],
                    size=[1.9, 1.9],
                    drill=1.9,
                    layers=['*.Cu', '*.Mask']))

        if self.switch_type in ['V2', 'V1V2']:
            if self.hotswap is False or self.hotswap_plated is True:
                self.append(
                    Pad(type=Pad.TYPE_THT,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[-5, 5.15],
                        size=[2.6, 2.6],
                        drill=1.6,
                        layers=['*.Cu', 'B.Mask']))
            else:
                self.append(
                    Pad(type=Pad.TYPE_NPTH,
                        shape=Pad.SHAPE_CIRCLE,
                        at=[-5, 5.15],
                        size=[1.6, 1.6],
                        drill=1.6,
                        layers=['*.Cu', '*.Mask']))
Example #3
0
    def _init_switch(self):

        # set attributes
        self.setAttribute('smd')

        # create fab outline (keyswitch)
        self.append(
            RectLine(start=[-self.kailh_hs_w / 2, -self.kailh_hs_h / 2],
                     end=[self.kailh_hs_w / 2, self.kailh_hs_h / 2],
                     layer='F.Fab',
                     width=0.1))

        # create fab outline (socket)
        self.append(
            Line(start=[-4, -6.8], end=[4.8, -6.8], layer='B.Fab', width=0.12))
        self.append(
            Line(start=[4.8, -6.8], end=[4.8, -2.8], layer='B.Fab',
                 width=0.12))
        self.append(
            Line(start=[-0.3, -2.8],
                 end=[4.8, -2.8],
                 layer='B.Fab',
                 width=0.12))
        self.append(
            Line(start=[-6, -0.8], end=[-2.3, -0.8], layer='B.Fab',
                 width=0.12))
        self.append(
            Line(start=[-6, -0.8], end=[-6, -4.8], layer='B.Fab', width=0.12))
        self.append(
            Arc(center=[-4, -4.8],
                start=[-4, -6.8],
                angle=-90,
                layer='B.Fab',
                width=0.12))
        self.append(
            Arc(center=[-0.3, -0.8],
                start=[-0.3, -2.8],
                angle=-90,
                layer='B.Fab',
                width=0.12))

        # create silkscreen (keyswitch)
        self.append(
            RectLine(start=[-self.kailh_hs_w / 2, -self.kailh_hs_h / 2],
                     end=[self.kailh_hs_w / 2, self.kailh_hs_h / 2],
                     layer='F.SilkS',
                     width=0.12,
                     offset=0.1))

        # create silkscreen (socket)
        self.append(
            Line(start=[-4.1, -6.9],
                 end=[1, -6.9],
                 layer='B.SilkS',
                 width=0.12))
        self.append(
            Line(start=[-0.2, -2.7],
                 end=[4.9, -2.7],
                 layer='B.SilkS',
                 width=0.12))
        self.append(
            Arc(center=[-4.1, -4.9],
                start=[-4.1, -6.9],
                angle=-90,
                layer='B.SilkS',
                width=0.12))
        self.append(
            Arc(center=[-0.2, -0.7],
                start=[-0.2, -2.7],
                angle=-90,
                layer='B.SilkS',
                width=0.12))

        # create courtyard (keyswitch)
        self.append(
            RectLine(start=[-self.kailh_hs_w / 2, -self.kailh_hs_h / 2],
                     end=[self.kailh_hs_w / 2, self.kailh_hs_h / 2],
                     layer='F.CrtYd',
                     width=0.05,
                     offset=0.25))

        # create courtyard (socket)
        # !TODO: add KLC correct offset (0.25)
        self.append(
            Line(start=[-4, -6.8],
                 end=[4.8, -6.8],
                 layer='B.CrtYd',
                 width=0.05))
        self.append(
            Line(start=[4.8, -6.8],
                 end=[4.8, -2.8],
                 layer='B.CrtYd',
                 width=0.05))
        self.append(
            Line(start=[-0.3, -2.8],
                 end=[4.8, -2.8],
                 layer='B.CrtYd',
                 width=0.05))
        self.append(
            Line(start=[-6, -0.8],
                 end=[-2.3, -0.8],
                 layer='B.CrtYd',
                 width=0.05))
        self.append(
            Line(start=[-6, -0.8], end=[-6, -4.8], layer='B.CrtYd',
                 width=0.05))
        self.append(
            Arc(center=[-4, -4.8],
                start=[-4, -6.8],
                angle=-90,
                layer='B.CrtYd',
                width=0.05))
        self.append(
            Arc(center=[-0.3, -0.8],
                start=[-0.3, -2.8],
                angle=-90,
                layer='B.CrtYd',
                width=0.05))

        # create pads
        if self.plated_th is True:
            self.append(
                Pad(number=1,
                    type=Pad.TYPE_THT,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[-3.81, -2.54],
                    size=[3.6, 3.6],
                    drill=3.05,
                    layers=['*.Cu', 'B.Mask']))
            self.append(
                Pad(number=2,
                    type=Pad.TYPE_THT,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[2.54, -5.08],
                    size=[3.6, 3.6],
                    drill=3.05,
                    layers=['*.Cu', 'B.Mask']))

            self.append(
                Pad(number=1,
                    type=Pad.TYPE_SMT,
                    shape=Pad.SHAPE_ROUNDRECT,
                    at=[-6.585, -2.54],
                    size=[3.55, 2.5],
                    round_radius_exact=0.25,
                    layers=['B.Cu']))
            self.append(
                Pad(number=2,
                    type=Pad.TYPE_SMT,
                    shape=Pad.SHAPE_ROUNDRECT,
                    at=[5.32, -5.08],
                    size=[3.55, 2.5],
                    round_radius_exact=0.25,
                    layers=['B.Cu']))

            self.append(
                Pad(type=Pad.TYPE_SMT,
                    shape=Pad.SHAPE_ROUNDRECT,
                    at=[-7.085, -2.54],
                    size=[2.55, 2.5],
                    round_radius_exact=0.25,
                    layers=['B.Mask', 'B.Paste']))
            self.append(
                Pad(type=Pad.TYPE_SMT,
                    shape=Pad.SHAPE_ROUNDRECT,
                    at=[5.842, -5.08],
                    size=[2.55, 2.5],
                    round_radius_exact=0.25,
                    layers=['B.Mask', 'B.Paste']))
        else:
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[-3.81, -2.54],
                    size=[3.05, 3.05],
                    drill=3.05,
                    layers=['*.Cu', '*.Mask']))
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[2.54, -5.08],
                    size=[3.05, 3.05],
                    drill=3.05,
                    layers=['*.Cu', '*.Mask']))

            self.append(
                Pad(number=1,
                    type=Pad.TYPE_SMT,
                    shape=Pad.SHAPE_ROUNDRECT,
                    at=[-7.085, -2.54],
                    size=[2.55, 2.5],
                    round_radius_exact=0.25,
                    layers=['B.Cu', 'B.Mask', 'B.Paste']))
            self.append(
                Pad(number=2,
                    type=Pad.TYPE_SMT,
                    shape=Pad.SHAPE_ROUNDRECT,
                    at=[5.842, -5.08],
                    size=[2.55, 2.5],
                    round_radius_exact=0.25,
                    layers=['B.Cu', 'B.Mask', 'B.Paste']))

        self.append(
            Pad(type=Pad.TYPE_NPTH,
                shape=Pad.SHAPE_CIRCLE,
                at=[0, 0],
                size=[4, 4],
                drill=4,
                layers=['*.Cu', '*.Mask']))
        self.append(
            Pad(type=Pad.TYPE_NPTH,
                shape=Pad.SHAPE_CIRCLE,
                at=[-5.08, 0],
                size=[1.75, 1.75],
                drill=1.75,
                layers=['*.Cu', '*.Mask']))
        self.append(
            Pad(type=Pad.TYPE_NPTH,
                shape=Pad.SHAPE_CIRCLE,
                at=[5.08, 0],
                size=[1.75, 1.75],
                drill=1.75,
                layers=['*.Cu', '*.Mask']))
Example #4
0
    def _init_switch(self):

        # create fab outline
        self.append(
            RectLine(start=[-self.cherry_w / 2, -self.cherry_h / 2],
                     end=[self.cherry_w / 2, self.cherry_h / 2],
                     layer='F.Fab',
                     width=0.1))

        # create silkscreen
        self.append(
            RectLine(start=[-self.cherry_w / 2, -self.cherry_h / 2],
                     end=[self.cherry_w / 2, self.cherry_h / 2],
                     layer='F.SilkS',
                     width=0.12,
                     offset=0.1))

        # create courtyard
        self.append(
            RectLine(start=[-self.cherry_w / 2, -self.cherry_h / 2],
                     end=[self.cherry_w / 2, self.cherry_h / 2],
                     layer='F.CrtYd',
                     width=0.05,
                     offset=0.25))
        # create pads
        self.append(
            Pad(number=1,
                type=Pad.TYPE_THT,
                shape=Pad.SHAPE_CIRCLE,
                at=[-3.81, -2.54],
                size=[2.5, 2.5],
                drill=1.5,
                layers=['*.Cu', 'B.Mask']))
        self.append(
            Pad(number=2,
                type=Pad.TYPE_THT,
                shape=Pad.SHAPE_CIRCLE,
                at=[2.54, -5.08],
                size=[2.5, 2.5],
                drill=1.5,
                layers=['*.Cu', 'B.Mask']))
        self.append(
            Pad(type=Pad.TYPE_NPTH,
                shape=Pad.SHAPE_CIRCLE,
                at=[0, 0],
                size=[4, 4],
                drill=4,
                layers=['*.Cu', '*.Mask']))

        if self.switch_type == 'PCB':
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[-5.08, 0],
                    size=[1.75, 1.75],
                    drill=1.75,
                    layers=['*.Cu', '*.Mask']))
            self.append(
                Pad(type=Pad.TYPE_NPTH,
                    shape=Pad.SHAPE_CIRCLE,
                    at=[5.08, 0],
                    size=[1.75, 1.75],
                    drill=1.75,
                    layers=['*.Cu', '*.Mask']))
Example #5
0
    def _init_switch(self):
        # create fab outline
        self.append(
            RectLine(start=[-self.kailh_nb_w / 2, -self.kailh_nb_h / 2],
                     end=[self.kailh_nb_w / 2, self.kailh_nb_h / 2],
                     layer='F.Fab',
                     width=0.1))

        # create silkscreen
        self.append(
            RectLine(start=[-self.kailh_nb_w / 2, -self.kailh_nb_h / 2],
                     end=[self.kailh_nb_w / 2, self.kailh_nb_h / 2],
                     layer='F.SilkS',
                     width=0.12,
                     offset=0.1))

        # create courtyard
        self.append(
            RectLine(start=[-self.kailh_nb_w / 2, -self.kailh_nb_h / 2],
                     end=[self.kailh_nb_w / 2, self.kailh_nb_h / 2],
                     layer='F.CrtYd',
                     width=0.05,
                     offset=0.25))

        # center hole
        self.append(
            RectLine(start=[1.1, -2.5],
                     end=[-2.9, 2.5],
                     layer='Edge.Cuts',
                     width=0.05))

        # create pads
        self.append(
            Pad(number=1,
                type=Pad.TYPE_THT,
                shape=Pad.SHAPE_CIRCLE,
                at=[-2, -3.4],
                size=[1.4, 1.4],
                drill=1.1,
                layers=['*.Cu', 'B.Mask']))
        self.append(
            Pad(number=2,
                type=Pad.TYPE_THT,
                shape=Pad.SHAPE_CIRCLE,
                at=[2.9, -3.4],
                size=[1.4, 1.4],
                drill=1.1,
                layers=['*.Cu', 'B.Mask']))

        self.append(
            Pad(type=Pad.TYPE_NPTH,
                shape=Pad.SHAPE_CIRCLE,
                at=[5.5, -5.50],
                size=[1.3, 1.3],
                drill=1.3,
                layers=['*.Cu', '*.Mask']))
        self.append(
            Pad(type=Pad.TYPE_NPTH,
                shape=Pad.SHAPE_CIRCLE,
                at=[-5.5, 5.5],
                size=[1.3, 1.3],
                drill=1.3,
                layers=['*.Cu', '*.Mask']))