Rev 307 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
347 | jelle | 1 | # release: pcb 1.6.3 |
2 | PCB("" 6000 5000) |
||
3 | Grid(10 0 0) |
||
4 | Cursor(0 0 3) |
||
5 | Flags(0x000000d0) |
||
6 | Groups("1,2,3,s:4,5,6,c:7:8:") |
||
7 | Styles("Signal,10,40,20:Power,25,60,35:Fat,40,60,35:Skinny,8,36,20") |
||
8 | # grab the input values and convert to 1/100 mil |
||
9 | |||
10 | |||
11 | |||
12 | |||
13 | |||
14 | |||
15 | |||
16 | # how much to grow the pads by for soldermask [1/100 mil] |
||
17 | |||
18 | # clearance from planes [1/100 mil] |
||
19 | |||
20 | # silk screen width [1/100 mil] |
||
21 | |||
22 | # courtyard silk screen width [1/100 mil] |
||
23 | |||
24 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
25 | # text_x, text_y, text_direction, text_scale, text_flags |
||
26 | Element[0x00000000 "0805" "C1205" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
27 | ( |
||
28 | # |
||
29 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
30 | Pad[-3543 -393 |
||
31 | -3543 393 |
||
32 | 5118 2000 5718 "1" "1" "square"] |
||
33 | Pad[3543 -393 |
||
34 | 3543 393 |
||
35 | 5118 2000 5718 "2" "2" "square"] |
||
36 | |||
92 | jelle | 37 | |
347 | jelle | 38 | ElementLine[-393 -2755 393 -2755 800] |
39 | ElementLine[-393 2755 393 2755 800] |
||
40 | |||
92 | jelle | 41 | |
347 | jelle | 42 | # |
43 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
44 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
45 | # again, it is most useful during parts placement. It really is time for some |
||
46 | # additional non-fab layers... |
||
92 | jelle | 47 | |
347 | jelle | 48 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
49 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
50 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
51 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
92 | jelle | 52 | |
347 | jelle | 53 | ) |
54 | # grab the input values and convert to 1/100 mil |
||
55 | |||
56 | |||
57 | |||
58 | |||
59 | |||
60 | |||
61 | |||
62 | # how much to grow the pads by for soldermask [1/100 mil] |
||
63 | |||
64 | # clearance from planes [1/100 mil] |
||
65 | |||
66 | # silk screen width [1/100 mil] |
||
67 | |||
68 | # courtyard silk screen width [1/100 mil] |
||
69 | |||
70 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
71 | # text_x, text_y, text_direction, text_scale, text_flags |
||
72 | Element[0x00000000 "0805" "C1204" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 73 | ( |
347 | jelle | 74 | # |
75 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
76 | Pad[-3543 -393 |
||
77 | -3543 393 |
||
78 | 5118 2000 5718 "1" "1" "square"] |
||
79 | Pad[3543 -393 |
||
80 | 3543 393 |
||
81 | 5118 2000 5718 "2" "2" "square"] |
||
82 | |||
83 | |||
84 | ElementLine[-393 -2755 393 -2755 800] |
||
85 | ElementLine[-393 2755 393 2755 800] |
||
86 | |||
87 | |||
88 | # |
||
89 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
90 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
91 | # again, it is most useful during parts placement. It really is time for some |
||
92 | # additional non-fab layers... |
||
93 | |||
94 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
95 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
96 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
97 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
98 | |||
92 | jelle | 99 | ) |
347 | jelle | 100 | # grab the input values and convert to 1/100 mil |
101 | |||
102 | |||
103 | |||
104 | |||
105 | |||
106 | |||
107 | |||
108 | # how much to grow the pads by for soldermask [1/100 mil] |
||
109 | |||
110 | # clearance from planes [1/100 mil] |
||
111 | |||
112 | # silk screen width [1/100 mil] |
||
113 | |||
114 | # courtyard silk screen width [1/100 mil] |
||
115 | |||
116 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
117 | # text_x, text_y, text_direction, text_scale, text_flags |
||
118 | Element[0x00000000 "0805" "C1202" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 119 | ( |
347 | jelle | 120 | # |
121 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
122 | Pad[-3543 -393 |
||
123 | -3543 393 |
||
124 | 5118 2000 5718 "1" "1" "square"] |
||
125 | Pad[3543 -393 |
||
126 | 3543 393 |
||
127 | 5118 2000 5718 "2" "2" "square"] |
||
128 | |||
129 | |||
130 | ElementLine[-393 -2755 393 -2755 800] |
||
131 | ElementLine[-393 2755 393 2755 800] |
||
132 | |||
133 | |||
134 | # |
||
135 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
136 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
137 | # again, it is most useful during parts placement. It really is time for some |
||
138 | # additional non-fab layers... |
||
139 | |||
140 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
141 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
142 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
143 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
144 | |||
92 | jelle | 145 | ) |
347 | jelle | 146 | # grab the input values and convert to 1/100 mil |
147 | |||
148 | |||
149 | |||
150 | |||
151 | |||
152 | |||
153 | |||
154 | # how much to grow the pads by for soldermask [1/100 mil] |
||
155 | |||
156 | # clearance from planes [1/100 mil] |
||
157 | |||
158 | # silk screen width [1/100 mil] |
||
159 | |||
160 | # courtyard silk screen width [1/100 mil] |
||
161 | |||
162 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
163 | # text_x, text_y, text_direction, text_scale, text_flags |
||
164 | Element[0x00000000 "0805" "C1201" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 165 | ( |
347 | jelle | 166 | # |
167 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
168 | Pad[-3543 -393 |
||
169 | -3543 393 |
||
170 | 5118 2000 5718 "1" "1" "square"] |
||
171 | Pad[3543 -393 |
||
172 | 3543 393 |
||
173 | 5118 2000 5718 "2" "2" "square"] |
||
174 | |||
175 | |||
176 | ElementLine[-393 -2755 393 -2755 800] |
||
177 | ElementLine[-393 2755 393 2755 800] |
||
178 | |||
179 | |||
180 | # |
||
181 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
182 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
183 | # again, it is most useful during parts placement. It really is time for some |
||
184 | # additional non-fab layers... |
||
185 | |||
186 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
187 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
188 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
189 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
190 | |||
92 | jelle | 191 | ) |
347 | jelle | 192 | # grab the input values and convert to 1/100 mil |
193 | |||
194 | |||
195 | |||
196 | |||
197 | |||
198 | |||
199 | |||
200 | # how much to grow the pads by for soldermask [1/100 mil] |
||
201 | |||
202 | # clearance from planes [1/100 mil] |
||
203 | |||
204 | # silk screen width [1/100 mil] |
||
205 | |||
206 | # courtyard silk screen width [1/100 mil] |
||
207 | |||
208 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
209 | # text_x, text_y, text_direction, text_scale, text_flags |
||
210 | Element[0x00000000 "0805" "C1207" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 211 | ( |
347 | jelle | 212 | # |
213 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
214 | Pad[-3543 -393 |
||
215 | -3543 393 |
||
216 | 5118 2000 5718 "1" "1" "square"] |
||
217 | Pad[3543 -393 |
||
218 | 3543 393 |
||
219 | 5118 2000 5718 "2" "2" "square"] |
||
220 | |||
221 | |||
222 | ElementLine[-393 -2755 393 -2755 800] |
||
223 | ElementLine[-393 2755 393 2755 800] |
||
224 | |||
225 | |||
226 | # |
||
227 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
228 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
229 | # again, it is most useful during parts placement. It really is time for some |
||
230 | # additional non-fab layers... |
||
231 | |||
232 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
233 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
234 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
235 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
236 | |||
92 | jelle | 237 | ) |
347 | jelle | 238 | # grab the input values and convert to 1/100 mil |
239 | |||
240 | |||
241 | |||
242 | |||
243 | |||
244 | |||
245 | |||
246 | # how much to grow the pads by for soldermask [1/100 mil] |
||
247 | |||
248 | # clearance from planes [1/100 mil] |
||
249 | |||
250 | # silk screen width [1/100 mil] |
||
251 | |||
252 | # courtyard silk screen width [1/100 mil] |
||
253 | |||
254 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
255 | # text_x, text_y, text_direction, text_scale, text_flags |
||
256 | Element[0x00000000 "0805" "R902" "10k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 257 | ( |
347 | jelle | 258 | # |
259 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
260 | Pad[-3543 -393 |
||
261 | -3543 393 |
||
262 | 5118 2000 5718 "1" "1" "square"] |
||
263 | Pad[3543 -393 |
||
264 | 3543 393 |
||
265 | 5118 2000 5718 "2" "2" "square"] |
||
266 | |||
267 | |||
268 | ElementLine[-393 -2755 393 -2755 800] |
||
269 | ElementLine[-393 2755 393 2755 800] |
||
270 | |||
271 | |||
272 | # |
||
273 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
274 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
275 | # again, it is most useful during parts placement. It really is time for some |
||
276 | # additional non-fab layers... |
||
277 | |||
278 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
279 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
280 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
281 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
282 | |||
92 | jelle | 283 | ) |
347 | jelle | 284 | # grab the input values and convert to 1/100 mil |
285 | |||
286 | |||
287 | |||
288 | |||
289 | |||
290 | |||
291 | |||
292 | # how much to grow the pads by for soldermask [1/100 mil] |
||
293 | |||
294 | # clearance from planes [1/100 mil] |
||
295 | |||
296 | # silk screen width [1/100 mil] |
||
297 | |||
298 | # courtyard silk screen width [1/100 mil] |
||
299 | |||
300 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
301 | # text_x, text_y, text_direction, text_scale, text_flags |
||
302 | Element[0x00000000 "0805" "C707" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 303 | ( |
347 | jelle | 304 | # |
305 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
306 | Pad[-3543 -393 |
||
307 | -3543 393 |
||
308 | 5118 2000 5718 "1" "1" "square"] |
||
309 | Pad[3543 -393 |
||
310 | 3543 393 |
||
311 | 5118 2000 5718 "2" "2" "square"] |
||
312 | |||
313 | |||
314 | ElementLine[-393 -2755 393 -2755 800] |
||
315 | ElementLine[-393 2755 393 2755 800] |
||
316 | |||
317 | |||
318 | # |
||
319 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
320 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
321 | # again, it is most useful during parts placement. It really is time for some |
||
322 | # additional non-fab layers... |
||
323 | |||
324 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
325 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
326 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
327 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
328 | |||
92 | jelle | 329 | ) |
347 | jelle | 330 | # grab the input values and convert to 1/100 mil |
331 | |||
332 | |||
333 | |||
334 | |||
335 | |||
336 | |||
337 | |||
338 | # how much to grow the pads by for soldermask [1/100 mil] |
||
339 | |||
340 | # clearance from planes [1/100 mil] |
||
341 | |||
342 | # silk screen width [1/100 mil] |
||
343 | |||
344 | # courtyard silk screen width [1/100 mil] |
||
345 | |||
346 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
347 | # text_x, text_y, text_direction, text_scale, text_flags |
||
348 | Element[0x00000000 "0805" "C706" "33pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 349 | ( |
347 | jelle | 350 | # |
351 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
352 | Pad[-3543 -393 |
||
353 | -3543 393 |
||
354 | 5118 2000 5718 "1" "1" "square"] |
||
355 | Pad[3543 -393 |
||
356 | 3543 393 |
||
357 | 5118 2000 5718 "2" "2" "square"] |
||
358 | |||
359 | |||
360 | ElementLine[-393 -2755 393 -2755 800] |
||
361 | ElementLine[-393 2755 393 2755 800] |
||
362 | |||
363 | |||
364 | # |
||
365 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
366 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
367 | # again, it is most useful during parts placement. It really is time for some |
||
368 | # additional non-fab layers... |
||
369 | |||
370 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
371 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
372 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
373 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
374 | |||
92 | jelle | 375 | ) |
347 | jelle | 376 | # grab the input values and convert to 1/100 mil |
377 | |||
378 | |||
379 | |||
380 | |||
381 | |||
382 | |||
383 | |||
384 | # how much to grow the pads by for soldermask [1/100 mil] |
||
385 | |||
386 | # clearance from planes [1/100 mil] |
||
387 | |||
388 | # silk screen width [1/100 mil] |
||
389 | |||
390 | # courtyard silk screen width [1/100 mil] |
||
391 | |||
392 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
393 | # text_x, text_y, text_direction, text_scale, text_flags |
||
394 | Element[0x00000000 "0805" "C1203" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 395 | ( |
347 | jelle | 396 | # |
397 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
398 | Pad[-3543 -393 |
||
399 | -3543 393 |
||
400 | 5118 2000 5718 "1" "1" "square"] |
||
401 | Pad[3543 -393 |
||
402 | 3543 393 |
||
403 | 5118 2000 5718 "2" "2" "square"] |
||
404 | |||
405 | |||
406 | ElementLine[-393 -2755 393 -2755 800] |
||
407 | ElementLine[-393 2755 393 2755 800] |
||
408 | |||
409 | |||
410 | # |
||
411 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
412 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
413 | # again, it is most useful during parts placement. It really is time for some |
||
414 | # additional non-fab layers... |
||
415 | |||
416 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
417 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
418 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
419 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
420 | |||
92 | jelle | 421 | ) |
347 | jelle | 422 | # grab the input values and convert to 1/100 mil |
423 | |||
424 | |||
425 | |||
426 | |||
427 | |||
428 | |||
429 | |||
430 | # how much to grow the pads by for soldermask [1/100 mil] |
||
431 | |||
432 | # clearance from planes [1/100 mil] |
||
433 | |||
434 | # silk screen width [1/100 mil] |
||
435 | |||
436 | # courtyard silk screen width [1/100 mil] |
||
437 | |||
438 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
439 | # text_x, text_y, text_direction, text_scale, text_flags |
||
440 | Element[0x00000000 "0805" "C108" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 441 | ( |
347 | jelle | 442 | # |
443 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
444 | Pad[-3543 -393 |
||
445 | -3543 393 |
||
446 | 5118 2000 5718 "1" "1" "square"] |
||
447 | Pad[3543 -393 |
||
448 | 3543 393 |
||
449 | 5118 2000 5718 "2" "2" "square"] |
||
450 | |||
451 | |||
452 | ElementLine[-393 -2755 393 -2755 800] |
||
453 | ElementLine[-393 2755 393 2755 800] |
||
454 | |||
455 | |||
456 | # |
||
457 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
458 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
459 | # again, it is most useful during parts placement. It really is time for some |
||
460 | # additional non-fab layers... |
||
461 | |||
462 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
463 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
464 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
465 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
466 | |||
92 | jelle | 467 | ) |
347 | jelle | 468 | # grab the input values and convert to 1/100 mil |
469 | |||
470 | |||
471 | |||
472 | |||
473 | |||
474 | |||
475 | |||
476 | # how much to grow the pads by for soldermask [1/100 mil] |
||
477 | |||
478 | # clearance from planes [1/100 mil] |
||
479 | |||
480 | # silk screen width [1/100 mil] |
||
481 | |||
482 | # courtyard silk screen width [1/100 mil] |
||
483 | |||
484 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
485 | # text_x, text_y, text_direction, text_scale, text_flags |
||
486 | Element[0x00000000 "0805" "C709" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 487 | ( |
347 | jelle | 488 | # |
489 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
490 | Pad[-3543 -393 |
||
491 | -3543 393 |
||
492 | 5118 2000 5718 "1" "1" "square"] |
||
493 | Pad[3543 -393 |
||
494 | 3543 393 |
||
495 | 5118 2000 5718 "2" "2" "square"] |
||
496 | |||
497 | |||
498 | ElementLine[-393 -2755 393 -2755 800] |
||
499 | ElementLine[-393 2755 393 2755 800] |
||
500 | |||
501 | |||
502 | # |
||
503 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
504 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
505 | # again, it is most useful during parts placement. It really is time for some |
||
506 | # additional non-fab layers... |
||
507 | |||
508 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
509 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
510 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
511 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
512 | |||
92 | jelle | 513 | ) |
347 | jelle | 514 | # grab the input values and convert to 1/100 mil |
515 | |||
516 | |||
517 | |||
518 | |||
519 | |||
520 | |||
521 | |||
522 | # how much to grow the pads by for soldermask [1/100 mil] |
||
523 | |||
524 | # clearance from planes [1/100 mil] |
||
525 | |||
526 | # silk screen width [1/100 mil] |
||
527 | |||
528 | # courtyard silk screen width [1/100 mil] |
||
529 | |||
530 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
531 | # text_x, text_y, text_direction, text_scale, text_flags |
||
532 | Element[0x00000000 "0805" "C708" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 533 | ( |
347 | jelle | 534 | # |
535 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
536 | Pad[-3543 -393 |
||
537 | -3543 393 |
||
538 | 5118 2000 5718 "1" "1" "square"] |
||
539 | Pad[3543 -393 |
||
540 | 3543 393 |
||
541 | 5118 2000 5718 "2" "2" "square"] |
||
542 | |||
543 | |||
544 | ElementLine[-393 -2755 393 -2755 800] |
||
545 | ElementLine[-393 2755 393 2755 800] |
||
546 | |||
547 | |||
548 | # |
||
549 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
550 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
551 | # again, it is most useful during parts placement. It really is time for some |
||
552 | # additional non-fab layers... |
||
553 | |||
554 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
555 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
556 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
557 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
558 | |||
92 | jelle | 559 | ) |
347 | jelle | 560 | # grab the input values and convert to 1/100 mil |
561 | |||
562 | |||
563 | |||
564 | |||
565 | |||
566 | |||
567 | |||
568 | # how much to grow the pads by for soldermask [1/100 mil] |
||
569 | |||
570 | # clearance from planes [1/100 mil] |
||
571 | |||
572 | # silk screen width [1/100 mil] |
||
573 | |||
574 | # courtyard silk screen width [1/100 mil] |
||
575 | |||
576 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
577 | # text_x, text_y, text_direction, text_scale, text_flags |
||
578 | Element[0x00000000 "1210" "C109" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 579 | ( |
347 | jelle | 580 | # |
581 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
582 | Pad[-5905 -2755 |
||
583 | -5905 2755 |
||
584 | 5118 2000 5718 "1" "1" "square"] |
||
585 | Pad[5905 -2755 |
||
586 | 5905 2755 |
||
587 | 5118 2000 5718 "2" "2" "square"] |
||
588 | |||
589 | |||
590 | ElementLine[-1968 -5314 1968 -5314 800] |
||
591 | ElementLine[-1968 5314 1968 5314 800] |
||
592 | |||
593 | |||
594 | # |
||
595 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
596 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
597 | # again, it is most useful during parts placement. It really is time for some |
||
598 | # additional non-fab layers... |
||
599 | |||
600 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
601 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
602 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
603 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
604 | |||
92 | jelle | 605 | ) |
347 | jelle | 606 | # grab the input values and convert to 1/100 mil |
607 | |||
608 | |||
609 | |||
610 | |||
611 | |||
612 | |||
613 | |||
614 | # how much to grow the pads by for soldermask [1/100 mil] |
||
615 | |||
616 | # clearance from planes [1/100 mil] |
||
617 | |||
618 | # silk screen width [1/100 mil] |
||
619 | |||
620 | # courtyard silk screen width [1/100 mil] |
||
621 | |||
622 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
623 | # text_x, text_y, text_direction, text_scale, text_flags |
||
624 | Element[0x00000000 "1210" "C104" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 625 | ( |
347 | jelle | 626 | # |
627 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
628 | Pad[-5905 -2755 |
||
629 | -5905 2755 |
||
630 | 5118 2000 5718 "1" "1" "square"] |
||
631 | Pad[5905 -2755 |
||
632 | 5905 2755 |
||
633 | 5118 2000 5718 "2" "2" "square"] |
||
634 | |||
635 | |||
636 | ElementLine[-1968 -5314 1968 -5314 800] |
||
637 | ElementLine[-1968 5314 1968 5314 800] |
||
638 | |||
639 | |||
640 | # |
||
641 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
642 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
643 | # again, it is most useful during parts placement. It really is time for some |
||
644 | # additional non-fab layers... |
||
645 | |||
646 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
647 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
648 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
649 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
650 | |||
92 | jelle | 651 | ) |
347 | jelle | 652 | # grab the input values and convert to 1/100 mil |
653 | |||
654 | |||
655 | |||
656 | |||
657 | |||
658 | |||
659 | |||
660 | # how much to grow the pads by for soldermask [1/100 mil] |
||
661 | |||
662 | # clearance from planes [1/100 mil] |
||
663 | |||
664 | # silk screen width [1/100 mil] |
||
665 | |||
666 | # courtyard silk screen width [1/100 mil] |
||
667 | |||
668 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
669 | # text_x, text_y, text_direction, text_scale, text_flags |
||
670 | Element[0x00000000 "0805" "C1208" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 671 | ( |
347 | jelle | 672 | # |
673 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
674 | Pad[-3543 -393 |
||
675 | -3543 393 |
||
676 | 5118 2000 5718 "1" "1" "square"] |
||
677 | Pad[3543 -393 |
||
678 | 3543 393 |
||
679 | 5118 2000 5718 "2" "2" "square"] |
||
680 | |||
681 | |||
682 | ElementLine[-393 -2755 393 -2755 800] |
||
683 | ElementLine[-393 2755 393 2755 800] |
||
684 | |||
685 | |||
686 | # |
||
687 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
688 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
689 | # again, it is most useful during parts placement. It really is time for some |
||
690 | # additional non-fab layers... |
||
691 | |||
692 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
693 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
694 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
695 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
696 | |||
92 | jelle | 697 | ) |
347 | jelle | 698 | # grab the input values and convert to 1/100 mil |
699 | |||
700 | |||
701 | |||
702 | |||
703 | |||
704 | |||
705 | |||
706 | # how much to grow the pads by for soldermask [1/100 mil] |
||
707 | |||
708 | # clearance from planes [1/100 mil] |
||
709 | |||
710 | # silk screen width [1/100 mil] |
||
711 | |||
712 | # courtyard silk screen width [1/100 mil] |
||
713 | |||
714 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
715 | # text_x, text_y, text_direction, text_scale, text_flags |
||
716 | Element[0x00000000 "1210" "C106" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 717 | ( |
347 | jelle | 718 | # |
719 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
720 | Pad[-5905 -2755 |
||
721 | -5905 2755 |
||
722 | 5118 2000 5718 "1" "1" "square"] |
||
723 | Pad[5905 -2755 |
||
724 | 5905 2755 |
||
725 | 5118 2000 5718 "2" "2" "square"] |
||
726 | |||
727 | |||
728 | ElementLine[-1968 -5314 1968 -5314 800] |
||
729 | ElementLine[-1968 5314 1968 5314 800] |
||
730 | |||
731 | |||
732 | # |
||
733 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
734 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
735 | # again, it is most useful during parts placement. It really is time for some |
||
736 | # additional non-fab layers... |
||
737 | |||
738 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
739 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
740 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
741 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
742 | |||
92 | jelle | 743 | ) |
347 | jelle | 744 | # grab the input values and convert to 1/100 mil |
745 | |||
746 | |||
747 | |||
748 | |||
749 | |||
750 | |||
751 | |||
752 | # how much to grow the pads by for soldermask [1/100 mil] |
||
753 | |||
754 | # clearance from planes [1/100 mil] |
||
755 | |||
756 | # silk screen width [1/100 mil] |
||
757 | |||
758 | # courtyard silk screen width [1/100 mil] |
||
759 | |||
760 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
761 | # text_x, text_y, text_direction, text_scale, text_flags |
||
762 | Element[0x00000000 "0805" "C105" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 763 | ( |
347 | jelle | 764 | # |
765 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
766 | Pad[-3543 -393 |
||
767 | -3543 393 |
||
768 | 5118 2000 5718 "1" "1" "square"] |
||
769 | Pad[3543 -393 |
||
770 | 3543 393 |
||
771 | 5118 2000 5718 "2" "2" "square"] |
||
772 | |||
773 | |||
774 | ElementLine[-393 -2755 393 -2755 800] |
||
775 | ElementLine[-393 2755 393 2755 800] |
||
776 | |||
777 | |||
778 | # |
||
779 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
780 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
781 | # again, it is most useful during parts placement. It really is time for some |
||
782 | # additional non-fab layers... |
||
783 | |||
784 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
785 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
786 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
787 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
788 | |||
92 | jelle | 789 | ) |
347 | jelle | 790 | # grab the input values and convert to 1/100 mil |
791 | |||
792 | |||
793 | |||
794 | |||
795 | |||
796 | |||
797 | |||
798 | # how much to grow the pads by for soldermask [1/100 mil] |
||
799 | |||
800 | # clearance from planes [1/100 mil] |
||
801 | |||
802 | # silk screen width [1/100 mil] |
||
803 | |||
804 | # courtyard silk screen width [1/100 mil] |
||
805 | |||
806 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
807 | # text_x, text_y, text_direction, text_scale, text_flags |
||
808 | Element[0x00000000 "1210" "C107" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 809 | ( |
347 | jelle | 810 | # |
811 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
812 | Pad[-5905 -2755 |
||
813 | -5905 2755 |
||
814 | 5118 2000 5718 "1" "1" "square"] |
||
815 | Pad[5905 -2755 |
||
816 | 5905 2755 |
||
817 | 5118 2000 5718 "2" "2" "square"] |
||
818 | |||
819 | |||
820 | ElementLine[-1968 -5314 1968 -5314 800] |
||
821 | ElementLine[-1968 5314 1968 5314 800] |
||
822 | |||
823 | |||
824 | # |
||
825 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
826 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
827 | # again, it is most useful during parts placement. It really is time for some |
||
828 | # additional non-fab layers... |
||
829 | |||
830 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
831 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
832 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
833 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
834 | |||
92 | jelle | 835 | ) |
347 | jelle | 836 | # grab the input values and convert to 1/100 mil |
837 | |||
838 | |||
839 | |||
840 | |||
841 | |||
842 | |||
843 | |||
844 | # how much to grow the pads by for soldermask [1/100 mil] |
||
845 | |||
846 | # clearance from planes [1/100 mil] |
||
847 | |||
848 | # silk screen width [1/100 mil] |
||
849 | |||
850 | # courtyard silk screen width [1/100 mil] |
||
851 | |||
852 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
853 | # text_x, text_y, text_direction, text_scale, text_flags |
||
854 | Element[0x00000000 "0805" "C103" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 855 | ( |
347 | jelle | 856 | # |
857 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
858 | Pad[-3543 -393 |
||
859 | -3543 393 |
||
860 | 5118 2000 5718 "1" "1" "square"] |
||
861 | Pad[3543 -393 |
||
862 | 3543 393 |
||
863 | 5118 2000 5718 "2" "2" "square"] |
||
864 | |||
865 | |||
866 | ElementLine[-393 -2755 393 -2755 800] |
||
867 | ElementLine[-393 2755 393 2755 800] |
||
868 | |||
869 | |||
870 | # |
||
871 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
872 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
873 | # again, it is most useful during parts placement. It really is time for some |
||
874 | # additional non-fab layers... |
||
875 | |||
876 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
877 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
878 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
879 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
880 | |||
92 | jelle | 881 | ) |
347 | jelle | 882 | # grab the input values and convert to 1/100 mil |
883 | |||
884 | |||
885 | |||
886 | |||
887 | |||
888 | |||
889 | |||
890 | # how much to grow the pads by for soldermask [1/100 mil] |
||
891 | |||
892 | # clearance from planes [1/100 mil] |
||
893 | |||
894 | # silk screen width [1/100 mil] |
||
895 | |||
896 | # courtyard silk screen width [1/100 mil] |
||
897 | |||
898 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
899 | # text_x, text_y, text_direction, text_scale, text_flags |
||
900 | Element[0x00000000 "1210" "C102" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 901 | ( |
347 | jelle | 902 | # |
903 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
904 | Pad[-5905 -2755 |
||
905 | -5905 2755 |
||
906 | 5118 2000 5718 "1" "1" "square"] |
||
907 | Pad[5905 -2755 |
||
908 | 5905 2755 |
||
909 | 5118 2000 5718 "2" "2" "square"] |
||
910 | |||
911 | |||
912 | ElementLine[-1968 -5314 1968 -5314 800] |
||
913 | ElementLine[-1968 5314 1968 5314 800] |
||
914 | |||
915 | |||
916 | # |
||
917 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
918 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
919 | # again, it is most useful during parts placement. It really is time for some |
||
920 | # additional non-fab layers... |
||
921 | |||
922 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
923 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
924 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
925 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
926 | |||
92 | jelle | 927 | ) |
347 | jelle | 928 | # grab the input values and convert to 1/100 mil |
929 | |||
930 | |||
931 | |||
932 | |||
933 | |||
934 | |||
935 | |||
936 | # how much to grow the pads by for soldermask [1/100 mil] |
||
937 | |||
938 | # clearance from planes [1/100 mil] |
||
939 | |||
940 | # silk screen width [1/100 mil] |
||
941 | |||
942 | # courtyard silk screen width [1/100 mil] |
||
943 | |||
944 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
945 | # text_x, text_y, text_direction, text_scale, text_flags |
||
946 | Element[0x00000000 "0805" "R307" "100" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 947 | ( |
347 | jelle | 948 | # |
949 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
950 | Pad[-3543 -393 |
||
951 | -3543 393 |
||
952 | 5118 2000 5718 "1" "1" "square"] |
||
953 | Pad[3543 -393 |
||
954 | 3543 393 |
||
955 | 5118 2000 5718 "2" "2" "square"] |
||
956 | |||
957 | |||
958 | ElementLine[-393 -2755 393 -2755 800] |
||
959 | ElementLine[-393 2755 393 2755 800] |
||
960 | |||
961 | |||
962 | # |
||
963 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
964 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
965 | # again, it is most useful during parts placement. It really is time for some |
||
966 | # additional non-fab layers... |
||
967 | |||
968 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
969 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
970 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
971 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
972 | |||
92 | jelle | 973 | ) |
347 | jelle | 974 | # grab the input values and convert to 1/100 mil |
975 | |||
976 | |||
977 | |||
978 | |||
979 | |||
980 | |||
981 | |||
982 | # how much to grow the pads by for soldermask [1/100 mil] |
||
983 | |||
984 | # clearance from planes [1/100 mil] |
||
985 | |||
986 | # silk screen width [1/100 mil] |
||
987 | |||
988 | # courtyard silk screen width [1/100 mil] |
||
989 | |||
990 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
991 | # text_x, text_y, text_direction, text_scale, text_flags |
||
992 | Element[0x00000000 "0805" "R306" "100" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 993 | ( |
347 | jelle | 994 | # |
995 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
996 | Pad[-3543 -393 |
||
997 | -3543 393 |
||
998 | 5118 2000 5718 "1" "1" "square"] |
||
999 | Pad[3543 -393 |
||
1000 | 3543 393 |
||
1001 | 5118 2000 5718 "2" "2" "square"] |
||
1002 | |||
1003 | |||
1004 | ElementLine[-393 -2755 393 -2755 800] |
||
1005 | ElementLine[-393 2755 393 2755 800] |
||
1006 | |||
1007 | |||
1008 | # |
||
1009 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1010 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1011 | # again, it is most useful during parts placement. It really is time for some |
||
1012 | # additional non-fab layers... |
||
1013 | |||
1014 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1015 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1016 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1017 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1018 | |||
92 | jelle | 1019 | ) |
347 | jelle | 1020 | # grab the input values and convert to 1/100 mil |
1021 | |||
1022 | |||
1023 | |||
1024 | |||
1025 | |||
1026 | |||
1027 | |||
1028 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1029 | |||
1030 | # clearance from planes [1/100 mil] |
||
1031 | |||
1032 | # silk screen width [1/100 mil] |
||
1033 | |||
1034 | # courtyard silk screen width [1/100 mil] |
||
1035 | |||
1036 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1037 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1038 | Element[0x00000000 "0805" "R305" "100" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1039 | ( |
347 | jelle | 1040 | # |
1041 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1042 | Pad[-3543 -393 |
||
1043 | -3543 393 |
||
1044 | 5118 2000 5718 "1" "1" "square"] |
||
1045 | Pad[3543 -393 |
||
1046 | 3543 393 |
||
1047 | 5118 2000 5718 "2" "2" "square"] |
||
1048 | |||
1049 | |||
1050 | ElementLine[-393 -2755 393 -2755 800] |
||
1051 | ElementLine[-393 2755 393 2755 800] |
||
1052 | |||
1053 | |||
1054 | # |
||
1055 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1056 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1057 | # again, it is most useful during parts placement. It really is time for some |
||
1058 | # additional non-fab layers... |
||
1059 | |||
1060 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1061 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1062 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1063 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1064 | |||
92 | jelle | 1065 | ) |
347 | jelle | 1066 | # grab the input values and convert to 1/100 mil |
1067 | |||
1068 | |||
1069 | |||
1070 | |||
1071 | |||
1072 | |||
1073 | |||
1074 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1075 | |||
1076 | # clearance from planes [1/100 mil] |
||
1077 | |||
1078 | # silk screen width [1/100 mil] |
||
1079 | |||
1080 | # courtyard silk screen width [1/100 mil] |
||
1081 | |||
1082 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1083 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1084 | Element[0x00000000 "0805" "R304" "100" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1085 | ( |
347 | jelle | 1086 | # |
1087 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1088 | Pad[-3543 -393 |
||
1089 | -3543 393 |
||
1090 | 5118 2000 5718 "1" "1" "square"] |
||
1091 | Pad[3543 -393 |
||
1092 | 3543 393 |
||
1093 | 5118 2000 5718 "2" "2" "square"] |
||
1094 | |||
1095 | |||
1096 | ElementLine[-393 -2755 393 -2755 800] |
||
1097 | ElementLine[-393 2755 393 2755 800] |
||
1098 | |||
1099 | |||
1100 | # |
||
1101 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1102 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1103 | # again, it is most useful during parts placement. It really is time for some |
||
1104 | # additional non-fab layers... |
||
1105 | |||
1106 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1107 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1108 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1109 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1110 | |||
92 | jelle | 1111 | ) |
347 | jelle | 1112 | # grab the input values and convert to 1/100 mil |
1113 | |||
1114 | |||
1115 | |||
1116 | |||
1117 | |||
1118 | |||
1119 | |||
1120 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1121 | |||
1122 | # clearance from planes [1/100 mil] |
||
1123 | |||
1124 | # silk screen width [1/100 mil] |
||
1125 | |||
1126 | # courtyard silk screen width [1/100 mil] |
||
1127 | |||
1128 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1129 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1130 | Element[0x00000000 "0805" "R303" "100" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1131 | ( |
347 | jelle | 1132 | # |
1133 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1134 | Pad[-3543 -393 |
||
1135 | -3543 393 |
||
1136 | 5118 2000 5718 "1" "1" "square"] |
||
1137 | Pad[3543 -393 |
||
1138 | 3543 393 |
||
1139 | 5118 2000 5718 "2" "2" "square"] |
||
1140 | |||
1141 | |||
1142 | ElementLine[-393 -2755 393 -2755 800] |
||
1143 | ElementLine[-393 2755 393 2755 800] |
||
1144 | |||
1145 | |||
1146 | # |
||
1147 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1148 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1149 | # again, it is most useful during parts placement. It really is time for some |
||
1150 | # additional non-fab layers... |
||
1151 | |||
1152 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1153 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1154 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1155 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1156 | |||
92 | jelle | 1157 | ) |
347 | jelle | 1158 | # grab the input values and convert to 1/100 mil |
1159 | |||
1160 | |||
1161 | |||
1162 | |||
1163 | |||
1164 | |||
1165 | |||
1166 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1167 | |||
1168 | # clearance from planes [1/100 mil] |
||
1169 | |||
1170 | # silk screen width [1/100 mil] |
||
1171 | |||
1172 | # courtyard silk screen width [1/100 mil] |
||
1173 | |||
1174 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1175 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1176 | Element[0x00000000 "0805" "R302" "100" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1177 | ( |
347 | jelle | 1178 | # |
1179 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1180 | Pad[-3543 -393 |
||
1181 | -3543 393 |
||
1182 | 5118 2000 5718 "1" "1" "square"] |
||
1183 | Pad[3543 -393 |
||
1184 | 3543 393 |
||
1185 | 5118 2000 5718 "2" "2" "square"] |
||
1186 | |||
1187 | |||
1188 | ElementLine[-393 -2755 393 -2755 800] |
||
1189 | ElementLine[-393 2755 393 2755 800] |
||
1190 | |||
1191 | |||
1192 | # |
||
1193 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1194 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1195 | # again, it is most useful during parts placement. It really is time for some |
||
1196 | # additional non-fab layers... |
||
1197 | |||
1198 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1199 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1200 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1201 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1202 | |||
92 | jelle | 1203 | ) |
347 | jelle | 1204 | # grab the input values and convert to 1/100 mil |
1205 | |||
1206 | |||
1207 | |||
1208 | |||
1209 | |||
1210 | |||
1211 | |||
1212 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1213 | |||
1214 | # clearance from planes [1/100 mil] |
||
1215 | |||
1216 | # silk screen width [1/100 mil] |
||
1217 | |||
1218 | # courtyard silk screen width [1/100 mil] |
||
1219 | |||
1220 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1221 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1222 | Element[0x00000000 "0805" "R301" "100" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1223 | ( |
347 | jelle | 1224 | # |
1225 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1226 | Pad[-3543 -393 |
||
1227 | -3543 393 |
||
1228 | 5118 2000 5718 "1" "1" "square"] |
||
1229 | Pad[3543 -393 |
||
1230 | 3543 393 |
||
1231 | 5118 2000 5718 "2" "2" "square"] |
||
1232 | |||
1233 | |||
1234 | ElementLine[-393 -2755 393 -2755 800] |
||
1235 | ElementLine[-393 2755 393 2755 800] |
||
1236 | |||
1237 | |||
1238 | # |
||
1239 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1240 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1241 | # again, it is most useful during parts placement. It really is time for some |
||
1242 | # additional non-fab layers... |
||
1243 | |||
1244 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1245 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1246 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1247 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1248 | |||
92 | jelle | 1249 | ) |
347 | jelle | 1250 | # grab the input values and convert to 1/100 mil |
1251 | |||
1252 | |||
1253 | |||
1254 | |||
1255 | |||
1256 | |||
1257 | |||
1258 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1259 | |||
1260 | # clearance from planes [1/100 mil] |
||
1261 | |||
1262 | # silk screen width [1/100 mil] |
||
1263 | |||
1264 | # courtyard silk screen width [1/100 mil] |
||
1265 | |||
1266 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1267 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1268 | Element[0x00000000 "0805" "C705" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1269 | ( |
347 | jelle | 1270 | # |
1271 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1272 | Pad[-3543 -393 |
||
1273 | -3543 393 |
||
1274 | 5118 2000 5718 "1" "1" "square"] |
||
1275 | Pad[3543 -393 |
||
1276 | 3543 393 |
||
1277 | 5118 2000 5718 "2" "2" "square"] |
||
1278 | |||
1279 | |||
1280 | ElementLine[-393 -2755 393 -2755 800] |
||
1281 | ElementLine[-393 2755 393 2755 800] |
||
1282 | |||
1283 | |||
1284 | # |
||
1285 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1286 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1287 | # again, it is most useful during parts placement. It really is time for some |
||
1288 | # additional non-fab layers... |
||
1289 | |||
1290 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1291 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1292 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1293 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1294 | |||
92 | jelle | 1295 | ) |
347 | jelle | 1296 | # grab the input values and convert to 1/100 mil |
1297 | |||
1298 | |||
1299 | |||
1300 | |||
1301 | |||
1302 | |||
1303 | |||
1304 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1305 | |||
1306 | # clearance from planes [1/100 mil] |
||
1307 | |||
1308 | # silk screen width [1/100 mil] |
||
1309 | |||
1310 | # courtyard silk screen width [1/100 mil] |
||
1311 | |||
1312 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1313 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1314 | Element[0x00000000 "0805" "C704" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1315 | ( |
347 | jelle | 1316 | # |
1317 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1318 | Pad[-3543 -393 |
||
1319 | -3543 393 |
||
1320 | 5118 2000 5718 "1" "1" "square"] |
||
1321 | Pad[3543 -393 |
||
1322 | 3543 393 |
||
1323 | 5118 2000 5718 "2" "2" "square"] |
||
1324 | |||
1325 | |||
1326 | ElementLine[-393 -2755 393 -2755 800] |
||
1327 | ElementLine[-393 2755 393 2755 800] |
||
1328 | |||
1329 | |||
1330 | # |
||
1331 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1332 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1333 | # again, it is most useful during parts placement. It really is time for some |
||
1334 | # additional non-fab layers... |
||
1335 | |||
1336 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1337 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1338 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1339 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1340 | |||
92 | jelle | 1341 | ) |
347 | jelle | 1342 | # grab the input values and convert to 1/100 mil |
1343 | |||
1344 | |||
1345 | |||
1346 | |||
1347 | |||
1348 | |||
1349 | |||
1350 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1351 | |||
1352 | # clearance from planes [1/100 mil] |
||
1353 | |||
1354 | # silk screen width [1/100 mil] |
||
1355 | |||
1356 | # courtyard silk screen width [1/100 mil] |
||
1357 | |||
1358 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1359 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1360 | Element[0x00000000 "0805" "C703" "33pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1361 | ( |
347 | jelle | 1362 | # |
1363 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1364 | Pad[-3543 -393 |
||
1365 | -3543 393 |
||
1366 | 5118 2000 5718 "1" "1" "square"] |
||
1367 | Pad[3543 -393 |
||
1368 | 3543 393 |
||
1369 | 5118 2000 5718 "2" "2" "square"] |
||
1370 | |||
1371 | |||
1372 | ElementLine[-393 -2755 393 -2755 800] |
||
1373 | ElementLine[-393 2755 393 2755 800] |
||
1374 | |||
1375 | |||
1376 | # |
||
1377 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1378 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1379 | # again, it is most useful during parts placement. It really is time for some |
||
1380 | # additional non-fab layers... |
||
1381 | |||
1382 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1383 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1384 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1385 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1386 | |||
92 | jelle | 1387 | ) |
347 | jelle | 1388 | # grab the input values and convert to 1/100 mil |
1389 | |||
1390 | |||
1391 | |||
1392 | |||
1393 | |||
1394 | |||
1395 | |||
1396 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1397 | |||
1398 | # clearance from planes [1/100 mil] |
||
1399 | |||
1400 | # silk screen width [1/100 mil] |
||
1401 | |||
1402 | # courtyard silk screen width [1/100 mil] |
||
1403 | |||
1404 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1405 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1406 | Element[0x00000000 "0805" "C702" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1407 | ( |
347 | jelle | 1408 | # |
1409 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1410 | Pad[-3543 -393 |
||
1411 | -3543 393 |
||
1412 | 5118 2000 5718 "1" "1" "square"] |
||
1413 | Pad[3543 -393 |
||
1414 | 3543 393 |
||
1415 | 5118 2000 5718 "2" "2" "square"] |
||
1416 | |||
1417 | |||
1418 | ElementLine[-393 -2755 393 -2755 800] |
||
1419 | ElementLine[-393 2755 393 2755 800] |
||
1420 | |||
1421 | |||
1422 | # |
||
1423 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1424 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1425 | # again, it is most useful during parts placement. It really is time for some |
||
1426 | # additional non-fab layers... |
||
1427 | |||
1428 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1429 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1430 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1431 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1432 | |||
92 | jelle | 1433 | ) |
347 | jelle | 1434 | # grab the input values and convert to 1/100 mil |
1435 | |||
1436 | |||
1437 | |||
1438 | |||
1439 | |||
1440 | |||
1441 | |||
1442 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1443 | |||
1444 | # clearance from planes [1/100 mil] |
||
1445 | |||
1446 | # silk screen width [1/100 mil] |
||
1447 | |||
1448 | # courtyard silk screen width [1/100 mil] |
||
1449 | |||
1450 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1451 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1452 | Element[0x00000000 "1206" "C701" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1453 | ( |
347 | jelle | 1454 | # |
1455 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1456 | Pad[-5905 -1181 |
||
1457 | -5905 1181 |
||
1458 | 5118 2000 5718 "1" "1" "square"] |
||
1459 | Pad[5905 -1181 |
||
1460 | 5905 1181 |
||
1461 | 5118 2000 5718 "2" "2" "square"] |
||
1462 | |||
1463 | |||
1464 | ElementLine[-2362 -3740 2362 -3740 800] |
||
1465 | ElementLine[-2362 3740 2362 3740 800] |
||
1466 | |||
1467 | |||
1468 | # |
||
1469 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1470 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1471 | # again, it is most useful during parts placement. It really is time for some |
||
1472 | # additional non-fab layers... |
||
1473 | |||
1474 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1475 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1476 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1477 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1478 | |||
92 | jelle | 1479 | ) |
347 | jelle | 1480 | # grab the input values and convert to 1/100 mil |
1481 | |||
1482 | |||
1483 | |||
1484 | |||
1485 | |||
1486 | |||
1487 | |||
1488 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1489 | |||
1490 | # clearance from planes [1/100 mil] |
||
1491 | |||
1492 | # silk screen width [1/100 mil] |
||
1493 | |||
1494 | # courtyard silk screen width [1/100 mil] |
||
1495 | |||
1496 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1497 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1498 | Element[0x00000000 "0805" "C1305" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1499 | ( |
347 | jelle | 1500 | # |
1501 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1502 | Pad[-3543 -393 |
||
1503 | -3543 393 |
||
1504 | 5118 2000 5718 "1" "1" "square"] |
||
1505 | Pad[3543 -393 |
||
1506 | 3543 393 |
||
1507 | 5118 2000 5718 "2" "2" "square"] |
||
1508 | |||
1509 | |||
1510 | ElementLine[-393 -2755 393 -2755 800] |
||
1511 | ElementLine[-393 2755 393 2755 800] |
||
1512 | |||
1513 | |||
1514 | # |
||
1515 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1516 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1517 | # again, it is most useful during parts placement. It really is time for some |
||
1518 | # additional non-fab layers... |
||
1519 | |||
1520 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1521 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1522 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1523 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1524 | |||
92 | jelle | 1525 | ) |
347 | jelle | 1526 | # grab the input values and convert to 1/100 mil |
1527 | |||
1528 | |||
1529 | |||
1530 | |||
1531 | |||
1532 | |||
1533 | |||
1534 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1535 | |||
1536 | # clearance from planes [1/100 mil] |
||
1537 | |||
1538 | # silk screen width [1/100 mil] |
||
1539 | |||
1540 | # courtyard silk screen width [1/100 mil] |
||
1541 | |||
1542 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1543 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1544 | Element[0x00000000 "0805" "R1008" "33R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1545 | ( |
347 | jelle | 1546 | # |
1547 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1548 | Pad[-3543 -393 |
||
1549 | -3543 393 |
||
1550 | 5118 2000 5718 "1" "1" "square"] |
||
1551 | Pad[3543 -393 |
||
1552 | 3543 393 |
||
1553 | 5118 2000 5718 "2" "2" "square"] |
||
1554 | |||
1555 | |||
1556 | ElementLine[-393 -2755 393 -2755 800] |
||
1557 | ElementLine[-393 2755 393 2755 800] |
||
1558 | |||
1559 | |||
1560 | # |
||
1561 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1562 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1563 | # again, it is most useful during parts placement. It really is time for some |
||
1564 | # additional non-fab layers... |
||
1565 | |||
1566 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1567 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1568 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1569 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1570 | |||
92 | jelle | 1571 | ) |
347 | jelle | 1572 | # grab the input values and convert to 1/100 mil |
1573 | |||
1574 | |||
1575 | |||
1576 | |||
1577 | |||
1578 | |||
1579 | |||
1580 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1581 | |||
1582 | # clearance from planes [1/100 mil] |
||
1583 | |||
1584 | # silk screen width [1/100 mil] |
||
1585 | |||
1586 | # courtyard silk screen width [1/100 mil] |
||
1587 | |||
1588 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1589 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1590 | Element[0x00000000 "0805" "R1007" "33R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1591 | ( |
347 | jelle | 1592 | # |
1593 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1594 | Pad[-3543 -393 |
||
1595 | -3543 393 |
||
1596 | 5118 2000 5718 "1" "1" "square"] |
||
1597 | Pad[3543 -393 |
||
1598 | 3543 393 |
||
1599 | 5118 2000 5718 "2" "2" "square"] |
||
1600 | |||
1601 | |||
1602 | ElementLine[-393 -2755 393 -2755 800] |
||
1603 | ElementLine[-393 2755 393 2755 800] |
||
1604 | |||
1605 | |||
1606 | # |
||
1607 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1608 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1609 | # again, it is most useful during parts placement. It really is time for some |
||
1610 | # additional non-fab layers... |
||
1611 | |||
1612 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1613 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1614 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1615 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1616 | |||
92 | jelle | 1617 | ) |
347 | jelle | 1618 | # grab the input values and convert to 1/100 mil |
1619 | |||
1620 | |||
1621 | |||
1622 | |||
1623 | |||
1624 | |||
1625 | |||
1626 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1627 | |||
1628 | # clearance from planes [1/100 mil] |
||
1629 | |||
1630 | # silk screen width [1/100 mil] |
||
1631 | |||
1632 | # courtyard silk screen width [1/100 mil] |
||
1633 | |||
1634 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1635 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1636 | Element[0x00000000 "0805" "C1304" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1637 | ( |
347 | jelle | 1638 | # |
1639 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1640 | Pad[-3543 -393 |
||
1641 | -3543 393 |
||
1642 | 5118 2000 5718 "1" "1" "square"] |
||
1643 | Pad[3543 -393 |
||
1644 | 3543 393 |
||
1645 | 5118 2000 5718 "2" "2" "square"] |
||
1646 | |||
1647 | |||
1648 | ElementLine[-393 -2755 393 -2755 800] |
||
1649 | ElementLine[-393 2755 393 2755 800] |
||
1650 | |||
1651 | |||
1652 | # |
||
1653 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1654 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1655 | # again, it is most useful during parts placement. It really is time for some |
||
1656 | # additional non-fab layers... |
||
1657 | |||
1658 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1659 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1660 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1661 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1662 | |||
92 | jelle | 1663 | ) |
347 | jelle | 1664 | # grab the input values and convert to 1/100 mil |
1665 | |||
1666 | |||
1667 | |||
1668 | |||
1669 | |||
1670 | |||
1671 | |||
1672 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1673 | |||
1674 | # clearance from planes [1/100 mil] |
||
1675 | |||
1676 | # silk screen width [1/100 mil] |
||
1677 | |||
1678 | # courtyard silk screen width [1/100 mil] |
||
1679 | |||
1680 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1681 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1682 | Element[0x00000000 "0805" "R1004" "3.3k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1683 | ( |
347 | jelle | 1684 | # |
1685 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1686 | Pad[-3543 -393 |
||
1687 | -3543 393 |
||
1688 | 5118 2000 5718 "1" "1" "square"] |
||
1689 | Pad[3543 -393 |
||
1690 | 3543 393 |
||
1691 | 5118 2000 5718 "2" "2" "square"] |
||
1692 | |||
1693 | |||
1694 | ElementLine[-393 -2755 393 -2755 800] |
||
1695 | ElementLine[-393 2755 393 2755 800] |
||
1696 | |||
1697 | |||
1698 | # |
||
1699 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1700 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1701 | # again, it is most useful during parts placement. It really is time for some |
||
1702 | # additional non-fab layers... |
||
1703 | |||
1704 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1705 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1706 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1707 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1708 | |||
92 | jelle | 1709 | ) |
347 | jelle | 1710 | # grab the input values and convert to 1/100 mil |
1711 | |||
1712 | |||
1713 | |||
1714 | |||
1715 | |||
1716 | |||
1717 | |||
1718 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1719 | |||
1720 | # clearance from planes [1/100 mil] |
||
1721 | |||
1722 | # silk screen width [1/100 mil] |
||
1723 | |||
1724 | # courtyard silk screen width [1/100 mil] |
||
1725 | |||
1726 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1727 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1728 | Element[0x00000000 "0805" "R1003" "10k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1729 | ( |
347 | jelle | 1730 | # |
1731 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1732 | Pad[-3543 -393 |
||
1733 | -3543 393 |
||
1734 | 5118 2000 5718 "1" "1" "square"] |
||
1735 | Pad[3543 -393 |
||
1736 | 3543 393 |
||
1737 | 5118 2000 5718 "2" "2" "square"] |
||
1738 | |||
1739 | |||
1740 | ElementLine[-393 -2755 393 -2755 800] |
||
1741 | ElementLine[-393 2755 393 2755 800] |
||
1742 | |||
1743 | |||
1744 | # |
||
1745 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1746 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1747 | # again, it is most useful during parts placement. It really is time for some |
||
1748 | # additional non-fab layers... |
||
1749 | |||
1750 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1751 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1752 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1753 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1754 | |||
92 | jelle | 1755 | ) |
347 | jelle | 1756 | # grab the input values and convert to 1/100 mil |
1757 | |||
1758 | |||
1759 | |||
1760 | |||
1761 | |||
1762 | |||
1763 | |||
1764 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1765 | |||
1766 | # clearance from planes [1/100 mil] |
||
1767 | |||
1768 | # silk screen width [1/100 mil] |
||
1769 | |||
1770 | # courtyard silk screen width [1/100 mil] |
||
1771 | |||
1772 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1773 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1774 | Element[0x00000000 "0805" "R1002" "10k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1775 | ( |
347 | jelle | 1776 | # |
1777 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1778 | Pad[-3543 -393 |
||
1779 | -3543 393 |
||
1780 | 5118 2000 5718 "1" "1" "square"] |
||
1781 | Pad[3543 -393 |
||
1782 | 3543 393 |
||
1783 | 5118 2000 5718 "2" "2" "square"] |
||
1784 | |||
1785 | |||
1786 | ElementLine[-393 -2755 393 -2755 800] |
||
1787 | ElementLine[-393 2755 393 2755 800] |
||
1788 | |||
1789 | |||
1790 | # |
||
1791 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1792 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1793 | # again, it is most useful during parts placement. It really is time for some |
||
1794 | # additional non-fab layers... |
||
1795 | |||
1796 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1797 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1798 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1799 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1800 | |||
92 | jelle | 1801 | ) |
347 | jelle | 1802 | # grab the input values and convert to 1/100 mil |
1803 | |||
1804 | |||
1805 | |||
1806 | |||
1807 | |||
1808 | |||
1809 | |||
1810 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1811 | |||
1812 | # clearance from planes [1/100 mil] |
||
1813 | |||
1814 | # silk screen width [1/100 mil] |
||
1815 | |||
1816 | # courtyard silk screen width [1/100 mil] |
||
1817 | |||
1818 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1819 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1820 | Element[0x00000000 "0805" "R1005" "3.3k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1821 | ( |
347 | jelle | 1822 | # |
1823 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1824 | Pad[-3543 -393 |
||
1825 | -3543 393 |
||
1826 | 5118 2000 5718 "1" "1" "square"] |
||
1827 | Pad[3543 -393 |
||
1828 | 3543 393 |
||
1829 | 5118 2000 5718 "2" "2" "square"] |
||
1830 | |||
1831 | |||
1832 | ElementLine[-393 -2755 393 -2755 800] |
||
1833 | ElementLine[-393 2755 393 2755 800] |
||
1834 | |||
1835 | |||
1836 | # |
||
1837 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1838 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1839 | # again, it is most useful during parts placement. It really is time for some |
||
1840 | # additional non-fab layers... |
||
1841 | |||
1842 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1843 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1844 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1845 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1846 | |||
92 | jelle | 1847 | ) |
347 | jelle | 1848 | # grab the input values and convert to 1/100 mil |
1849 | |||
1850 | |||
1851 | |||
1852 | |||
1853 | |||
1854 | |||
1855 | |||
1856 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1857 | |||
1858 | # clearance from planes [1/100 mil] |
||
1859 | |||
1860 | # silk screen width [1/100 mil] |
||
1861 | |||
1862 | # courtyard silk screen width [1/100 mil] |
||
1863 | |||
1864 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1865 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1866 | Element[0x00000000 "0805" "R1006" "100k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1867 | ( |
347 | jelle | 1868 | # |
1869 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1870 | Pad[-3543 -393 |
||
1871 | -3543 393 |
||
1872 | 5118 2000 5718 "1" "1" "square"] |
||
1873 | Pad[3543 -393 |
||
1874 | 3543 393 |
||
1875 | 5118 2000 5718 "2" "2" "square"] |
||
1876 | |||
1877 | |||
1878 | ElementLine[-393 -2755 393 -2755 800] |
||
1879 | ElementLine[-393 2755 393 2755 800] |
||
1880 | |||
1881 | |||
1882 | # |
||
1883 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1884 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1885 | # again, it is most useful during parts placement. It really is time for some |
||
1886 | # additional non-fab layers... |
||
1887 | |||
1888 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1889 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1890 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1891 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1892 | |||
92 | jelle | 1893 | ) |
347 | jelle | 1894 | # grab the input values and convert to 1/100 mil |
1895 | |||
1896 | |||
1897 | |||
1898 | |||
1899 | |||
1900 | |||
1901 | |||
1902 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1903 | |||
1904 | # clearance from planes [1/100 mil] |
||
1905 | |||
1906 | # silk screen width [1/100 mil] |
||
1907 | |||
1908 | # courtyard silk screen width [1/100 mil] |
||
1909 | |||
1910 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1911 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1912 | Element[0x00000000 "0805" "C203" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1913 | ( |
347 | jelle | 1914 | # |
1915 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1916 | Pad[-3543 -393 |
||
1917 | -3543 393 |
||
1918 | 5118 2000 5718 "1" "1" "square"] |
||
1919 | Pad[3543 -393 |
||
1920 | 3543 393 |
||
1921 | 5118 2000 5718 "2" "2" "square"] |
||
1922 | |||
1923 | |||
1924 | ElementLine[-393 -2755 393 -2755 800] |
||
1925 | ElementLine[-393 2755 393 2755 800] |
||
1926 | |||
1927 | |||
1928 | # |
||
1929 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1930 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1931 | # again, it is most useful during parts placement. It really is time for some |
||
1932 | # additional non-fab layers... |
||
1933 | |||
1934 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1935 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1936 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1937 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1938 | |||
92 | jelle | 1939 | ) |
347 | jelle | 1940 | # grab the input values and convert to 1/100 mil |
1941 | |||
1942 | |||
1943 | |||
1944 | |||
1945 | |||
1946 | |||
1947 | |||
1948 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1949 | |||
1950 | # clearance from planes [1/100 mil] |
||
1951 | |||
1952 | # silk screen width [1/100 mil] |
||
1953 | |||
1954 | # courtyard silk screen width [1/100 mil] |
||
1955 | |||
1956 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
1957 | # text_x, text_y, text_direction, text_scale, text_flags |
||
1958 | Element[0x00000000 "0805" "C202" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 1959 | ( |
347 | jelle | 1960 | # |
1961 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
1962 | Pad[-3543 -393 |
||
1963 | -3543 393 |
||
1964 | 5118 2000 5718 "1" "1" "square"] |
||
1965 | Pad[3543 -393 |
||
1966 | 3543 393 |
||
1967 | 5118 2000 5718 "2" "2" "square"] |
||
1968 | |||
1969 | |||
1970 | ElementLine[-393 -2755 393 -2755 800] |
||
1971 | ElementLine[-393 2755 393 2755 800] |
||
1972 | |||
1973 | |||
1974 | # |
||
1975 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
1976 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
1977 | # again, it is most useful during parts placement. It really is time for some |
||
1978 | # additional non-fab layers... |
||
1979 | |||
1980 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1981 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1982 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
1983 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
1984 | |||
92 | jelle | 1985 | ) |
347 | jelle | 1986 | # grab the input values and convert to 1/100 mil |
1987 | |||
1988 | |||
1989 | |||
1990 | |||
1991 | |||
1992 | |||
1993 | |||
1994 | # how much to grow the pads by for soldermask [1/100 mil] |
||
1995 | |||
1996 | # clearance from planes [1/100 mil] |
||
1997 | |||
1998 | # silk screen width [1/100 mil] |
||
1999 | |||
2000 | # courtyard silk screen width [1/100 mil] |
||
2001 | |||
2002 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2003 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2004 | Element[0x00000000 "0805" "C201" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2005 | ( |
347 | jelle | 2006 | # |
2007 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2008 | Pad[-3543 -393 |
||
2009 | -3543 393 |
||
2010 | 5118 2000 5718 "1" "1" "square"] |
||
2011 | Pad[3543 -393 |
||
2012 | 3543 393 |
||
2013 | 5118 2000 5718 "2" "2" "square"] |
||
2014 | |||
2015 | |||
2016 | ElementLine[-393 -2755 393 -2755 800] |
||
2017 | ElementLine[-393 2755 393 2755 800] |
||
2018 | |||
2019 | |||
2020 | # |
||
2021 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2022 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2023 | # again, it is most useful during parts placement. It really is time for some |
||
2024 | # additional non-fab layers... |
||
2025 | |||
2026 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2027 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2028 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2029 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2030 | |||
92 | jelle | 2031 | ) |
347 | jelle | 2032 | # grab the input values and convert to 1/100 mil |
2033 | |||
2034 | |||
2035 | |||
2036 | |||
2037 | |||
2038 | |||
2039 | |||
2040 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2041 | |||
2042 | # clearance from planes [1/100 mil] |
||
2043 | |||
2044 | # silk screen width [1/100 mil] |
||
2045 | |||
2046 | # courtyard silk screen width [1/100 mil] |
||
2047 | |||
2048 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2049 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2050 | Element[0x00000000 "0805" "R401" "0" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2051 | ( |
347 | jelle | 2052 | # |
2053 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2054 | Pad[-3543 -393 |
||
2055 | -3543 393 |
||
2056 | 5118 2000 5718 "1" "1" "square"] |
||
2057 | Pad[3543 -393 |
||
2058 | 3543 393 |
||
2059 | 5118 2000 5718 "2" "2" "square"] |
||
2060 | |||
2061 | |||
2062 | ElementLine[-393 -2755 393 -2755 800] |
||
2063 | ElementLine[-393 2755 393 2755 800] |
||
2064 | |||
2065 | |||
2066 | # |
||
2067 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2068 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2069 | # again, it is most useful during parts placement. It really is time for some |
||
2070 | # additional non-fab layers... |
||
2071 | |||
2072 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2073 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2074 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2075 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2076 | |||
92 | jelle | 2077 | ) |
347 | jelle | 2078 | # grab the input values and convert to 1/100 mil |
2079 | |||
2080 | |||
2081 | |||
2082 | |||
2083 | |||
2084 | |||
2085 | |||
2086 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2087 | |||
2088 | # clearance from planes [1/100 mil] |
||
2089 | |||
2090 | # silk screen width [1/100 mil] |
||
2091 | |||
2092 | # courtyard silk screen width [1/100 mil] |
||
2093 | |||
2094 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2095 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2096 | Element[0x00000000 "0805" "R402" "0" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2097 | ( |
347 | jelle | 2098 | # |
2099 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2100 | Pad[-3543 -393 |
||
2101 | -3543 393 |
||
2102 | 5118 2000 5718 "1" "1" "square"] |
||
2103 | Pad[3543 -393 |
||
2104 | 3543 393 |
||
2105 | 5118 2000 5718 "2" "2" "square"] |
||
2106 | |||
2107 | |||
2108 | ElementLine[-393 -2755 393 -2755 800] |
||
2109 | ElementLine[-393 2755 393 2755 800] |
||
2110 | |||
2111 | |||
2112 | # |
||
2113 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2114 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2115 | # again, it is most useful during parts placement. It really is time for some |
||
2116 | # additional non-fab layers... |
||
2117 | |||
2118 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2119 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2120 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2121 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2122 | |||
92 | jelle | 2123 | ) |
347 | jelle | 2124 | # grab the input values and convert to 1/100 mil |
2125 | |||
2126 | |||
2127 | |||
2128 | |||
2129 | |||
2130 | |||
2131 | |||
2132 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2133 | |||
2134 | # clearance from planes [1/100 mil] |
||
2135 | |||
2136 | # silk screen width [1/100 mil] |
||
2137 | |||
2138 | # courtyard silk screen width [1/100 mil] |
||
2139 | |||
2140 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2141 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2142 | Element[0x00000000 "0805" "R1001" "100k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2143 | ( |
347 | jelle | 2144 | # |
2145 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2146 | Pad[-3543 -393 |
||
2147 | -3543 393 |
||
2148 | 5118 2000 5718 "1" "1" "square"] |
||
2149 | Pad[3543 -393 |
||
2150 | 3543 393 |
||
2151 | 5118 2000 5718 "2" "2" "square"] |
||
2152 | |||
2153 | |||
2154 | ElementLine[-393 -2755 393 -2755 800] |
||
2155 | ElementLine[-393 2755 393 2755 800] |
||
2156 | |||
2157 | |||
2158 | # |
||
2159 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2160 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2161 | # again, it is most useful during parts placement. It really is time for some |
||
2162 | # additional non-fab layers... |
||
2163 | |||
2164 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2165 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2166 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2167 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2168 | |||
92 | jelle | 2169 | ) |
347 | jelle | 2170 | # grab the input values and convert to 1/100 mil |
2171 | |||
2172 | |||
2173 | |||
2174 | |||
2175 | |||
2176 | |||
2177 | |||
2178 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2179 | |||
2180 | # clearance from planes [1/100 mil] |
||
2181 | |||
2182 | # silk screen width [1/100 mil] |
||
2183 | |||
2184 | # courtyard silk screen width [1/100 mil] |
||
2185 | |||
2186 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2187 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2188 | Element[0x00000000 "0805" "C1303" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2189 | ( |
347 | jelle | 2190 | # |
2191 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2192 | Pad[-3543 -393 |
||
2193 | -3543 393 |
||
2194 | 5118 2000 5718 "1" "1" "square"] |
||
2195 | Pad[3543 -393 |
||
2196 | 3543 393 |
||
2197 | 5118 2000 5718 "2" "2" "square"] |
||
2198 | |||
2199 | |||
2200 | ElementLine[-393 -2755 393 -2755 800] |
||
2201 | ElementLine[-393 2755 393 2755 800] |
||
2202 | |||
2203 | |||
2204 | # |
||
2205 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2206 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2207 | # again, it is most useful during parts placement. It really is time for some |
||
2208 | # additional non-fab layers... |
||
2209 | |||
2210 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2211 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2212 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2213 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2214 | |||
92 | jelle | 2215 | ) |
347 | jelle | 2216 | # grab the input values and convert to 1/100 mil |
2217 | |||
2218 | |||
2219 | |||
2220 | |||
2221 | |||
2222 | |||
2223 | |||
2224 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2225 | |||
2226 | # clearance from planes [1/100 mil] |
||
2227 | |||
2228 | # silk screen width [1/100 mil] |
||
2229 | |||
2230 | # courtyard silk screen width [1/100 mil] |
||
2231 | |||
2232 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2233 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2234 | Element[0x00000000 "0805" "C1302" "22pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2235 | ( |
347 | jelle | 2236 | # |
2237 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2238 | Pad[-3543 -393 |
||
2239 | -3543 393 |
||
2240 | 5118 2000 5718 "1" "1" "square"] |
||
2241 | Pad[3543 -393 |
||
2242 | 3543 393 |
||
2243 | 5118 2000 5718 "2" "2" "square"] |
||
2244 | |||
2245 | |||
2246 | ElementLine[-393 -2755 393 -2755 800] |
||
2247 | ElementLine[-393 2755 393 2755 800] |
||
2248 | |||
2249 | |||
2250 | # |
||
2251 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2252 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2253 | # again, it is most useful during parts placement. It really is time for some |
||
2254 | # additional non-fab layers... |
||
2255 | |||
2256 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2257 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2258 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2259 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2260 | |||
92 | jelle | 2261 | ) |
347 | jelle | 2262 | # grab the input values and convert to 1/100 mil |
2263 | |||
2264 | |||
2265 | |||
2266 | |||
2267 | |||
2268 | |||
2269 | |||
2270 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2271 | |||
2272 | # clearance from planes [1/100 mil] |
||
2273 | |||
2274 | # silk screen width [1/100 mil] |
||
2275 | |||
2276 | # courtyard silk screen width [1/100 mil] |
||
2277 | |||
2278 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2279 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2280 | Element[0x00000000 "0805" "C1301" "22pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2281 | ( |
347 | jelle | 2282 | # |
2283 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2284 | Pad[-3543 -393 |
||
2285 | -3543 393 |
||
2286 | 5118 2000 5718 "1" "1" "square"] |
||
2287 | Pad[3543 -393 |
||
2288 | 3543 393 |
||
2289 | 5118 2000 5718 "2" "2" "square"] |
||
2290 | |||
2291 | |||
2292 | ElementLine[-393 -2755 393 -2755 800] |
||
2293 | ElementLine[-393 2755 393 2755 800] |
||
2294 | |||
2295 | |||
2296 | # |
||
2297 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2298 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2299 | # again, it is most useful during parts placement. It really is time for some |
||
2300 | # additional non-fab layers... |
||
2301 | |||
2302 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2303 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2304 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2305 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2306 | |||
92 | jelle | 2307 | ) |
347 | jelle | 2308 | # grab the input values and convert to 1/100 mil |
2309 | |||
2310 | |||
2311 | |||
2312 | |||
2313 | |||
2314 | |||
2315 | |||
2316 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2317 | |||
2318 | # clearance from planes [1/100 mil] |
||
2319 | |||
2320 | # silk screen width [1/100 mil] |
||
2321 | |||
2322 | # courtyard silk screen width [1/100 mil] |
||
2323 | |||
2324 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2325 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2326 | Element[0x00000000 "0805" "C913" "10pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2327 | ( |
347 | jelle | 2328 | # |
2329 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2330 | Pad[-3543 -393 |
||
2331 | -3543 393 |
||
2332 | 5118 2000 5718 "1" "1" "square"] |
||
2333 | Pad[3543 -393 |
||
2334 | 3543 393 |
||
2335 | 5118 2000 5718 "2" "2" "square"] |
||
2336 | |||
2337 | |||
2338 | ElementLine[-393 -2755 393 -2755 800] |
||
2339 | ElementLine[-393 2755 393 2755 800] |
||
2340 | |||
2341 | |||
2342 | # |
||
2343 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2344 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2345 | # again, it is most useful during parts placement. It really is time for some |
||
2346 | # additional non-fab layers... |
||
2347 | |||
2348 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2349 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2350 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2351 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2352 | |||
92 | jelle | 2353 | ) |
347 | jelle | 2354 | # grab the input values and convert to 1/100 mil |
2355 | |||
2356 | |||
2357 | |||
2358 | |||
2359 | |||
2360 | |||
2361 | |||
2362 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2363 | |||
2364 | # clearance from planes [1/100 mil] |
||
2365 | |||
2366 | # silk screen width [1/100 mil] |
||
2367 | |||
2368 | # courtyard silk screen width [1/100 mil] |
||
2369 | |||
2370 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2371 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2372 | Element[0x00000000 "0805" "C912" "10pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2373 | ( |
347 | jelle | 2374 | # |
2375 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2376 | Pad[-3543 -393 |
||
2377 | -3543 393 |
||
2378 | 5118 2000 5718 "1" "1" "square"] |
||
2379 | Pad[3543 -393 |
||
2380 | 3543 393 |
||
2381 | 5118 2000 5718 "2" "2" "square"] |
||
2382 | |||
2383 | |||
2384 | ElementLine[-393 -2755 393 -2755 800] |
||
2385 | ElementLine[-393 2755 393 2755 800] |
||
2386 | |||
2387 | |||
2388 | # |
||
2389 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2390 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2391 | # again, it is most useful during parts placement. It really is time for some |
||
2392 | # additional non-fab layers... |
||
2393 | |||
2394 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2395 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2396 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2397 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2398 | |||
92 | jelle | 2399 | ) |
347 | jelle | 2400 | # grab the input values and convert to 1/100 mil |
2401 | |||
2402 | |||
2403 | |||
2404 | |||
2405 | |||
2406 | |||
2407 | |||
2408 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2409 | |||
2410 | # clearance from planes [1/100 mil] |
||
2411 | |||
2412 | # silk screen width [1/100 mil] |
||
2413 | |||
2414 | # courtyard silk screen width [1/100 mil] |
||
2415 | |||
2416 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2417 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2418 | Element[0x00000000 "0805" "C911" "22pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2419 | ( |
347 | jelle | 2420 | # |
2421 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2422 | Pad[-3543 -393 |
||
2423 | -3543 393 |
||
2424 | 5118 2000 5718 "1" "1" "square"] |
||
2425 | Pad[3543 -393 |
||
2426 | 3543 393 |
||
2427 | 5118 2000 5718 "2" "2" "square"] |
||
2428 | |||
2429 | |||
2430 | ElementLine[-393 -2755 393 -2755 800] |
||
2431 | ElementLine[-393 2755 393 2755 800] |
||
2432 | |||
2433 | |||
2434 | # |
||
2435 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2436 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2437 | # again, it is most useful during parts placement. It really is time for some |
||
2438 | # additional non-fab layers... |
||
2439 | |||
2440 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2441 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2442 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2443 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2444 | |||
92 | jelle | 2445 | ) |
347 | jelle | 2446 | # grab the input values and convert to 1/100 mil |
2447 | |||
2448 | |||
2449 | |||
2450 | |||
2451 | |||
2452 | |||
2453 | |||
2454 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2455 | |||
2456 | # clearance from planes [1/100 mil] |
||
2457 | |||
2458 | # silk screen width [1/100 mil] |
||
2459 | |||
2460 | # courtyard silk screen width [1/100 mil] |
||
2461 | |||
2462 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2463 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2464 | Element[0x00000000 "0805" "C910" "22pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2465 | ( |
347 | jelle | 2466 | # |
2467 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2468 | Pad[-3543 -393 |
||
2469 | -3543 393 |
||
2470 | 5118 2000 5718 "1" "1" "square"] |
||
2471 | Pad[3543 -393 |
||
2472 | 3543 393 |
||
2473 | 5118 2000 5718 "2" "2" "square"] |
||
2474 | |||
2475 | |||
2476 | ElementLine[-393 -2755 393 -2755 800] |
||
2477 | ElementLine[-393 2755 393 2755 800] |
||
2478 | |||
2479 | |||
2480 | # |
||
2481 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2482 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2483 | # again, it is most useful during parts placement. It really is time for some |
||
2484 | # additional non-fab layers... |
||
2485 | |||
2486 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2487 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2488 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2489 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2490 | |||
92 | jelle | 2491 | ) |
347 | jelle | 2492 | # grab the input values and convert to 1/100 mil |
2493 | |||
2494 | |||
2495 | |||
2496 | |||
2497 | |||
2498 | |||
2499 | |||
2500 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2501 | |||
2502 | # clearance from planes [1/100 mil] |
||
2503 | |||
2504 | # silk screen width [1/100 mil] |
||
2505 | |||
2506 | # courtyard silk screen width [1/100 mil] |
||
2507 | |||
2508 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2509 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2510 | Element[0x00000000 "0805" "C423" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2511 | ( |
347 | jelle | 2512 | # |
2513 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2514 | Pad[-3543 -393 |
||
2515 | -3543 393 |
||
2516 | 5118 2000 5718 "1" "1" "square"] |
||
2517 | Pad[3543 -393 |
||
2518 | 3543 393 |
||
2519 | 5118 2000 5718 "2" "2" "square"] |
||
2520 | |||
2521 | |||
2522 | ElementLine[-393 -2755 393 -2755 800] |
||
2523 | ElementLine[-393 2755 393 2755 800] |
||
2524 | |||
2525 | |||
2526 | # |
||
2527 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2528 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2529 | # again, it is most useful during parts placement. It really is time for some |
||
2530 | # additional non-fab layers... |
||
2531 | |||
2532 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2533 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2534 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2535 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2536 | |||
92 | jelle | 2537 | ) |
347 | jelle | 2538 | # grab the input values and convert to 1/100 mil |
2539 | |||
2540 | |||
2541 | |||
2542 | |||
2543 | |||
2544 | |||
2545 | |||
2546 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2547 | |||
2548 | # clearance from planes [1/100 mil] |
||
2549 | |||
2550 | # silk screen width [1/100 mil] |
||
2551 | |||
2552 | # courtyard silk screen width [1/100 mil] |
||
2553 | |||
2554 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2555 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2556 | Element[0x00000000 "0805" "C422" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2557 | ( |
347 | jelle | 2558 | # |
2559 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2560 | Pad[-3543 -393 |
||
2561 | -3543 393 |
||
2562 | 5118 2000 5718 "1" "1" "square"] |
||
2563 | Pad[3543 -393 |
||
2564 | 3543 393 |
||
2565 | 5118 2000 5718 "2" "2" "square"] |
||
2566 | |||
2567 | |||
2568 | ElementLine[-393 -2755 393 -2755 800] |
||
2569 | ElementLine[-393 2755 393 2755 800] |
||
2570 | |||
2571 | |||
2572 | # |
||
2573 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2574 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2575 | # again, it is most useful during parts placement. It really is time for some |
||
2576 | # additional non-fab layers... |
||
2577 | |||
2578 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2579 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2580 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2581 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2582 | |||
92 | jelle | 2583 | ) |
347 | jelle | 2584 | # grab the input values and convert to 1/100 mil |
2585 | |||
2586 | |||
2587 | |||
2588 | |||
2589 | |||
2590 | |||
2591 | |||
2592 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2593 | |||
2594 | # clearance from planes [1/100 mil] |
||
2595 | |||
2596 | # silk screen width [1/100 mil] |
||
2597 | |||
2598 | # courtyard silk screen width [1/100 mil] |
||
2599 | |||
2600 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2601 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2602 | Element[0x00000000 "0805" "C421" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2603 | ( |
347 | jelle | 2604 | # |
2605 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2606 | Pad[-3543 -393 |
||
2607 | -3543 393 |
||
2608 | 5118 2000 5718 "1" "1" "square"] |
||
2609 | Pad[3543 -393 |
||
2610 | 3543 393 |
||
2611 | 5118 2000 5718 "2" "2" "square"] |
||
2612 | |||
2613 | |||
2614 | ElementLine[-393 -2755 393 -2755 800] |
||
2615 | ElementLine[-393 2755 393 2755 800] |
||
2616 | |||
2617 | |||
2618 | # |
||
2619 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2620 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2621 | # again, it is most useful during parts placement. It really is time for some |
||
2622 | # additional non-fab layers... |
||
2623 | |||
2624 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2625 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2626 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2627 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2628 | |||
92 | jelle | 2629 | ) |
347 | jelle | 2630 | # grab the input values and convert to 1/100 mil |
2631 | |||
2632 | |||
2633 | |||
2634 | |||
2635 | |||
2636 | |||
2637 | |||
2638 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2639 | |||
2640 | # clearance from planes [1/100 mil] |
||
2641 | |||
2642 | # silk screen width [1/100 mil] |
||
2643 | |||
2644 | # courtyard silk screen width [1/100 mil] |
||
2645 | |||
2646 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2647 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2648 | Element[0x00000000 "0805" "C420" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2649 | ( |
347 | jelle | 2650 | # |
2651 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2652 | Pad[-3543 -393 |
||
2653 | -3543 393 |
||
2654 | 5118 2000 5718 "1" "1" "square"] |
||
2655 | Pad[3543 -393 |
||
2656 | 3543 393 |
||
2657 | 5118 2000 5718 "2" "2" "square"] |
||
2658 | |||
2659 | |||
2660 | ElementLine[-393 -2755 393 -2755 800] |
||
2661 | ElementLine[-393 2755 393 2755 800] |
||
2662 | |||
2663 | |||
2664 | # |
||
2665 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2666 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2667 | # again, it is most useful during parts placement. It really is time for some |
||
2668 | # additional non-fab layers... |
||
2669 | |||
2670 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2671 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2672 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2673 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2674 | |||
92 | jelle | 2675 | ) |
347 | jelle | 2676 | # grab the input values and convert to 1/100 mil |
2677 | |||
2678 | |||
2679 | |||
2680 | |||
2681 | |||
2682 | |||
2683 | |||
2684 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2685 | |||
2686 | # clearance from planes [1/100 mil] |
||
2687 | |||
2688 | # silk screen width [1/100 mil] |
||
2689 | |||
2690 | # courtyard silk screen width [1/100 mil] |
||
2691 | |||
2692 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2693 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2694 | Element[0x00000000 "0805" "C904" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2695 | ( |
347 | jelle | 2696 | # |
2697 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2698 | Pad[-3543 -393 |
||
2699 | -3543 393 |
||
2700 | 5118 2000 5718 "1" "1" "square"] |
||
2701 | Pad[3543 -393 |
||
2702 | 3543 393 |
||
2703 | 5118 2000 5718 "2" "2" "square"] |
||
2704 | |||
2705 | |||
2706 | ElementLine[-393 -2755 393 -2755 800] |
||
2707 | ElementLine[-393 2755 393 2755 800] |
||
2708 | |||
2709 | |||
2710 | # |
||
2711 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2712 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2713 | # again, it is most useful during parts placement. It really is time for some |
||
2714 | # additional non-fab layers... |
||
2715 | |||
2716 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2717 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2718 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2719 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2720 | |||
92 | jelle | 2721 | ) |
347 | jelle | 2722 | # grab the input values and convert to 1/100 mil |
2723 | |||
2724 | |||
2725 | |||
2726 | |||
2727 | |||
2728 | |||
2729 | |||
2730 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2731 | |||
2732 | # clearance from planes [1/100 mil] |
||
2733 | |||
2734 | # silk screen width [1/100 mil] |
||
2735 | |||
2736 | # courtyard silk screen width [1/100 mil] |
||
2737 | |||
2738 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2739 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2740 | Element[0x00000000 "0805" "C901" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2741 | ( |
347 | jelle | 2742 | # |
2743 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2744 | Pad[-3543 -393 |
||
2745 | -3543 393 |
||
2746 | 5118 2000 5718 "1" "1" "square"] |
||
2747 | Pad[3543 -393 |
||
2748 | 3543 393 |
||
2749 | 5118 2000 5718 "2" "2" "square"] |
||
2750 | |||
2751 | |||
2752 | ElementLine[-393 -2755 393 -2755 800] |
||
2753 | ElementLine[-393 2755 393 2755 800] |
||
2754 | |||
2755 | |||
2756 | # |
||
2757 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2758 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2759 | # again, it is most useful during parts placement. It really is time for some |
||
2760 | # additional non-fab layers... |
||
2761 | |||
2762 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2763 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2764 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2765 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2766 | |||
92 | jelle | 2767 | ) |
347 | jelle | 2768 | # grab the input values and convert to 1/100 mil |
2769 | |||
2770 | |||
2771 | |||
2772 | |||
2773 | |||
2774 | |||
2775 | |||
2776 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2777 | |||
2778 | # clearance from planes [1/100 mil] |
||
2779 | |||
2780 | # silk screen width [1/100 mil] |
||
2781 | |||
2782 | # courtyard silk screen width [1/100 mil] |
||
2783 | |||
2784 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2785 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2786 | Element[0x00000000 "0805" "C909" "3900pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2787 | ( |
347 | jelle | 2788 | # |
2789 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2790 | Pad[-3543 -393 |
||
2791 | -3543 393 |
||
2792 | 5118 2000 5718 "1" "1" "square"] |
||
2793 | Pad[3543 -393 |
||
2794 | 3543 393 |
||
2795 | 5118 2000 5718 "2" "2" "square"] |
||
2796 | |||
2797 | |||
2798 | ElementLine[-393 -2755 393 -2755 800] |
||
2799 | ElementLine[-393 2755 393 2755 800] |
||
2800 | |||
2801 | |||
2802 | # |
||
2803 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2804 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2805 | # again, it is most useful during parts placement. It really is time for some |
||
2806 | # additional non-fab layers... |
||
2807 | |||
2808 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2809 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2810 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2811 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2812 | |||
92 | jelle | 2813 | ) |
347 | jelle | 2814 | # grab the input values and convert to 1/100 mil |
2815 | |||
2816 | |||
2817 | |||
2818 | |||
2819 | |||
2820 | |||
2821 | |||
2822 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2823 | |||
2824 | # clearance from planes [1/100 mil] |
||
2825 | |||
2826 | # silk screen width [1/100 mil] |
||
2827 | |||
2828 | # courtyard silk screen width [1/100 mil] |
||
2829 | |||
2830 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2831 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2832 | Element[0x00000000 "0805" "C301" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2833 | ( |
347 | jelle | 2834 | # |
2835 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2836 | Pad[-3543 -393 |
||
2837 | -3543 393 |
||
2838 | 5118 2000 5718 "1" "1" "square"] |
||
2839 | Pad[3543 -393 |
||
2840 | 3543 393 |
||
2841 | 5118 2000 5718 "2" "2" "square"] |
||
2842 | |||
2843 | |||
2844 | ElementLine[-393 -2755 393 -2755 800] |
||
2845 | ElementLine[-393 2755 393 2755 800] |
||
2846 | |||
2847 | |||
2848 | # |
||
2849 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2850 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2851 | # again, it is most useful during parts placement. It really is time for some |
||
2852 | # additional non-fab layers... |
||
2853 | |||
2854 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2855 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2856 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2857 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2858 | |||
92 | jelle | 2859 | ) |
347 | jelle | 2860 | # grab the input values and convert to 1/100 mil |
2861 | |||
2862 | |||
2863 | |||
2864 | |||
2865 | |||
2866 | |||
2867 | |||
2868 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2869 | |||
2870 | # clearance from planes [1/100 mil] |
||
2871 | |||
2872 | # silk screen width [1/100 mil] |
||
2873 | |||
2874 | # courtyard silk screen width [1/100 mil] |
||
2875 | |||
2876 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2877 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2878 | Element[0x00000000 "0805" "C903" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2879 | ( |
347 | jelle | 2880 | # |
2881 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2882 | Pad[-3543 -393 |
||
2883 | -3543 393 |
||
2884 | 5118 2000 5718 "1" "1" "square"] |
||
2885 | Pad[3543 -393 |
||
2886 | 3543 393 |
||
2887 | 5118 2000 5718 "2" "2" "square"] |
||
2888 | |||
2889 | |||
2890 | ElementLine[-393 -2755 393 -2755 800] |
||
2891 | ElementLine[-393 2755 393 2755 800] |
||
2892 | |||
2893 | |||
2894 | # |
||
2895 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2896 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2897 | # again, it is most useful during parts placement. It really is time for some |
||
2898 | # additional non-fab layers... |
||
2899 | |||
2900 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2901 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2902 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2903 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2904 | |||
92 | jelle | 2905 | ) |
347 | jelle | 2906 | # grab the input values and convert to 1/100 mil |
2907 | |||
2908 | |||
2909 | |||
2910 | |||
2911 | |||
2912 | |||
2913 | |||
2914 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2915 | |||
2916 | # clearance from planes [1/100 mil] |
||
2917 | |||
2918 | # silk screen width [1/100 mil] |
||
2919 | |||
2920 | # courtyard silk screen width [1/100 mil] |
||
2921 | |||
2922 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2923 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2924 | Element[0x00000000 "0805" "C902" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2925 | ( |
347 | jelle | 2926 | # |
2927 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2928 | Pad[-3543 -393 |
||
2929 | -3543 393 |
||
2930 | 5118 2000 5718 "1" "1" "square"] |
||
2931 | Pad[3543 -393 |
||
2932 | 3543 393 |
||
2933 | 5118 2000 5718 "2" "2" "square"] |
||
2934 | |||
2935 | |||
2936 | ElementLine[-393 -2755 393 -2755 800] |
||
2937 | ElementLine[-393 2755 393 2755 800] |
||
2938 | |||
2939 | |||
2940 | # |
||
2941 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2942 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2943 | # again, it is most useful during parts placement. It really is time for some |
||
2944 | # additional non-fab layers... |
||
2945 | |||
2946 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2947 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2948 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2949 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2950 | |||
92 | jelle | 2951 | ) |
347 | jelle | 2952 | # grab the input values and convert to 1/100 mil |
2953 | |||
2954 | |||
2955 | |||
2956 | |||
2957 | |||
2958 | |||
2959 | |||
2960 | # how much to grow the pads by for soldermask [1/100 mil] |
||
2961 | |||
2962 | # clearance from planes [1/100 mil] |
||
2963 | |||
2964 | # silk screen width [1/100 mil] |
||
2965 | |||
2966 | # courtyard silk screen width [1/100 mil] |
||
2967 | |||
2968 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
2969 | # text_x, text_y, text_direction, text_scale, text_flags |
||
2970 | Element[0x00000000 "0805" "D702" "unknown" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 2971 | ( |
347 | jelle | 2972 | # |
2973 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
2974 | Pad[-3543 -393 |
||
2975 | -3543 393 |
||
2976 | 5118 2000 5718 "1" "1" "square"] |
||
2977 | Pad[3543 -393 |
||
2978 | 3543 393 |
||
2979 | 5118 2000 5718 "2" "2" "square"] |
||
2980 | |||
2981 | |||
2982 | ElementLine[-393 -2755 393 -2755 800] |
||
2983 | ElementLine[-393 2755 393 2755 800] |
||
2984 | |||
2985 | |||
2986 | # |
||
2987 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
2988 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
2989 | # again, it is most useful during parts placement. It really is time for some |
||
2990 | # additional non-fab layers... |
||
2991 | |||
2992 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2993 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2994 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
2995 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
2996 | |||
92 | jelle | 2997 | ) |
347 | jelle | 2998 | # grab the input values and convert to 1/100 mil |
2999 | |||
3000 | |||
3001 | |||
3002 | |||
3003 | |||
3004 | |||
3005 | |||
3006 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3007 | |||
3008 | # clearance from planes [1/100 mil] |
||
3009 | |||
3010 | # silk screen width [1/100 mil] |
||
3011 | |||
3012 | # courtyard silk screen width [1/100 mil] |
||
3013 | |||
3014 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3015 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3016 | Element[0x00000000 "0805" "D701" "unknown" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3017 | ( |
347 | jelle | 3018 | # |
3019 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3020 | Pad[-3543 -393 |
||
3021 | -3543 393 |
||
3022 | 5118 2000 5718 "1" "1" "square"] |
||
3023 | Pad[3543 -393 |
||
3024 | 3543 393 |
||
3025 | 5118 2000 5718 "2" "2" "square"] |
||
3026 | |||
3027 | |||
3028 | ElementLine[-393 -2755 393 -2755 800] |
||
3029 | ElementLine[-393 2755 393 2755 800] |
||
3030 | |||
3031 | |||
3032 | # |
||
3033 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3034 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3035 | # again, it is most useful during parts placement. It really is time for some |
||
3036 | # additional non-fab layers... |
||
3037 | |||
3038 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3039 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3040 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3041 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3042 | |||
92 | jelle | 3043 | ) |
347 | jelle | 3044 | # grab the input values and convert to 1/100 mil |
3045 | |||
3046 | |||
3047 | |||
3048 | |||
3049 | |||
3050 | |||
3051 | |||
3052 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3053 | |||
3054 | # clearance from planes [1/100 mil] |
||
3055 | |||
3056 | # silk screen width [1/100 mil] |
||
3057 | |||
3058 | # courtyard silk screen width [1/100 mil] |
||
3059 | |||
3060 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3061 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3062 | Element[0x00000000 "0805" "R502" "10k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3063 | ( |
347 | jelle | 3064 | # |
3065 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3066 | Pad[-3543 -393 |
||
3067 | -3543 393 |
||
3068 | 5118 2000 5718 "1" "1" "square"] |
||
3069 | Pad[3543 -393 |
||
3070 | 3543 393 |
||
3071 | 5118 2000 5718 "2" "2" "square"] |
||
3072 | |||
3073 | |||
3074 | ElementLine[-393 -2755 393 -2755 800] |
||
3075 | ElementLine[-393 2755 393 2755 800] |
||
3076 | |||
3077 | |||
3078 | # |
||
3079 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3080 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3081 | # again, it is most useful during parts placement. It really is time for some |
||
3082 | # additional non-fab layers... |
||
3083 | |||
3084 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3085 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3086 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3087 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3088 | |||
92 | jelle | 3089 | ) |
347 | jelle | 3090 | # grab the input values and convert to 1/100 mil |
3091 | |||
3092 | |||
3093 | |||
3094 | |||
3095 | |||
3096 | |||
3097 | |||
3098 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3099 | |||
3100 | # clearance from planes [1/100 mil] |
||
3101 | |||
3102 | # silk screen width [1/100 mil] |
||
3103 | |||
3104 | # courtyard silk screen width [1/100 mil] |
||
3105 | |||
3106 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3107 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3108 | Element[0x00000000 "0805" "R501" "10k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3109 | ( |
347 | jelle | 3110 | # |
3111 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3112 | Pad[-3543 -393 |
||
3113 | -3543 393 |
||
3114 | 5118 2000 5718 "1" "1" "square"] |
||
3115 | Pad[3543 -393 |
||
3116 | 3543 393 |
||
3117 | 5118 2000 5718 "2" "2" "square"] |
||
3118 | |||
3119 | |||
3120 | ElementLine[-393 -2755 393 -2755 800] |
||
3121 | ElementLine[-393 2755 393 2755 800] |
||
3122 | |||
3123 | |||
3124 | # |
||
3125 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3126 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3127 | # again, it is most useful during parts placement. It really is time for some |
||
3128 | # additional non-fab layers... |
||
3129 | |||
3130 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3131 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3132 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3133 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3134 | |||
92 | jelle | 3135 | ) |
347 | jelle | 3136 | # grab the input values and convert to 1/100 mil |
3137 | |||
3138 | |||
3139 | |||
3140 | |||
3141 | |||
3142 | |||
3143 | |||
3144 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3145 | |||
3146 | # clearance from planes [1/100 mil] |
||
3147 | |||
3148 | # silk screen width [1/100 mil] |
||
3149 | |||
3150 | # courtyard silk screen width [1/100 mil] |
||
3151 | |||
3152 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3153 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3154 | Element[0x00000000 "0805" "C907" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3155 | ( |
347 | jelle | 3156 | # |
3157 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3158 | Pad[-3543 -393 |
||
3159 | -3543 393 |
||
3160 | 5118 2000 5718 "1" "1" "square"] |
||
3161 | Pad[3543 -393 |
||
3162 | 3543 393 |
||
3163 | 5118 2000 5718 "2" "2" "square"] |
||
3164 | |||
3165 | |||
3166 | ElementLine[-393 -2755 393 -2755 800] |
||
3167 | ElementLine[-393 2755 393 2755 800] |
||
3168 | |||
3169 | |||
3170 | # |
||
3171 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3172 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3173 | # again, it is most useful during parts placement. It really is time for some |
||
3174 | # additional non-fab layers... |
||
3175 | |||
3176 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3177 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3178 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3179 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3180 | |||
92 | jelle | 3181 | ) |
347 | jelle | 3182 | # grab the input values and convert to 1/100 mil |
3183 | |||
3184 | |||
3185 | |||
3186 | |||
3187 | |||
3188 | |||
3189 | |||
3190 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3191 | |||
3192 | # clearance from planes [1/100 mil] |
||
3193 | |||
3194 | # silk screen width [1/100 mil] |
||
3195 | |||
3196 | # courtyard silk screen width [1/100 mil] |
||
3197 | |||
3198 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3199 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3200 | Element[0x00000000 "0805" "C906" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3201 | ( |
347 | jelle | 3202 | # |
3203 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3204 | Pad[-3543 -393 |
||
3205 | -3543 393 |
||
3206 | 5118 2000 5718 "1" "1" "square"] |
||
3207 | Pad[3543 -393 |
||
3208 | 3543 393 |
||
3209 | 5118 2000 5718 "2" "2" "square"] |
||
3210 | |||
3211 | |||
3212 | ElementLine[-393 -2755 393 -2755 800] |
||
3213 | ElementLine[-393 2755 393 2755 800] |
||
3214 | |||
3215 | |||
3216 | # |
||
3217 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3218 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3219 | # again, it is most useful during parts placement. It really is time for some |
||
3220 | # additional non-fab layers... |
||
3221 | |||
3222 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3223 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3224 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3225 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3226 | |||
92 | jelle | 3227 | ) |
347 | jelle | 3228 | # grab the input values and convert to 1/100 mil |
3229 | |||
3230 | |||
3231 | |||
3232 | |||
3233 | |||
3234 | |||
3235 | |||
3236 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3237 | |||
3238 | # clearance from planes [1/100 mil] |
||
3239 | |||
3240 | # silk screen width [1/100 mil] |
||
3241 | |||
3242 | # courtyard silk screen width [1/100 mil] |
||
3243 | |||
3244 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3245 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3246 | Element[0x00000000 "0805" "C905" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3247 | ( |
347 | jelle | 3248 | # |
3249 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3250 | Pad[-3543 -393 |
||
3251 | -3543 393 |
||
3252 | 5118 2000 5718 "1" "1" "square"] |
||
3253 | Pad[3543 -393 |
||
3254 | 3543 393 |
||
3255 | 5118 2000 5718 "2" "2" "square"] |
||
3256 | |||
3257 | |||
3258 | ElementLine[-393 -2755 393 -2755 800] |
||
3259 | ElementLine[-393 2755 393 2755 800] |
||
3260 | |||
3261 | |||
3262 | # |
||
3263 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3264 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3265 | # again, it is most useful during parts placement. It really is time for some |
||
3266 | # additional non-fab layers... |
||
3267 | |||
3268 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3269 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3270 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3271 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3272 | |||
92 | jelle | 3273 | ) |
347 | jelle | 3274 | # grab the input values and convert to 1/100 mil |
3275 | |||
3276 | |||
3277 | |||
3278 | |||
3279 | |||
3280 | |||
3281 | |||
3282 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3283 | |||
3284 | # clearance from planes [1/100 mil] |
||
3285 | |||
3286 | # silk screen width [1/100 mil] |
||
3287 | |||
3288 | # courtyard silk screen width [1/100 mil] |
||
3289 | |||
3290 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3291 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3292 | Element[0x00000000 "0805" "C419" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3293 | ( |
347 | jelle | 3294 | # |
3295 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3296 | Pad[-3543 -393 |
||
3297 | -3543 393 |
||
3298 | 5118 2000 5718 "1" "1" "square"] |
||
3299 | Pad[3543 -393 |
||
3300 | 3543 393 |
||
3301 | 5118 2000 5718 "2" "2" "square"] |
||
3302 | |||
3303 | |||
3304 | ElementLine[-393 -2755 393 -2755 800] |
||
3305 | ElementLine[-393 2755 393 2755 800] |
||
3306 | |||
3307 | |||
3308 | # |
||
3309 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3310 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3311 | # again, it is most useful during parts placement. It really is time for some |
||
3312 | # additional non-fab layers... |
||
3313 | |||
3314 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3315 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3316 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3317 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3318 | |||
92 | jelle | 3319 | ) |
347 | jelle | 3320 | # grab the input values and convert to 1/100 mil |
3321 | |||
3322 | |||
3323 | |||
3324 | |||
3325 | |||
3326 | |||
3327 | |||
3328 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3329 | |||
3330 | # clearance from planes [1/100 mil] |
||
3331 | |||
3332 | # silk screen width [1/100 mil] |
||
3333 | |||
3334 | # courtyard silk screen width [1/100 mil] |
||
3335 | |||
3336 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3337 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3338 | Element[0x00000000 "0805" "C418" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3339 | ( |
347 | jelle | 3340 | # |
3341 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3342 | Pad[-3543 -393 |
||
3343 | -3543 393 |
||
3344 | 5118 2000 5718 "1" "1" "square"] |
||
3345 | Pad[3543 -393 |
||
3346 | 3543 393 |
||
3347 | 5118 2000 5718 "2" "2" "square"] |
||
3348 | |||
3349 | |||
3350 | ElementLine[-393 -2755 393 -2755 800] |
||
3351 | ElementLine[-393 2755 393 2755 800] |
||
3352 | |||
3353 | |||
3354 | # |
||
3355 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3356 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3357 | # again, it is most useful during parts placement. It really is time for some |
||
3358 | # additional non-fab layers... |
||
3359 | |||
3360 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3361 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3362 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3363 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3364 | |||
92 | jelle | 3365 | ) |
347 | jelle | 3366 | # grab the input values and convert to 1/100 mil |
3367 | |||
3368 | |||
3369 | |||
3370 | |||
3371 | |||
3372 | |||
3373 | |||
3374 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3375 | |||
3376 | # clearance from planes [1/100 mil] |
||
3377 | |||
3378 | # silk screen width [1/100 mil] |
||
3379 | |||
3380 | # courtyard silk screen width [1/100 mil] |
||
3381 | |||
3382 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3383 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3384 | Element[0x00000000 "0805" "C417" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3385 | ( |
347 | jelle | 3386 | # |
3387 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3388 | Pad[-3543 -393 |
||
3389 | -3543 393 |
||
3390 | 5118 2000 5718 "1" "1" "square"] |
||
3391 | Pad[3543 -393 |
||
3392 | 3543 393 |
||
3393 | 5118 2000 5718 "2" "2" "square"] |
||
3394 | |||
3395 | |||
3396 | ElementLine[-393 -2755 393 -2755 800] |
||
3397 | ElementLine[-393 2755 393 2755 800] |
||
3398 | |||
3399 | |||
3400 | # |
||
3401 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3402 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3403 | # again, it is most useful during parts placement. It really is time for some |
||
3404 | # additional non-fab layers... |
||
3405 | |||
3406 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3407 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3408 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3409 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3410 | |||
92 | jelle | 3411 | ) |
347 | jelle | 3412 | # grab the input values and convert to 1/100 mil |
3413 | |||
3414 | |||
3415 | |||
3416 | |||
3417 | |||
3418 | |||
3419 | |||
3420 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3421 | |||
3422 | # clearance from planes [1/100 mil] |
||
3423 | |||
3424 | # silk screen width [1/100 mil] |
||
3425 | |||
3426 | # courtyard silk screen width [1/100 mil] |
||
3427 | |||
3428 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3429 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3430 | Element[0x00000000 "0805" "C416" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3431 | ( |
347 | jelle | 3432 | # |
3433 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3434 | Pad[-3543 -393 |
||
3435 | -3543 393 |
||
3436 | 5118 2000 5718 "1" "1" "square"] |
||
3437 | Pad[3543 -393 |
||
3438 | 3543 393 |
||
3439 | 5118 2000 5718 "2" "2" "square"] |
||
3440 | |||
3441 | |||
3442 | ElementLine[-393 -2755 393 -2755 800] |
||
3443 | ElementLine[-393 2755 393 2755 800] |
||
3444 | |||
3445 | |||
3446 | # |
||
3447 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3448 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3449 | # again, it is most useful during parts placement. It really is time for some |
||
3450 | # additional non-fab layers... |
||
3451 | |||
3452 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3453 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3454 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3455 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3456 | |||
92 | jelle | 3457 | ) |
347 | jelle | 3458 | # grab the input values and convert to 1/100 mil |
3459 | |||
3460 | |||
3461 | |||
3462 | |||
3463 | |||
3464 | |||
3465 | |||
3466 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3467 | |||
3468 | # clearance from planes [1/100 mil] |
||
3469 | |||
3470 | # silk screen width [1/100 mil] |
||
3471 | |||
3472 | # courtyard silk screen width [1/100 mil] |
||
3473 | |||
3474 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3475 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3476 | Element[0x00000000 "0805" "C415" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3477 | ( |
347 | jelle | 3478 | # |
3479 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3480 | Pad[-3543 -393 |
||
3481 | -3543 393 |
||
3482 | 5118 2000 5718 "1" "1" "square"] |
||
3483 | Pad[3543 -393 |
||
3484 | 3543 393 |
||
3485 | 5118 2000 5718 "2" "2" "square"] |
||
3486 | |||
3487 | |||
3488 | ElementLine[-393 -2755 393 -2755 800] |
||
3489 | ElementLine[-393 2755 393 2755 800] |
||
3490 | |||
3491 | |||
3492 | # |
||
3493 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3494 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3495 | # again, it is most useful during parts placement. It really is time for some |
||
3496 | # additional non-fab layers... |
||
3497 | |||
3498 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3499 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3500 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3501 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3502 | |||
92 | jelle | 3503 | ) |
347 | jelle | 3504 | # grab the input values and convert to 1/100 mil |
3505 | |||
3506 | |||
3507 | |||
3508 | |||
3509 | |||
3510 | |||
3511 | |||
3512 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3513 | |||
3514 | # clearance from planes [1/100 mil] |
||
3515 | |||
3516 | # silk screen width [1/100 mil] |
||
3517 | |||
3518 | # courtyard silk screen width [1/100 mil] |
||
3519 | |||
3520 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3521 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3522 | Element[0x00000000 "0805" "C414" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3523 | ( |
347 | jelle | 3524 | # |
3525 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3526 | Pad[-3543 -393 |
||
3527 | -3543 393 |
||
3528 | 5118 2000 5718 "1" "1" "square"] |
||
3529 | Pad[3543 -393 |
||
3530 | 3543 393 |
||
3531 | 5118 2000 5718 "2" "2" "square"] |
||
3532 | |||
3533 | |||
3534 | ElementLine[-393 -2755 393 -2755 800] |
||
3535 | ElementLine[-393 2755 393 2755 800] |
||
3536 | |||
3537 | |||
3538 | # |
||
3539 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3540 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3541 | # again, it is most useful during parts placement. It really is time for some |
||
3542 | # additional non-fab layers... |
||
3543 | |||
3544 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3545 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3546 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3547 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3548 | |||
92 | jelle | 3549 | ) |
347 | jelle | 3550 | # grab the input values and convert to 1/100 mil |
3551 | |||
3552 | |||
3553 | |||
3554 | |||
3555 | |||
3556 | |||
3557 | |||
3558 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3559 | |||
3560 | # clearance from planes [1/100 mil] |
||
3561 | |||
3562 | # silk screen width [1/100 mil] |
||
3563 | |||
3564 | # courtyard silk screen width [1/100 mil] |
||
3565 | |||
3566 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3567 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3568 | Element[0x00000000 "0805" "C413" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3569 | ( |
347 | jelle | 3570 | # |
3571 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3572 | Pad[-3543 -393 |
||
3573 | -3543 393 |
||
3574 | 5118 2000 5718 "1" "1" "square"] |
||
3575 | Pad[3543 -393 |
||
3576 | 3543 393 |
||
3577 | 5118 2000 5718 "2" "2" "square"] |
||
3578 | |||
3579 | |||
3580 | ElementLine[-393 -2755 393 -2755 800] |
||
3581 | ElementLine[-393 2755 393 2755 800] |
||
3582 | |||
3583 | |||
3584 | # |
||
3585 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3586 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3587 | # again, it is most useful during parts placement. It really is time for some |
||
3588 | # additional non-fab layers... |
||
3589 | |||
3590 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3591 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3592 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3593 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3594 | |||
92 | jelle | 3595 | ) |
347 | jelle | 3596 | # grab the input values and convert to 1/100 mil |
3597 | |||
3598 | |||
3599 | |||
3600 | |||
3601 | |||
3602 | |||
3603 | |||
3604 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3605 | |||
3606 | # clearance from planes [1/100 mil] |
||
3607 | |||
3608 | # silk screen width [1/100 mil] |
||
3609 | |||
3610 | # courtyard silk screen width [1/100 mil] |
||
3611 | |||
3612 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3613 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3614 | Element[0x00000000 "0805" "C412" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3615 | ( |
347 | jelle | 3616 | # |
3617 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3618 | Pad[-3543 -393 |
||
3619 | -3543 393 |
||
3620 | 5118 2000 5718 "1" "1" "square"] |
||
3621 | Pad[3543 -393 |
||
3622 | 3543 393 |
||
3623 | 5118 2000 5718 "2" "2" "square"] |
||
3624 | |||
3625 | |||
3626 | ElementLine[-393 -2755 393 -2755 800] |
||
3627 | ElementLine[-393 2755 393 2755 800] |
||
3628 | |||
3629 | |||
3630 | # |
||
3631 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3632 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3633 | # again, it is most useful during parts placement. It really is time for some |
||
3634 | # additional non-fab layers... |
||
3635 | |||
3636 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3637 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3638 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3639 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3640 | |||
92 | jelle | 3641 | ) |
347 | jelle | 3642 | # grab the input values and convert to 1/100 mil |
3643 | |||
3644 | |||
3645 | |||
3646 | |||
3647 | |||
3648 | |||
3649 | |||
3650 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3651 | |||
3652 | # clearance from planes [1/100 mil] |
||
3653 | |||
3654 | # silk screen width [1/100 mil] |
||
3655 | |||
3656 | # courtyard silk screen width [1/100 mil] |
||
3657 | |||
3658 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3659 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3660 | Element[0x00000000 "0805" "C411" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3661 | ( |
347 | jelle | 3662 | # |
3663 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3664 | Pad[-3543 -393 |
||
3665 | -3543 393 |
||
3666 | 5118 2000 5718 "1" "1" "square"] |
||
3667 | Pad[3543 -393 |
||
3668 | 3543 393 |
||
3669 | 5118 2000 5718 "2" "2" "square"] |
||
3670 | |||
3671 | |||
3672 | ElementLine[-393 -2755 393 -2755 800] |
||
3673 | ElementLine[-393 2755 393 2755 800] |
||
3674 | |||
3675 | |||
3676 | # |
||
3677 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3678 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3679 | # again, it is most useful during parts placement. It really is time for some |
||
3680 | # additional non-fab layers... |
||
3681 | |||
3682 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3683 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3684 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3685 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3686 | |||
92 | jelle | 3687 | ) |
347 | jelle | 3688 | # grab the input values and convert to 1/100 mil |
3689 | |||
3690 | |||
3691 | |||
3692 | |||
3693 | |||
3694 | |||
3695 | |||
3696 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3697 | |||
3698 | # clearance from planes [1/100 mil] |
||
3699 | |||
3700 | # silk screen width [1/100 mil] |
||
3701 | |||
3702 | # courtyard silk screen width [1/100 mil] |
||
3703 | |||
3704 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3705 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3706 | Element[0x00000000 "0805" "C410" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3707 | ( |
347 | jelle | 3708 | # |
3709 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3710 | Pad[-3543 -393 |
||
3711 | -3543 393 |
||
3712 | 5118 2000 5718 "1" "1" "square"] |
||
3713 | Pad[3543 -393 |
||
3714 | 3543 393 |
||
3715 | 5118 2000 5718 "2" "2" "square"] |
||
3716 | |||
3717 | |||
3718 | ElementLine[-393 -2755 393 -2755 800] |
||
3719 | ElementLine[-393 2755 393 2755 800] |
||
3720 | |||
3721 | |||
3722 | # |
||
3723 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3724 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3725 | # again, it is most useful during parts placement. It really is time for some |
||
3726 | # additional non-fab layers... |
||
3727 | |||
3728 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3729 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3730 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3731 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3732 | |||
92 | jelle | 3733 | ) |
347 | jelle | 3734 | # grab the input values and convert to 1/100 mil |
3735 | |||
3736 | |||
3737 | |||
3738 | |||
3739 | |||
3740 | |||
3741 | |||
3742 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3743 | |||
3744 | # clearance from planes [1/100 mil] |
||
3745 | |||
3746 | # silk screen width [1/100 mil] |
||
3747 | |||
3748 | # courtyard silk screen width [1/100 mil] |
||
3749 | |||
3750 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3751 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3752 | Element[0x00000000 "0805" "R1302" "330R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3753 | ( |
347 | jelle | 3754 | # |
3755 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3756 | Pad[-3543 -393 |
||
3757 | -3543 393 |
||
3758 | 5118 2000 5718 "1" "1" "square"] |
||
3759 | Pad[3543 -393 |
||
3760 | 3543 393 |
||
3761 | 5118 2000 5718 "2" "2" "square"] |
||
3762 | |||
3763 | |||
3764 | ElementLine[-393 -2755 393 -2755 800] |
||
3765 | ElementLine[-393 2755 393 2755 800] |
||
3766 | |||
3767 | |||
3768 | # |
||
3769 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3770 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3771 | # again, it is most useful during parts placement. It really is time for some |
||
3772 | # additional non-fab layers... |
||
3773 | |||
3774 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3775 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3776 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3777 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3778 | |||
92 | jelle | 3779 | ) |
347 | jelle | 3780 | # grab the input values and convert to 1/100 mil |
3781 | |||
3782 | |||
3783 | |||
3784 | |||
3785 | |||
3786 | |||
3787 | |||
3788 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3789 | |||
3790 | # clearance from planes [1/100 mil] |
||
3791 | |||
3792 | # silk screen width [1/100 mil] |
||
3793 | |||
3794 | # courtyard silk screen width [1/100 mil] |
||
3795 | |||
3796 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3797 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3798 | Element[0x00000000 "0805" "R1304" "120R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3799 | ( |
347 | jelle | 3800 | # |
3801 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3802 | Pad[-3543 -393 |
||
3803 | -3543 393 |
||
3804 | 5118 2000 5718 "1" "1" "square"] |
||
3805 | Pad[3543 -393 |
||
3806 | 3543 393 |
||
3807 | 5118 2000 5718 "2" "2" "square"] |
||
3808 | |||
3809 | |||
3810 | ElementLine[-393 -2755 393 -2755 800] |
||
3811 | ElementLine[-393 2755 393 2755 800] |
||
3812 | |||
3813 | |||
3814 | # |
||
3815 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3816 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3817 | # again, it is most useful during parts placement. It really is time for some |
||
3818 | # additional non-fab layers... |
||
3819 | |||
3820 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3821 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3822 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3823 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3824 | |||
92 | jelle | 3825 | ) |
347 | jelle | 3826 | |
3827 | |||
3828 | |||
3829 | |||
3830 | |||
3831 | Element(0x00 "HC49" "X1301" "20MHz" 100 170 0 100 0x00) |
||
92 | jelle | 3832 | ( |
347 | jelle | 3833 | Pin(100 100 60 28 "1" 0x101) |
3834 | Pin(300 100 60 28 "2" 0x01) |
||
3835 | ElementLine(100 50 300 50 10) |
||
3836 | ElementLine(100 150 300 150 10) |
||
3837 | ElementArc(100 100 50 50 270 180 10) |
||
3838 | ElementArc(300 100 50 50 90 180 10) |
||
3839 | Mark (100 100) |
||
92 | jelle | 3840 | ) |
347 | jelle | 3841 | # grab the input values and convert to 1/100 mil |
3842 | |||
3843 | |||
3844 | |||
3845 | |||
3846 | |||
3847 | |||
3848 | |||
3849 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3850 | |||
3851 | # clearance from planes [1/100 mil] |
||
3852 | |||
3853 | # silk screen width [1/100 mil] |
||
3854 | |||
3855 | # courtyard silk screen width [1/100 mil] |
||
3856 | |||
3857 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3858 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3859 | Element[0x00000000 "0805" "C409" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3860 | ( |
347 | jelle | 3861 | # |
3862 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3863 | Pad[-3543 -393 |
||
3864 | -3543 393 |
||
3865 | 5118 2000 5718 "1" "1" "square"] |
||
3866 | Pad[3543 -393 |
||
3867 | 3543 393 |
||
3868 | 5118 2000 5718 "2" "2" "square"] |
||
3869 | |||
3870 | |||
3871 | ElementLine[-393 -2755 393 -2755 800] |
||
3872 | ElementLine[-393 2755 393 2755 800] |
||
3873 | |||
3874 | |||
3875 | # |
||
3876 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3877 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3878 | # again, it is most useful during parts placement. It really is time for some |
||
3879 | # additional non-fab layers... |
||
3880 | |||
3881 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3882 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3883 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3884 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3885 | |||
92 | jelle | 3886 | ) |
347 | jelle | 3887 | # grab the input values and convert to 1/100 mil |
3888 | |||
3889 | |||
3890 | |||
3891 | |||
3892 | |||
3893 | |||
3894 | |||
3895 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3896 | |||
3897 | # clearance from planes [1/100 mil] |
||
3898 | |||
3899 | # silk screen width [1/100 mil] |
||
3900 | |||
3901 | # courtyard silk screen width [1/100 mil] |
||
3902 | |||
3903 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3904 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3905 | Element[0x00000000 "0805" "C408" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3906 | ( |
347 | jelle | 3907 | # |
3908 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3909 | Pad[-3543 -393 |
||
3910 | -3543 393 |
||
3911 | 5118 2000 5718 "1" "1" "square"] |
||
3912 | Pad[3543 -393 |
||
3913 | 3543 393 |
||
3914 | 5118 2000 5718 "2" "2" "square"] |
||
3915 | |||
3916 | |||
3917 | ElementLine[-393 -2755 393 -2755 800] |
||
3918 | ElementLine[-393 2755 393 2755 800] |
||
3919 | |||
3920 | |||
3921 | # |
||
3922 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3923 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3924 | # again, it is most useful during parts placement. It really is time for some |
||
3925 | # additional non-fab layers... |
||
3926 | |||
3927 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3928 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3929 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3930 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3931 | |||
92 | jelle | 3932 | ) |
347 | jelle | 3933 | # grab the input values and convert to 1/100 mil |
3934 | |||
3935 | |||
3936 | |||
3937 | |||
3938 | |||
3939 | |||
3940 | |||
3941 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3942 | |||
3943 | # clearance from planes [1/100 mil] |
||
3944 | |||
3945 | # silk screen width [1/100 mil] |
||
3946 | |||
3947 | # courtyard silk screen width [1/100 mil] |
||
3948 | |||
3949 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3950 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3951 | Element[0x00000000 "0805" "C407" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3952 | ( |
347 | jelle | 3953 | # |
3954 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
3955 | Pad[-3543 -393 |
||
3956 | -3543 393 |
||
3957 | 5118 2000 5718 "1" "1" "square"] |
||
3958 | Pad[3543 -393 |
||
3959 | 3543 393 |
||
3960 | 5118 2000 5718 "2" "2" "square"] |
||
3961 | |||
3962 | |||
3963 | ElementLine[-393 -2755 393 -2755 800] |
||
3964 | ElementLine[-393 2755 393 2755 800] |
||
3965 | |||
3966 | |||
3967 | # |
||
3968 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
3969 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
3970 | # again, it is most useful during parts placement. It really is time for some |
||
3971 | # additional non-fab layers... |
||
3972 | |||
3973 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3974 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3975 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
3976 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
3977 | |||
92 | jelle | 3978 | ) |
347 | jelle | 3979 | # grab the input values and convert to 1/100 mil |
3980 | |||
3981 | |||
3982 | |||
3983 | |||
3984 | |||
3985 | |||
3986 | |||
3987 | # how much to grow the pads by for soldermask [1/100 mil] |
||
3988 | |||
3989 | # clearance from planes [1/100 mil] |
||
3990 | |||
3991 | # silk screen width [1/100 mil] |
||
3992 | |||
3993 | # courtyard silk screen width [1/100 mil] |
||
3994 | |||
3995 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
3996 | # text_x, text_y, text_direction, text_scale, text_flags |
||
3997 | Element[0x00000000 "0805" "C406" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 3998 | ( |
347 | jelle | 3999 | # |
4000 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4001 | Pad[-3543 -393 |
||
4002 | -3543 393 |
||
4003 | 5118 2000 5718 "1" "1" "square"] |
||
4004 | Pad[3543 -393 |
||
4005 | 3543 393 |
||
4006 | 5118 2000 5718 "2" "2" "square"] |
||
4007 | |||
4008 | |||
4009 | ElementLine[-393 -2755 393 -2755 800] |
||
4010 | ElementLine[-393 2755 393 2755 800] |
||
4011 | |||
4012 | |||
4013 | # |
||
4014 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4015 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4016 | # again, it is most useful during parts placement. It really is time for some |
||
4017 | # additional non-fab layers... |
||
4018 | |||
4019 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4020 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4021 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4022 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4023 | |||
92 | jelle | 4024 | ) |
347 | jelle | 4025 | # grab the input values and convert to 1/100 mil |
4026 | |||
4027 | |||
4028 | |||
4029 | |||
4030 | |||
4031 | |||
4032 | |||
4033 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4034 | |||
4035 | # clearance from planes [1/100 mil] |
||
4036 | |||
4037 | # silk screen width [1/100 mil] |
||
4038 | |||
4039 | # courtyard silk screen width [1/100 mil] |
||
4040 | |||
4041 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4042 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4043 | Element[0x00000000 "0805" "C405" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4044 | ( |
347 | jelle | 4045 | # |
4046 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4047 | Pad[-3543 -393 |
||
4048 | -3543 393 |
||
4049 | 5118 2000 5718 "1" "1" "square"] |
||
4050 | Pad[3543 -393 |
||
4051 | 3543 393 |
||
4052 | 5118 2000 5718 "2" "2" "square"] |
||
4053 | |||
4054 | |||
4055 | ElementLine[-393 -2755 393 -2755 800] |
||
4056 | ElementLine[-393 2755 393 2755 800] |
||
4057 | |||
4058 | |||
4059 | # |
||
4060 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4061 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4062 | # again, it is most useful during parts placement. It really is time for some |
||
4063 | # additional non-fab layers... |
||
4064 | |||
4065 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4066 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4067 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4068 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4069 | |||
92 | jelle | 4070 | ) |
347 | jelle | 4071 | # grab the input values and convert to 1/100 mil |
4072 | |||
4073 | |||
4074 | |||
4075 | |||
4076 | |||
4077 | |||
4078 | |||
4079 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4080 | |||
4081 | # clearance from planes [1/100 mil] |
||
4082 | |||
4083 | # silk screen width [1/100 mil] |
||
4084 | |||
4085 | # courtyard silk screen width [1/100 mil] |
||
4086 | |||
4087 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4088 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4089 | Element[0x00000000 "0805" "C404" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4090 | ( |
347 | jelle | 4091 | # |
4092 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4093 | Pad[-3543 -393 |
||
4094 | -3543 393 |
||
4095 | 5118 2000 5718 "1" "1" "square"] |
||
4096 | Pad[3543 -393 |
||
4097 | 3543 393 |
||
4098 | 5118 2000 5718 "2" "2" "square"] |
||
4099 | |||
4100 | |||
4101 | ElementLine[-393 -2755 393 -2755 800] |
||
4102 | ElementLine[-393 2755 393 2755 800] |
||
4103 | |||
4104 | |||
4105 | # |
||
4106 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4107 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4108 | # again, it is most useful during parts placement. It really is time for some |
||
4109 | # additional non-fab layers... |
||
4110 | |||
4111 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4112 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4113 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4114 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4115 | |||
92 | jelle | 4116 | ) |
347 | jelle | 4117 | # grab the input values and convert to 1/100 mil |
4118 | |||
4119 | |||
4120 | |||
4121 | |||
4122 | |||
4123 | |||
4124 | |||
4125 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4126 | |||
4127 | # clearance from planes [1/100 mil] |
||
4128 | |||
4129 | # silk screen width [1/100 mil] |
||
4130 | |||
4131 | # courtyard silk screen width [1/100 mil] |
||
4132 | |||
4133 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4134 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4135 | Element[0x00000000 "0805" "C403" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4136 | ( |
347 | jelle | 4137 | # |
4138 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4139 | Pad[-3543 -393 |
||
4140 | -3543 393 |
||
4141 | 5118 2000 5718 "1" "1" "square"] |
||
4142 | Pad[3543 -393 |
||
4143 | 3543 393 |
||
4144 | 5118 2000 5718 "2" "2" "square"] |
||
4145 | |||
4146 | |||
4147 | ElementLine[-393 -2755 393 -2755 800] |
||
4148 | ElementLine[-393 2755 393 2755 800] |
||
4149 | |||
4150 | |||
4151 | # |
||
4152 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4153 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4154 | # again, it is most useful during parts placement. It really is time for some |
||
4155 | # additional non-fab layers... |
||
4156 | |||
4157 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4158 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4159 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4160 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4161 | |||
92 | jelle | 4162 | ) |
347 | jelle | 4163 | # grab the input values and convert to 1/100 mil |
4164 | |||
4165 | |||
4166 | |||
4167 | |||
4168 | |||
4169 | |||
4170 | |||
4171 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4172 | |||
4173 | # clearance from planes [1/100 mil] |
||
4174 | |||
4175 | # silk screen width [1/100 mil] |
||
4176 | |||
4177 | # courtyard silk screen width [1/100 mil] |
||
4178 | |||
4179 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4180 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4181 | Element[0x00000000 "0805" "C402" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4182 | ( |
347 | jelle | 4183 | # |
4184 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4185 | Pad[-3543 -393 |
||
4186 | -3543 393 |
||
4187 | 5118 2000 5718 "1" "1" "square"] |
||
4188 | Pad[3543 -393 |
||
4189 | 3543 393 |
||
4190 | 5118 2000 5718 "2" "2" "square"] |
||
4191 | |||
4192 | |||
4193 | ElementLine[-393 -2755 393 -2755 800] |
||
4194 | ElementLine[-393 2755 393 2755 800] |
||
4195 | |||
4196 | |||
4197 | # |
||
4198 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4199 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4200 | # again, it is most useful during parts placement. It really is time for some |
||
4201 | # additional non-fab layers... |
||
4202 | |||
4203 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4204 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4205 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4206 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4207 | |||
92 | jelle | 4208 | ) |
347 | jelle | 4209 | # grab the input values and convert to 1/100 mil |
4210 | |||
4211 | |||
4212 | |||
4213 | |||
4214 | |||
4215 | |||
4216 | |||
4217 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4218 | |||
4219 | # clearance from planes [1/100 mil] |
||
4220 | |||
4221 | # silk screen width [1/100 mil] |
||
4222 | |||
4223 | # courtyard silk screen width [1/100 mil] |
||
4224 | |||
4225 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4226 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4227 | Element[0x00000000 "0805" "C401" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4228 | ( |
347 | jelle | 4229 | # |
4230 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4231 | Pad[-3543 -393 |
||
4232 | -3543 393 |
||
4233 | 5118 2000 5718 "1" "1" "square"] |
||
4234 | Pad[3543 -393 |
||
4235 | 3543 393 |
||
4236 | 5118 2000 5718 "2" "2" "square"] |
||
4237 | |||
4238 | |||
4239 | ElementLine[-393 -2755 393 -2755 800] |
||
4240 | ElementLine[-393 2755 393 2755 800] |
||
4241 | |||
4242 | |||
4243 | # |
||
4244 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4245 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4246 | # again, it is most useful during parts placement. It really is time for some |
||
4247 | # additional non-fab layers... |
||
4248 | |||
4249 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4250 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4251 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4252 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4253 | |||
92 | jelle | 4254 | ) |
347 | jelle | 4255 | # grab the input values and convert to 1/100 mil |
4256 | |||
4257 | |||
4258 | |||
4259 | |||
4260 | |||
4261 | |||
4262 | |||
4263 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4264 | |||
4265 | # clearance from planes [1/100 mil] |
||
4266 | |||
4267 | # silk screen width [1/100 mil] |
||
4268 | |||
4269 | # courtyard silk screen width [1/100 mil] |
||
4270 | |||
4271 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4272 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4273 | Element[0x00000000 "0805" "R1303" "10k" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4274 | ( |
347 | jelle | 4275 | # |
4276 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4277 | Pad[-3543 -393 |
||
4278 | -3543 393 |
||
4279 | 5118 2000 5718 "1" "1" "square"] |
||
4280 | Pad[3543 -393 |
||
4281 | 3543 393 |
||
4282 | 5118 2000 5718 "2" "2" "square"] |
||
4283 | |||
4284 | |||
4285 | ElementLine[-393 -2755 393 -2755 800] |
||
4286 | ElementLine[-393 2755 393 2755 800] |
||
4287 | |||
4288 | |||
4289 | # |
||
4290 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4291 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4292 | # again, it is most useful during parts placement. It really is time for some |
||
4293 | # additional non-fab layers... |
||
4294 | |||
4295 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4296 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4297 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4298 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4299 | |||
92 | jelle | 4300 | ) |
347 | jelle | 4301 | # grab the input values and convert to 1/100 mil |
4302 | |||
4303 | |||
4304 | |||
4305 | |||
4306 | |||
4307 | |||
4308 | |||
4309 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4310 | |||
4311 | # clearance from planes [1/100 mil] |
||
4312 | |||
4313 | # silk screen width [1/100 mil] |
||
4314 | |||
4315 | # courtyard silk screen width [1/100 mil] |
||
4316 | |||
4317 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4318 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4319 | Element[0x00000000 "0805" "C1006" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4320 | ( |
347 | jelle | 4321 | # |
4322 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4323 | Pad[-3543 -393 |
||
4324 | -3543 393 |
||
4325 | 5118 2000 5718 "1" "1" "square"] |
||
4326 | Pad[3543 -393 |
||
4327 | 3543 393 |
||
4328 | 5118 2000 5718 "2" "2" "square"] |
||
4329 | |||
4330 | |||
4331 | ElementLine[-393 -2755 393 -2755 800] |
||
4332 | ElementLine[-393 2755 393 2755 800] |
||
4333 | |||
4334 | |||
4335 | # |
||
4336 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4337 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4338 | # again, it is most useful during parts placement. It really is time for some |
||
4339 | # additional non-fab layers... |
||
4340 | |||
4341 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4342 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4343 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4344 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4345 | |||
92 | jelle | 4346 | ) |
347 | jelle | 4347 | # grab the input values and convert to 1/100 mil |
4348 | |||
4349 | |||
4350 | |||
4351 | |||
4352 | |||
4353 | |||
4354 | |||
4355 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4356 | |||
4357 | # clearance from planes [1/100 mil] |
||
4358 | |||
4359 | # silk screen width [1/100 mil] |
||
4360 | |||
4361 | # courtyard silk screen width [1/100 mil] |
||
4362 | |||
4363 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4364 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4365 | Element[0x00000000 "0805" "C1003" "22pF" 0 0 -3150 -3150 0 100 ""] |
||
4366 | ( |
||
4367 | # |
||
4368 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4369 | Pad[-3543 -393 |
||
4370 | -3543 393 |
||
4371 | 5118 2000 5718 "1" "1" "square"] |
||
4372 | Pad[3543 -393 |
||
4373 | 3543 393 |
||
4374 | 5118 2000 5718 "2" "2" "square"] |
||
4375 | |||
92 | jelle | 4376 | |
347 | jelle | 4377 | ElementLine[-393 -2755 393 -2755 800] |
4378 | ElementLine[-393 2755 393 2755 800] |
||
4379 | |||
4380 | |||
4381 | # |
||
4382 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4383 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4384 | # again, it is most useful during parts placement. It really is time for some |
||
4385 | # additional non-fab layers... |
||
4386 | |||
4387 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4388 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4389 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4390 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4391 | |||
4392 | ) |
||
4393 | # grab the input values and convert to 1/100 mil |
||
4394 | |||
4395 | |||
4396 | |||
4397 | |||
4398 | |||
4399 | |||
4400 | |||
4401 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4402 | |||
4403 | # clearance from planes [1/100 mil] |
||
4404 | |||
4405 | # silk screen width [1/100 mil] |
||
4406 | |||
4407 | # courtyard silk screen width [1/100 mil] |
||
4408 | |||
4409 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4410 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4411 | Element[0x00000000 "0805" "C1002" "22pF" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4412 | ( |
347 | jelle | 4413 | # |
4414 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4415 | Pad[-3543 -393 |
||
4416 | -3543 393 |
||
4417 | 5118 2000 5718 "1" "1" "square"] |
||
4418 | Pad[3543 -393 |
||
4419 | 3543 393 |
||
4420 | 5118 2000 5718 "2" "2" "square"] |
||
4421 | |||
93 | jelle | 4422 | |
347 | jelle | 4423 | ElementLine[-393 -2755 393 -2755 800] |
4424 | ElementLine[-393 2755 393 2755 800] |
||
4425 | |||
93 | jelle | 4426 | |
347 | jelle | 4427 | # |
4428 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4429 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4430 | # again, it is most useful during parts placement. It really is time for some |
||
4431 | # additional non-fab layers... |
||
4432 | |||
4433 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4434 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4435 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4436 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4437 | |||
4438 | ) |
||
4439 | # grab the input values and convert to 1/100 mil |
||
4440 | |||
4441 | |||
4442 | |||
4443 | |||
4444 | |||
4445 | |||
4446 | |||
4447 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4448 | |||
4449 | # clearance from planes [1/100 mil] |
||
4450 | |||
4451 | # silk screen width [1/100 mil] |
||
4452 | |||
4453 | # courtyard silk screen width [1/100 mil] |
||
4454 | |||
4455 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4456 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4457 | Element[0x00000000 "0805" "C1008" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 4458 | ( |
347 | jelle | 4459 | # |
4460 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4461 | Pad[-3543 -393 |
||
4462 | -3543 393 |
||
4463 | 5118 2000 5718 "1" "1" "square"] |
||
4464 | Pad[3543 -393 |
||
4465 | 3543 393 |
||
4466 | 5118 2000 5718 "2" "2" "square"] |
||
4467 | |||
93 | jelle | 4468 | |
347 | jelle | 4469 | ElementLine[-393 -2755 393 -2755 800] |
4470 | ElementLine[-393 2755 393 2755 800] |
||
4471 | |||
93 | jelle | 4472 | |
347 | jelle | 4473 | # |
4474 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4475 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4476 | # again, it is most useful during parts placement. It really is time for some |
||
4477 | # additional non-fab layers... |
||
4478 | |||
4479 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4480 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4481 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4482 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4483 | |||
4484 | ) |
||
4485 | # grab the input values and convert to 1/100 mil |
||
4486 | |||
4487 | |||
4488 | |||
4489 | |||
4490 | |||
4491 | |||
4492 | |||
4493 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4494 | |||
4495 | # clearance from planes [1/100 mil] |
||
4496 | |||
4497 | # silk screen width [1/100 mil] |
||
4498 | |||
4499 | # courtyard silk screen width [1/100 mil] |
||
4500 | |||
4501 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4502 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4503 | Element[0x00000000 "0805" "C1005" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 4504 | ( |
347 | jelle | 4505 | # |
4506 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4507 | Pad[-3543 -393 |
||
4508 | -3543 393 |
||
4509 | 5118 2000 5718 "1" "1" "square"] |
||
4510 | Pad[3543 -393 |
||
4511 | 3543 393 |
||
4512 | 5118 2000 5718 "2" "2" "square"] |
||
4513 | |||
93 | jelle | 4514 | |
347 | jelle | 4515 | ElementLine[-393 -2755 393 -2755 800] |
4516 | ElementLine[-393 2755 393 2755 800] |
||
4517 | |||
93 | jelle | 4518 | |
347 | jelle | 4519 | # |
4520 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4521 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4522 | # again, it is most useful during parts placement. It really is time for some |
||
4523 | # additional non-fab layers... |
||
4524 | |||
4525 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4526 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4527 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4528 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4529 | |||
4530 | ) |
||
4531 | # grab the input values and convert to 1/100 mil |
||
4532 | |||
4533 | |||
4534 | |||
4535 | |||
4536 | |||
4537 | |||
4538 | |||
4539 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4540 | |||
4541 | # clearance from planes [1/100 mil] |
||
4542 | |||
4543 | # silk screen width [1/100 mil] |
||
4544 | |||
4545 | # courtyard silk screen width [1/100 mil] |
||
4546 | |||
4547 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4548 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4549 | Element[0x00000000 "0805" "C1004" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 4550 | ( |
347 | jelle | 4551 | # |
4552 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4553 | Pad[-3543 -393 |
||
4554 | -3543 393 |
||
4555 | 5118 2000 5718 "1" "1" "square"] |
||
4556 | Pad[3543 -393 |
||
4557 | 3543 393 |
||
4558 | 5118 2000 5718 "2" "2" "square"] |
||
4559 | |||
108 | jelle | 4560 | |
347 | jelle | 4561 | ElementLine[-393 -2755 393 -2755 800] |
4562 | ElementLine[-393 2755 393 2755 800] |
||
4563 | |||
108 | jelle | 4564 | |
347 | jelle | 4565 | # |
4566 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4567 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4568 | # again, it is most useful during parts placement. It really is time for some |
||
4569 | # additional non-fab layers... |
||
4570 | |||
4571 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4572 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4573 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4574 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4575 | |||
4576 | ) |
||
4577 | |||
4578 | |||
4579 | |||
4580 | |||
4581 | |||
4582 | |||
4583 | |||
4584 | |||
4585 | |||
4586 | |||
4587 | |||
4588 | |||
4589 | |||
4590 | |||
4591 | Element(0x00 "SOT223" "U103" "unknown" 305 0 3 100 0x00) |
||
108 | jelle | 4592 | ( |
347 | jelle | 4593 | ElementLine(0 0 0 414 10) |
4594 | ElementLine(0 414 285 414 10) |
||
4595 | ElementLine(285 414 285 0 10) |
||
4596 | ElementLine(285 0 0 0 10) |
||
93 | jelle | 4597 | |
347 | jelle | 4598 | # 1st pin on pin side |
4599 | Pad(52 296 |
||
4600 | 52 362 |
||
4601 | 56 |
||
4602 | "1" "1" 0x100) |
||
4603 | |||
93 | jelle | 4604 | |
347 | jelle | 4605 | Pad(142 296 |
4606 | 142 362 |
||
4607 | 56 |
||
4608 | "2" "2" 0x100) |
||
4609 | |||
4610 | |||
4611 | |||
4612 | |||
4613 | # last pin on pin side |
||
4614 | Pad(233 296 |
||
4615 | 233 362 |
||
4616 | 56 |
||
4617 | "3" "3" 0x100) |
||
4618 | |||
4619 | |||
4620 | # extra wide pin on opposite side |
||
4621 | Pad(187 85 |
||
4622 | 97 85 |
||
4623 | 122 "4" "4" 0x100) |
||
4624 | |||
4625 | Mark(52 329) |
||
4626 | ) |
||
4627 | |||
4628 | |||
4629 | |||
4630 | |||
4631 | |||
4632 | |||
4633 | |||
4634 | |||
4635 | |||
4636 | |||
4637 | |||
4638 | |||
4639 | |||
4640 | |||
4641 | Element(0x00 "SOT223" "U102" "unknown" 305 0 3 100 0x00) |
||
93 | jelle | 4642 | ( |
347 | jelle | 4643 | ElementLine(0 0 0 414 10) |
4644 | ElementLine(0 414 285 414 10) |
||
4645 | ElementLine(285 414 285 0 10) |
||
4646 | ElementLine(285 0 0 0 10) |
||
93 | jelle | 4647 | |
347 | jelle | 4648 | # 1st pin on pin side |
4649 | Pad(52 296 |
||
4650 | 52 362 |
||
4651 | 56 |
||
4652 | "1" "1" 0x100) |
||
4653 | |||
93 | jelle | 4654 | |
347 | jelle | 4655 | Pad(142 296 |
4656 | 142 362 |
||
4657 | 56 |
||
4658 | "2" "2" 0x100) |
||
4659 | |||
4660 | |||
4661 | |||
108 | jelle | 4662 | |
347 | jelle | 4663 | # last pin on pin side |
4664 | Pad(233 296 |
||
4665 | 233 362 |
||
4666 | 56 |
||
4667 | "3" "3" 0x100) |
||
4668 | |||
4669 | |||
4670 | # extra wide pin on opposite side |
||
4671 | Pad(187 85 |
||
4672 | 97 85 |
||
4673 | 122 "4" "4" 0x100) |
||
4674 | |||
4675 | Mark(52 329) |
||
4676 | ) |
||
4677 | |||
4678 | |||
4679 | |||
4680 | |||
4681 | |||
4682 | |||
4683 | |||
4684 | |||
4685 | |||
4686 | |||
4687 | |||
4688 | |||
4689 | |||
4690 | |||
4691 | Element(0x00 "SOT223" "U101" "unknown" 305 0 3 100 0x00) |
||
108 | jelle | 4692 | ( |
347 | jelle | 4693 | ElementLine(0 0 0 414 10) |
4694 | ElementLine(0 414 285 414 10) |
||
4695 | ElementLine(285 414 285 0 10) |
||
4696 | ElementLine(285 0 0 0 10) |
||
93 | jelle | 4697 | |
347 | jelle | 4698 | # 1st pin on pin side |
4699 | Pad(52 296 |
||
4700 | 52 362 |
||
4701 | 56 |
||
4702 | "1" "1" 0x100) |
||
4703 | |||
93 | jelle | 4704 | |
347 | jelle | 4705 | Pad(142 296 |
4706 | 142 362 |
||
4707 | 56 |
||
4708 | "2" "2" 0x100) |
||
4709 | |||
4710 | |||
4711 | |||
4712 | |||
4713 | # last pin on pin side |
||
4714 | Pad(233 296 |
||
4715 | 233 362 |
||
4716 | 56 |
||
4717 | "3" "3" 0x100) |
||
4718 | |||
4719 | |||
4720 | # extra wide pin on opposite side |
||
4721 | Pad(187 85 |
||
4722 | 97 85 |
||
4723 | 122 "4" "4" 0x100) |
||
4724 | |||
4725 | Mark(52 329) |
||
4726 | ) |
||
4727 | # grab the input values and convert to 1/100 mil |
||
4728 | |||
4729 | |||
4730 | |||
4731 | |||
4732 | |||
4733 | |||
4734 | |||
4735 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4736 | |||
4737 | # clearance from planes [1/100 mil] |
||
4738 | |||
4739 | # silk screen width [1/100 mil] |
||
4740 | |||
4741 | # courtyard silk screen width [1/100 mil] |
||
4742 | |||
4743 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4744 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4745 | Element[0x00000000 "0805" "C501" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 4746 | ( |
347 | jelle | 4747 | # |
4748 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4749 | Pad[-3543 -393 |
||
4750 | -3543 393 |
||
4751 | 5118 2000 5718 "1" "1" "square"] |
||
4752 | Pad[3543 -393 |
||
4753 | 3543 393 |
||
4754 | 5118 2000 5718 "2" "2" "square"] |
||
4755 | |||
93 | jelle | 4756 | |
347 | jelle | 4757 | ElementLine[-393 -2755 393 -2755 800] |
4758 | ElementLine[-393 2755 393 2755 800] |
||
4759 | |||
93 | jelle | 4760 | |
347 | jelle | 4761 | # |
4762 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4763 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4764 | # again, it is most useful during parts placement. It really is time for some |
||
4765 | # additional non-fab layers... |
||
4766 | |||
4767 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4768 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4769 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4770 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4771 | |||
4772 | ) |
||
4773 | # grab the input values and convert to 1/100 mil |
||
4774 | |||
4775 | |||
4776 | |||
4777 | |||
4778 | |||
4779 | |||
4780 | |||
4781 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4782 | |||
4783 | # clearance from planes [1/100 mil] |
||
4784 | |||
4785 | # silk screen width [1/100 mil] |
||
4786 | |||
4787 | # courtyard silk screen width [1/100 mil] |
||
4788 | |||
4789 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4790 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4791 | Element[0x00000000 "0805" "C1007" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 4792 | ( |
347 | jelle | 4793 | # |
4794 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4795 | Pad[-3543 -393 |
||
4796 | -3543 393 |
||
4797 | 5118 2000 5718 "1" "1" "square"] |
||
4798 | Pad[3543 -393 |
||
4799 | 3543 393 |
||
4800 | 5118 2000 5718 "2" "2" "square"] |
||
4801 | |||
93 | jelle | 4802 | |
347 | jelle | 4803 | ElementLine[-393 -2755 393 -2755 800] |
4804 | ElementLine[-393 2755 393 2755 800] |
||
4805 | |||
93 | jelle | 4806 | |
347 | jelle | 4807 | # |
4808 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4809 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4810 | # again, it is most useful during parts placement. It really is time for some |
||
4811 | # additional non-fab layers... |
||
4812 | |||
4813 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4814 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4815 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4816 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4817 | |||
4818 | ) |
||
4819 | # grab the input values and convert to 1/100 mil |
||
4820 | |||
4821 | |||
4822 | |||
4823 | |||
4824 | |||
4825 | |||
4826 | |||
4827 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4828 | |||
4829 | # clearance from planes [1/100 mil] |
||
4830 | |||
4831 | # silk screen width [1/100 mil] |
||
4832 | |||
4833 | # courtyard silk screen width [1/100 mil] |
||
4834 | |||
4835 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4836 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4837 | Element[0x00000000 "0805" "C1009" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 4838 | ( |
347 | jelle | 4839 | # |
4840 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4841 | Pad[-3543 -393 |
||
4842 | -3543 393 |
||
4843 | 5118 2000 5718 "1" "1" "square"] |
||
4844 | Pad[3543 -393 |
||
4845 | 3543 393 |
||
4846 | 5118 2000 5718 "2" "2" "square"] |
||
4847 | |||
108 | jelle | 4848 | |
347 | jelle | 4849 | ElementLine[-393 -2755 393 -2755 800] |
4850 | ElementLine[-393 2755 393 2755 800] |
||
4851 | |||
108 | jelle | 4852 | |
347 | jelle | 4853 | # |
4854 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4855 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4856 | # again, it is most useful during parts placement. It really is time for some |
||
4857 | # additional non-fab layers... |
||
4858 | |||
4859 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4860 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4861 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4862 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4863 | |||
4864 | ) |
||
4865 | # grab the input values and convert to 1/100 mil |
||
4866 | |||
4867 | |||
4868 | |||
4869 | |||
4870 | |||
4871 | |||
4872 | |||
4873 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4874 | |||
4875 | # clearance from planes [1/100 mil] |
||
4876 | |||
4877 | # silk screen width [1/100 mil] |
||
4878 | |||
4879 | # courtyard silk screen width [1/100 mil] |
||
4880 | |||
4881 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4882 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4883 | Element[0x00000000 "0805" "C1001" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
108 | jelle | 4884 | ( |
347 | jelle | 4885 | # |
4886 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4887 | Pad[-3543 -393 |
||
4888 | -3543 393 |
||
4889 | 5118 2000 5718 "1" "1" "square"] |
||
4890 | Pad[3543 -393 |
||
4891 | 3543 393 |
||
4892 | 5118 2000 5718 "2" "2" "square"] |
||
4893 | |||
92 | jelle | 4894 | |
347 | jelle | 4895 | ElementLine[-393 -2755 393 -2755 800] |
4896 | ElementLine[-393 2755 393 2755 800] |
||
4897 | |||
92 | jelle | 4898 | |
347 | jelle | 4899 | # |
4900 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4901 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4902 | # again, it is most useful during parts placement. It really is time for some |
||
4903 | # additional non-fab layers... |
||
4904 | |||
4905 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4906 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4907 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4908 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4909 | |||
4910 | ) |
||
4911 | # grab the input values and convert to 1/100 mil |
||
4912 | |||
4913 | |||
4914 | |||
4915 | |||
4916 | |||
4917 | |||
4918 | |||
4919 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4920 | |||
4921 | # clearance from planes [1/100 mil] |
||
4922 | |||
4923 | # silk screen width [1/100 mil] |
||
4924 | |||
4925 | # courtyard silk screen width [1/100 mil] |
||
4926 | |||
4927 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4928 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4929 | Element[0x00000000 "0805" "R707" "49.9R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4930 | ( |
347 | jelle | 4931 | # |
4932 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4933 | Pad[-3543 -393 |
||
4934 | -3543 393 |
||
4935 | 5118 2000 5718 "1" "1" "square"] |
||
4936 | Pad[3543 -393 |
||
4937 | 3543 393 |
||
4938 | 5118 2000 5718 "2" "2" "square"] |
||
4939 | |||
92 | jelle | 4940 | |
347 | jelle | 4941 | ElementLine[-393 -2755 393 -2755 800] |
4942 | ElementLine[-393 2755 393 2755 800] |
||
4943 | |||
92 | jelle | 4944 | |
347 | jelle | 4945 | # |
4946 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4947 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4948 | # again, it is most useful during parts placement. It really is time for some |
||
4949 | # additional non-fab layers... |
||
4950 | |||
4951 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4952 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4953 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4954 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4955 | |||
4956 | ) |
||
4957 | # grab the input values and convert to 1/100 mil |
||
4958 | |||
4959 | |||
4960 | |||
4961 | |||
4962 | |||
4963 | |||
4964 | |||
4965 | # how much to grow the pads by for soldermask [1/100 mil] |
||
4966 | |||
4967 | # clearance from planes [1/100 mil] |
||
4968 | |||
4969 | # silk screen width [1/100 mil] |
||
4970 | |||
4971 | # courtyard silk screen width [1/100 mil] |
||
4972 | |||
4973 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
4974 | # text_x, text_y, text_direction, text_scale, text_flags |
||
4975 | Element[0x00000000 "0805" "R105" "390R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 4976 | ( |
347 | jelle | 4977 | # |
4978 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
4979 | Pad[-3543 -393 |
||
4980 | -3543 393 |
||
4981 | 5118 2000 5718 "1" "1" "square"] |
||
4982 | Pad[3543 -393 |
||
4983 | 3543 393 |
||
4984 | 5118 2000 5718 "2" "2" "square"] |
||
4985 | |||
92 | jelle | 4986 | |
347 | jelle | 4987 | ElementLine[-393 -2755 393 -2755 800] |
4988 | ElementLine[-393 2755 393 2755 800] |
||
4989 | |||
92 | jelle | 4990 | |
347 | jelle | 4991 | # |
4992 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
4993 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
4994 | # again, it is most useful during parts placement. It really is time for some |
||
4995 | # additional non-fab layers... |
||
4996 | |||
4997 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
4998 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
4999 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5000 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5001 | |||
5002 | ) |
||
5003 | # grab the input values and convert to 1/100 mil |
||
5004 | |||
5005 | |||
5006 | |||
5007 | |||
5008 | |||
5009 | |||
5010 | |||
5011 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5012 | |||
5013 | # clearance from planes [1/100 mil] |
||
5014 | |||
5015 | # silk screen width [1/100 mil] |
||
5016 | |||
5017 | # courtyard silk screen width [1/100 mil] |
||
5018 | |||
5019 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5020 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5021 | Element[0x00000000 "0805" "R104" "240R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 5022 | ( |
347 | jelle | 5023 | # |
5024 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5025 | Pad[-3543 -393 |
||
5026 | -3543 393 |
||
5027 | 5118 2000 5718 "1" "1" "square"] |
||
5028 | Pad[3543 -393 |
||
5029 | 3543 393 |
||
5030 | 5118 2000 5718 "2" "2" "square"] |
||
5031 | |||
93 | jelle | 5032 | |
347 | jelle | 5033 | ElementLine[-393 -2755 393 -2755 800] |
5034 | ElementLine[-393 2755 393 2755 800] |
||
5035 | |||
93 | jelle | 5036 | |
347 | jelle | 5037 | # |
5038 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5039 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5040 | # again, it is most useful during parts placement. It really is time for some |
||
5041 | # additional non-fab layers... |
||
5042 | |||
5043 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5044 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5045 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5046 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5047 | |||
5048 | ) |
||
5049 | # grab the input values and convert to 1/100 mil |
||
5050 | |||
5051 | |||
5052 | |||
5053 | |||
5054 | |||
5055 | |||
5056 | |||
5057 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5058 | |||
5059 | # clearance from planes [1/100 mil] |
||
5060 | |||
5061 | # silk screen width [1/100 mil] |
||
5062 | |||
5063 | # courtyard silk screen width [1/100 mil] |
||
5064 | |||
5065 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5066 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5067 | Element[0x00000000 "0805" "R103" "330R" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5068 | ( |
347 | jelle | 5069 | # |
5070 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5071 | Pad[-3543 -393 |
||
5072 | -3543 393 |
||
5073 | 5118 2000 5718 "1" "1" "square"] |
||
5074 | Pad[3543 -393 |
||
5075 | 3543 393 |
||
5076 | 5118 2000 5718 "2" "2" "square"] |
||
5077 | |||
92 | jelle | 5078 | |
347 | jelle | 5079 | ElementLine[-393 -2755 393 -2755 800] |
5080 | ElementLine[-393 2755 393 2755 800] |
||
5081 | |||
92 | jelle | 5082 | |
347 | jelle | 5083 | # |
5084 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5085 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5086 | # again, it is most useful during parts placement. It really is time for some |
||
5087 | # additional non-fab layers... |
||
5088 | |||
5089 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5090 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5091 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5092 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5093 | |||
5094 | ) |
||
5095 | # grab the input values and convert to 1/100 mil |
||
5096 | |||
5097 | |||
5098 | |||
5099 | |||
5100 | |||
5101 | |||
5102 | |||
5103 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5104 | |||
5105 | # clearance from planes [1/100 mil] |
||
5106 | |||
5107 | # silk screen width [1/100 mil] |
||
5108 | |||
5109 | # courtyard silk screen width [1/100 mil] |
||
5110 | |||
5111 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5112 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5113 | Element[0x00000000 "0805" "R102" "220R" 0 0 -3150 -3150 0 100 ""] |
||
92 | jelle | 5114 | ( |
347 | jelle | 5115 | # |
5116 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5117 | Pad[-3543 -393 |
||
5118 | -3543 393 |
||
5119 | 5118 2000 5718 "1" "1" "square"] |
||
5120 | Pad[3543 -393 |
||
5121 | 3543 393 |
||
5122 | 5118 2000 5718 "2" "2" "square"] |
||
5123 | |||
108 | jelle | 5124 | |
347 | jelle | 5125 | ElementLine[-393 -2755 393 -2755 800] |
5126 | ElementLine[-393 2755 393 2755 800] |
||
5127 | |||
108 | jelle | 5128 | |
347 | jelle | 5129 | # |
5130 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5131 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5132 | # again, it is most useful during parts placement. It really is time for some |
||
5133 | # additional non-fab layers... |
||
5134 | |||
5135 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5136 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5137 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5138 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5139 | |||
5140 | ) |
||
5141 | # grab the input values and convert to 1/100 mil |
||
5142 | |||
5143 | |||
5144 | |||
5145 | |||
5146 | |||
5147 | |||
5148 | |||
5149 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5150 | |||
5151 | # clearance from planes [1/100 mil] |
||
5152 | |||
5153 | # silk screen width [1/100 mil] |
||
5154 | |||
5155 | # courtyard silk screen width [1/100 mil] |
||
5156 | |||
5157 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5158 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5159 | Element[0x00000000 "0805" "R101" "120R" 0 0 -3150 -3150 0 100 ""] |
||
108 | jelle | 5160 | ( |
347 | jelle | 5161 | # |
5162 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5163 | Pad[-3543 -393 |
||
5164 | -3543 393 |
||
5165 | 5118 2000 5718 "1" "1" "square"] |
||
5166 | Pad[3543 -393 |
||
5167 | 3543 393 |
||
5168 | 5118 2000 5718 "2" "2" "square"] |
||
5169 | |||
108 | jelle | 5170 | |
347 | jelle | 5171 | ElementLine[-393 -2755 393 -2755 800] |
5172 | ElementLine[-393 2755 393 2755 800] |
||
5173 | |||
108 | jelle | 5174 | |
347 | jelle | 5175 | # |
5176 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5177 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5178 | # again, it is most useful during parts placement. It really is time for some |
||
5179 | # additional non-fab layers... |
||
5180 | |||
5181 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5182 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5183 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5184 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5185 | |||
5186 | ) |
||
5187 | # grab the input values and convert to 1/100 mil |
||
5188 | |||
5189 | |||
5190 | |||
5191 | |||
5192 | |||
5193 | |||
5194 | |||
5195 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5196 | |||
5197 | # clearance from planes [1/100 mil] |
||
5198 | |||
5199 | # silk screen width [1/100 mil] |
||
5200 | |||
5201 | # courtyard silk screen width [1/100 mil] |
||
5202 | |||
5203 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5204 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5205 | Element[0x00000000 "0805" "R706" "49.9R" 0 0 -3150 -3150 0 100 ""] |
||
108 | jelle | 5206 | ( |
347 | jelle | 5207 | # |
5208 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5209 | Pad[-3543 -393 |
||
5210 | -3543 393 |
||
5211 | 5118 2000 5718 "1" "1" "square"] |
||
5212 | Pad[3543 -393 |
||
5213 | 3543 393 |
||
5214 | 5118 2000 5718 "2" "2" "square"] |
||
5215 | |||
93 | jelle | 5216 | |
347 | jelle | 5217 | ElementLine[-393 -2755 393 -2755 800] |
5218 | ElementLine[-393 2755 393 2755 800] |
||
5219 | |||
93 | jelle | 5220 | |
347 | jelle | 5221 | # |
5222 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5223 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5224 | # again, it is most useful during parts placement. It really is time for some |
||
5225 | # additional non-fab layers... |
||
5226 | |||
5227 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5228 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5229 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5230 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5231 | |||
5232 | ) |
||
5233 | # grab the input values and convert to 1/100 mil |
||
5234 | |||
5235 | |||
5236 | |||
5237 | |||
5238 | |||
5239 | |||
5240 | |||
5241 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5242 | |||
5243 | # clearance from planes [1/100 mil] |
||
5244 | |||
5245 | # silk screen width [1/100 mil] |
||
5246 | |||
5247 | # courtyard silk screen width [1/100 mil] |
||
5248 | |||
5249 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5250 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5251 | Element[0x00000000 "0805" "C502" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5252 | ( |
347 | jelle | 5253 | # |
5254 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5255 | Pad[-3543 -393 |
||
5256 | -3543 393 |
||
5257 | 5118 2000 5718 "1" "1" "square"] |
||
5258 | Pad[3543 -393 |
||
5259 | 3543 393 |
||
5260 | 5118 2000 5718 "2" "2" "square"] |
||
5261 | |||
92 | jelle | 5262 | |
347 | jelle | 5263 | ElementLine[-393 -2755 393 -2755 800] |
5264 | ElementLine[-393 2755 393 2755 800] |
||
5265 | |||
93 | jelle | 5266 | |
347 | jelle | 5267 | # |
5268 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5269 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5270 | # again, it is most useful during parts placement. It really is time for some |
||
5271 | # additional non-fab layers... |
||
5272 | |||
5273 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5274 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5275 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5276 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5277 | |||
5278 | ) |
||
5279 | # grab the input values and convert to 1/100 mil |
||
5280 | |||
5281 | |||
5282 | |||
5283 | |||
5284 | |||
5285 | |||
5286 | |||
5287 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5288 | |||
5289 | # clearance from planes [1/100 mil] |
||
5290 | |||
5291 | # silk screen width [1/100 mil] |
||
5292 | |||
5293 | # courtyard silk screen width [1/100 mil] |
||
5294 | |||
5295 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5296 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5297 | Element[0x00000000 "0805" "R705" "49.9R" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5298 | ( |
347 | jelle | 5299 | # |
5300 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5301 | Pad[-3543 -393 |
||
5302 | -3543 393 |
||
5303 | 5118 2000 5718 "1" "1" "square"] |
||
5304 | Pad[3543 -393 |
||
5305 | 3543 393 |
||
5306 | 5118 2000 5718 "2" "2" "square"] |
||
5307 | |||
93 | jelle | 5308 | |
347 | jelle | 5309 | ElementLine[-393 -2755 393 -2755 800] |
5310 | ElementLine[-393 2755 393 2755 800] |
||
5311 | |||
93 | jelle | 5312 | |
347 | jelle | 5313 | # |
5314 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5315 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5316 | # again, it is most useful during parts placement. It really is time for some |
||
5317 | # additional non-fab layers... |
||
5318 | |||
5319 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5320 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5321 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5322 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5323 | |||
5324 | ) |
||
5325 | # grab the input values and convert to 1/100 mil |
||
5326 | |||
5327 | |||
5328 | |||
5329 | |||
5330 | |||
5331 | |||
5332 | |||
5333 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5334 | |||
5335 | # clearance from planes [1/100 mil] |
||
5336 | |||
5337 | # silk screen width [1/100 mil] |
||
5338 | |||
5339 | # courtyard silk screen width [1/100 mil] |
||
5340 | |||
5341 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5342 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5343 | Element[0x00000000 "0805" "R704" "49.9R" 0 0 -3150 -3150 0 100 ""] |
||
108 | jelle | 5344 | ( |
347 | jelle | 5345 | # |
5346 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5347 | Pad[-3543 -393 |
||
5348 | -3543 393 |
||
5349 | 5118 2000 5718 "1" "1" "square"] |
||
5350 | Pad[3543 -393 |
||
5351 | 3543 393 |
||
5352 | 5118 2000 5718 "2" "2" "square"] |
||
5353 | |||
108 | jelle | 5354 | |
347 | jelle | 5355 | ElementLine[-393 -2755 393 -2755 800] |
5356 | ElementLine[-393 2755 393 2755 800] |
||
5357 | |||
108 | jelle | 5358 | |
347 | jelle | 5359 | # |
5360 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5361 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5362 | # again, it is most useful during parts placement. It really is time for some |
||
5363 | # additional non-fab layers... |
||
5364 | |||
5365 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5366 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5367 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5368 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5369 | |||
5370 | ) |
||
5371 | # grab the input values and convert to 1/100 mil |
||
5372 | |||
5373 | |||
5374 | |||
5375 | |||
5376 | |||
5377 | |||
5378 | |||
5379 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5380 | |||
5381 | # clearance from planes [1/100 mil] |
||
5382 | |||
5383 | # silk screen width [1/100 mil] |
||
5384 | |||
5385 | # courtyard silk screen width [1/100 mil] |
||
5386 | |||
5387 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5388 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5389 | Element[0x00000000 "0805" "R703" "330R" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5390 | ( |
347 | jelle | 5391 | # |
5392 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5393 | Pad[-3543 -393 |
||
5394 | -3543 393 |
||
5395 | 5118 2000 5718 "1" "1" "square"] |
||
5396 | Pad[3543 -393 |
||
5397 | 3543 393 |
||
5398 | 5118 2000 5718 "2" "2" "square"] |
||
5399 | |||
93 | jelle | 5400 | |
347 | jelle | 5401 | ElementLine[-393 -2755 393 -2755 800] |
5402 | ElementLine[-393 2755 393 2755 800] |
||
5403 | |||
93 | jelle | 5404 | |
347 | jelle | 5405 | # |
5406 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5407 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5408 | # again, it is most useful during parts placement. It really is time for some |
||
5409 | # additional non-fab layers... |
||
5410 | |||
5411 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5412 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5413 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5414 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5415 | |||
5416 | ) |
||
5417 | # grab the input values and convert to 1/100 mil |
||
5418 | |||
5419 | |||
5420 | |||
5421 | |||
5422 | |||
5423 | |||
5424 | |||
5425 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5426 | |||
5427 | # clearance from planes [1/100 mil] |
||
5428 | |||
5429 | # silk screen width [1/100 mil] |
||
5430 | |||
5431 | # courtyard silk screen width [1/100 mil] |
||
5432 | |||
5433 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5434 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5435 | Element[0x00000000 "0805" "R702" "2K32" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5436 | ( |
347 | jelle | 5437 | # |
5438 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5439 | Pad[-3543 -393 |
||
5440 | -3543 393 |
||
5441 | 5118 2000 5718 "1" "1" "square"] |
||
5442 | Pad[3543 -393 |
||
5443 | 3543 393 |
||
5444 | 5118 2000 5718 "2" "2" "square"] |
||
5445 | |||
93 | jelle | 5446 | |
347 | jelle | 5447 | ElementLine[-393 -2755 393 -2755 800] |
5448 | ElementLine[-393 2755 393 2755 800] |
||
5449 | |||
93 | jelle | 5450 | |
347 | jelle | 5451 | # |
5452 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5453 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5454 | # again, it is most useful during parts placement. It really is time for some |
||
5455 | # additional non-fab layers... |
||
5456 | |||
5457 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5458 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5459 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5460 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5461 | |||
5462 | ) |
||
5463 | # grab the input values and convert to 1/100 mil |
||
5464 | |||
5465 | |||
5466 | |||
5467 | |||
5468 | |||
5469 | |||
5470 | |||
5471 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5472 | |||
5473 | # clearance from planes [1/100 mil] |
||
5474 | |||
5475 | # silk screen width [1/100 mil] |
||
5476 | |||
5477 | # courtyard silk screen width [1/100 mil] |
||
5478 | |||
5479 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5480 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5481 | Element[0x00000000 "0805" "R701" "330R" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5482 | ( |
347 | jelle | 5483 | # |
5484 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5485 | Pad[-3543 -393 |
||
5486 | -3543 393 |
||
5487 | 5118 2000 5718 "1" "1" "square"] |
||
5488 | Pad[3543 -393 |
||
5489 | 3543 393 |
||
5490 | 5118 2000 5718 "2" "2" "square"] |
||
5491 | |||
93 | jelle | 5492 | |
347 | jelle | 5493 | ElementLine[-393 -2755 393 -2755 800] |
5494 | ElementLine[-393 2755 393 2755 800] |
||
5495 | |||
93 | jelle | 5496 | |
347 | jelle | 5497 | # |
5498 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5499 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5500 | # again, it is most useful during parts placement. It really is time for some |
||
5501 | # additional non-fab layers... |
||
5502 | |||
5503 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5504 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5505 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5506 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5507 | |||
5508 | ) |
||
5509 | # grab the input values and convert to 1/100 mil |
||
5510 | |||
5511 | |||
5512 | |||
5513 | |||
5514 | |||
5515 | |||
5516 | |||
5517 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5518 | |||
5519 | # clearance from planes [1/100 mil] |
||
5520 | |||
5521 | # silk screen width [1/100 mil] |
||
5522 | |||
5523 | # courtyard silk screen width [1/100 mil] |
||
5524 | |||
5525 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5526 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5527 | Element[0x00000000 "0805" "R1301" "330R" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5528 | ( |
347 | jelle | 5529 | # |
5530 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5531 | Pad[-3543 -393 |
||
5532 | -3543 393 |
||
5533 | 5118 2000 5718 "1" "1" "square"] |
||
5534 | Pad[3543 -393 |
||
5535 | 3543 393 |
||
5536 | 5118 2000 5718 "2" "2" "square"] |
||
5537 | |||
93 | jelle | 5538 | |
347 | jelle | 5539 | ElementLine[-393 -2755 393 -2755 800] |
5540 | ElementLine[-393 2755 393 2755 800] |
||
5541 | |||
93 | jelle | 5542 | |
347 | jelle | 5543 | # |
5544 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5545 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5546 | # again, it is most useful during parts placement. It really is time for some |
||
5547 | # additional non-fab layers... |
||
5548 | |||
5549 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5550 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5551 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5552 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5553 | |||
5554 | ) |
||
5555 | # grab the input values and convert to 1/100 mil |
||
5556 | |||
5557 | |||
5558 | |||
5559 | |||
5560 | |||
5561 | |||
5562 | |||
5563 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5564 | |||
5565 | # clearance from planes [1/100 mil] |
||
5566 | |||
5567 | # silk screen width [1/100 mil] |
||
5568 | |||
5569 | # courtyard silk screen width [1/100 mil] |
||
5570 | |||
5571 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5572 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5573 | Element[0x00000000 "0805" "C1218" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
93 | jelle | 5574 | ( |
347 | jelle | 5575 | # |
5576 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5577 | Pad[-3543 -393 |
||
5578 | -3543 393 |
||
5579 | 5118 2000 5718 "1" "1" "square"] |
||
5580 | Pad[3543 -393 |
||
5581 | 3543 393 |
||
5582 | 5118 2000 5718 "2" "2" "square"] |
||
5583 | |||
93 | jelle | 5584 | |
347 | jelle | 5585 | ElementLine[-393 -2755 393 -2755 800] |
5586 | ElementLine[-393 2755 393 2755 800] |
||
5587 | |||
5588 | |||
5589 | # |
||
5590 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5591 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5592 | # again, it is most useful during parts placement. It really is time for some |
||
5593 | # additional non-fab layers... |
||
5594 | |||
5595 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5596 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5597 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5598 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5599 | |||
5600 | ) |
||
5601 | # grab the input values and convert to 1/100 mil |
||
5602 | |||
5603 | |||
5604 | |||
5605 | |||
5606 | |||
5607 | |||
5608 | |||
5609 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5610 | |||
5611 | # clearance from planes [1/100 mil] |
||
5612 | |||
5613 | # silk screen width [1/100 mil] |
||
5614 | |||
5615 | # courtyard silk screen width [1/100 mil] |
||
5616 | |||
5617 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5618 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5619 | Element[0x00000000 "0805" "D1301" "unknown" 0 0 -3150 -3150 0 100 ""] |
||
5620 | ( |
||
5621 | # |
||
5622 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5623 | Pad[-3543 -393 |
||
5624 | -3543 393 |
||
5625 | 5118 2000 5718 "1" "1" "square"] |
||
5626 | Pad[3543 -393 |
||
5627 | 3543 393 |
||
5628 | 5118 2000 5718 "2" "2" "square"] |
||
5629 | |||
5630 | |||
5631 | ElementLine[-393 -2755 393 -2755 800] |
||
5632 | ElementLine[-393 2755 393 2755 800] |
||
5633 | |||
5634 | |||
5635 | # |
||
5636 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5637 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5638 | # again, it is most useful during parts placement. It really is time for some |
||
5639 | # additional non-fab layers... |
||
5640 | |||
5641 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5642 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5643 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5644 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5645 | |||
5646 | ) |
||
5647 | # grab the input values and convert to 1/100 mil |
||
5648 | |||
5649 | |||
5650 | |||
5651 | |||
5652 | |||
5653 | |||
5654 | |||
5655 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5656 | |||
5657 | # clearance from planes [1/100 mil] |
||
5658 | |||
5659 | # silk screen width [1/100 mil] |
||
5660 | |||
5661 | # courtyard silk screen width [1/100 mil] |
||
5662 | |||
5663 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5664 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5665 | Element[0x00000000 "0805" "C1213" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
5666 | ( |
||
5667 | # |
||
5668 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5669 | Pad[-3543 -393 |
||
5670 | -3543 393 |
||
5671 | 5118 2000 5718 "1" "1" "square"] |
||
5672 | Pad[3543 -393 |
||
5673 | 3543 393 |
||
5674 | 5118 2000 5718 "2" "2" "square"] |
||
5675 | |||
5676 | |||
5677 | ElementLine[-393 -2755 393 -2755 800] |
||
5678 | ElementLine[-393 2755 393 2755 800] |
||
5679 | |||
5680 | |||
5681 | # |
||
5682 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5683 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5684 | # again, it is most useful during parts placement. It really is time for some |
||
5685 | # additional non-fab layers... |
||
5686 | |||
5687 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5688 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5689 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5690 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5691 | |||
5692 | ) |
||
5693 | # 78 for SOT23 |
||
5694 | # 82 for SOT23 |
||
5695 | # 41 for SOT23 |
||
5696 | # 34 for SOT23, 24 for SOT25 |
||
5697 | |||
5698 | |||
5699 | |||
5700 | |||
5701 | |||
5702 | |||
5703 | |||
5704 | |||
5705 | |||
5706 | |||
5707 | Element(0x00 "SOT23" "U202" "unknown" 148 0 3 100 0x00) |
||
5708 | ( |
||
5709 | ElementLine(0 0 0 139 10) |
||
5710 | ElementLine(0 139 128 139 10) |
||
5711 | ElementLine(128 139 128 0 10) |
||
5712 | ElementLine(128 0 0 0 10) |
||
5713 | |||
5714 | # 1st side, 1st pin |
||
5715 | Pad(25 107 |
||
5716 | 25 113 |
||
5717 | 34 |
||
5718 | "1" "1" 0x100) |
||
5719 | |||
5720 | |||
5721 | |||
5722 | # 1st side, 2nd pin |
||
5723 | |||
5724 | |||
5725 | # 1st side, 3rd pin |
||
5726 | Pad(103 107 |
||
5727 | 103 113 |
||
5728 | 34 |
||
5729 | "2" "2" 0x100) |
||
5730 | |||
5731 | |||
5732 | # 2nd side, 3rd pin |
||
5733 | |||
5734 | |||
5735 | # 2nd side, 2nd pin |
||
5736 | Pad(64 25 |
||
5737 | 64 31 |
||
5738 | 34 |
||
5739 | "3" "3" 0x100) |
||
5740 | |||
5741 | |||
5742 | |||
5743 | # 2nd side, 1st pin |
||
5744 | |||
5745 | |||
5746 | Mark(25 110) |
||
5747 | ) |
||
5748 | # 78 for SOT23 |
||
5749 | # 82 for SOT23 |
||
5750 | # 41 for SOT23 |
||
5751 | # 34 for SOT23, 24 for SOT25 |
||
5752 | |||
5753 | |||
5754 | |||
5755 | |||
5756 | |||
5757 | |||
5758 | |||
5759 | |||
5760 | |||
5761 | |||
5762 | Element(0x00 "SOT23" "U201" "unknown" 148 0 3 100 0x00) |
||
5763 | ( |
||
5764 | ElementLine(0 0 0 139 10) |
||
5765 | ElementLine(0 139 128 139 10) |
||
5766 | ElementLine(128 139 128 0 10) |
||
5767 | ElementLine(128 0 0 0 10) |
||
5768 | |||
5769 | # 1st side, 1st pin |
||
5770 | Pad(25 107 |
||
5771 | 25 113 |
||
5772 | 34 |
||
5773 | "1" "1" 0x100) |
||
5774 | |||
5775 | |||
5776 | |||
5777 | # 1st side, 2nd pin |
||
5778 | |||
5779 | |||
5780 | # 1st side, 3rd pin |
||
5781 | Pad(103 107 |
||
5782 | 103 113 |
||
5783 | 34 |
||
5784 | "2" "2" 0x100) |
||
5785 | |||
5786 | |||
5787 | # 2nd side, 3rd pin |
||
5788 | |||
5789 | |||
5790 | # 2nd side, 2nd pin |
||
5791 | Pad(64 25 |
||
5792 | 64 31 |
||
5793 | 34 |
||
5794 | "3" "3" 0x100) |
||
5795 | |||
5796 | |||
5797 | |||
5798 | # 2nd side, 1st pin |
||
5799 | |||
5800 | |||
5801 | Mark(25 110) |
||
5802 | ) |
||
5803 | # grab the input values and convert to 1/100 mil |
||
5804 | |||
5805 | |||
5806 | |||
5807 | |||
5808 | |||
5809 | |||
5810 | |||
5811 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5812 | |||
5813 | # clearance from planes [1/100 mil] |
||
5814 | |||
5815 | # silk screen width [1/100 mil] |
||
5816 | |||
5817 | # courtyard silk screen width [1/100 mil] |
||
5818 | |||
5819 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5820 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5821 | Element[0x00000000 "0805" "C1215" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
5822 | ( |
||
5823 | # |
||
5824 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5825 | Pad[-3543 -393 |
||
5826 | -3543 393 |
||
5827 | 5118 2000 5718 "1" "1" "square"] |
||
5828 | Pad[3543 -393 |
||
5829 | 3543 393 |
||
5830 | 5118 2000 5718 "2" "2" "square"] |
||
5831 | |||
5832 | |||
5833 | ElementLine[-393 -2755 393 -2755 800] |
||
5834 | ElementLine[-393 2755 393 2755 800] |
||
5835 | |||
5836 | |||
5837 | # |
||
5838 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5839 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5840 | # again, it is most useful during parts placement. It really is time for some |
||
5841 | # additional non-fab layers... |
||
5842 | |||
5843 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5844 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5845 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5846 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5847 | |||
5848 | ) |
||
5849 | # grab the input values and convert to 1/100 mil |
||
5850 | |||
5851 | |||
5852 | |||
5853 | |||
5854 | |||
5855 | |||
5856 | |||
5857 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5858 | |||
5859 | # clearance from planes [1/100 mil] |
||
5860 | |||
5861 | # silk screen width [1/100 mil] |
||
5862 | |||
5863 | # courtyard silk screen width [1/100 mil] |
||
5864 | |||
5865 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5866 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5867 | Element[0x00000000 "0805" "C1221" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
5868 | ( |
||
5869 | # |
||
5870 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5871 | Pad[-3543 -393 |
||
5872 | -3543 393 |
||
5873 | 5118 2000 5718 "1" "1" "square"] |
||
5874 | Pad[3543 -393 |
||
5875 | 3543 393 |
||
5876 | 5118 2000 5718 "2" "2" "square"] |
||
5877 | |||
5878 | |||
5879 | ElementLine[-393 -2755 393 -2755 800] |
||
5880 | ElementLine[-393 2755 393 2755 800] |
||
5881 | |||
5882 | |||
5883 | # |
||
5884 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5885 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5886 | # again, it is most useful during parts placement. It really is time for some |
||
5887 | # additional non-fab layers... |
||
5888 | |||
5889 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5890 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5891 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5892 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5893 | |||
5894 | ) |
||
5895 | # grab the input values and convert to 1/100 mil |
||
5896 | |||
5897 | |||
5898 | |||
5899 | |||
5900 | |||
5901 | |||
5902 | |||
5903 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5904 | |||
5905 | # clearance from planes [1/100 mil] |
||
5906 | |||
5907 | # silk screen width [1/100 mil] |
||
5908 | |||
5909 | # courtyard silk screen width [1/100 mil] |
||
5910 | |||
5911 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5912 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5913 | Element[0x00000000 "0805" "C1220" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
5914 | ( |
||
5915 | # |
||
5916 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5917 | Pad[-3543 -393 |
||
5918 | -3543 393 |
||
5919 | 5118 2000 5718 "1" "1" "square"] |
||
5920 | Pad[3543 -393 |
||
5921 | 3543 393 |
||
5922 | 5118 2000 5718 "2" "2" "square"] |
||
5923 | |||
5924 | |||
5925 | ElementLine[-393 -2755 393 -2755 800] |
||
5926 | ElementLine[-393 2755 393 2755 800] |
||
5927 | |||
5928 | |||
5929 | # |
||
5930 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5931 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5932 | # again, it is most useful during parts placement. It really is time for some |
||
5933 | # additional non-fab layers... |
||
5934 | |||
5935 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5936 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5937 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5938 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5939 | |||
5940 | ) |
||
5941 | # grab the input values and convert to 1/100 mil |
||
5942 | |||
5943 | |||
5944 | |||
5945 | |||
5946 | |||
5947 | |||
5948 | |||
5949 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5950 | |||
5951 | # clearance from planes [1/100 mil] |
||
5952 | |||
5953 | # silk screen width [1/100 mil] |
||
5954 | |||
5955 | # courtyard silk screen width [1/100 mil] |
||
5956 | |||
5957 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
5958 | # text_x, text_y, text_direction, text_scale, text_flags |
||
5959 | Element[0x00000000 "0805" "D1302" "unknown" 0 0 -3150 -3150 0 100 ""] |
||
5960 | ( |
||
5961 | # |
||
5962 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
5963 | Pad[-3543 -393 |
||
5964 | -3543 393 |
||
5965 | 5118 2000 5718 "1" "1" "square"] |
||
5966 | Pad[3543 -393 |
||
5967 | 3543 393 |
||
5968 | 5118 2000 5718 "2" "2" "square"] |
||
5969 | |||
5970 | |||
5971 | ElementLine[-393 -2755 393 -2755 800] |
||
5972 | ElementLine[-393 2755 393 2755 800] |
||
5973 | |||
5974 | |||
5975 | # |
||
5976 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
5977 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
5978 | # again, it is most useful during parts placement. It really is time for some |
||
5979 | # additional non-fab layers... |
||
5980 | |||
5981 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5982 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5983 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
5984 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
5985 | |||
5986 | ) |
||
5987 | # grab the input values and convert to 1/100 mil |
||
5988 | |||
5989 | |||
5990 | |||
5991 | |||
5992 | |||
5993 | |||
5994 | |||
5995 | # how much to grow the pads by for soldermask [1/100 mil] |
||
5996 | |||
5997 | # clearance from planes [1/100 mil] |
||
5998 | |||
5999 | # silk screen width [1/100 mil] |
||
6000 | |||
6001 | # courtyard silk screen width [1/100 mil] |
||
6002 | |||
6003 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6004 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6005 | Element[0x00000000 "0805" "C1211" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6006 | ( |
||
6007 | # |
||
6008 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6009 | Pad[-3543 -393 |
||
6010 | -3543 393 |
||
6011 | 5118 2000 5718 "1" "1" "square"] |
||
6012 | Pad[3543 -393 |
||
6013 | 3543 393 |
||
6014 | 5118 2000 5718 "2" "2" "square"] |
||
6015 | |||
6016 | |||
6017 | ElementLine[-393 -2755 393 -2755 800] |
||
6018 | ElementLine[-393 2755 393 2755 800] |
||
6019 | |||
6020 | |||
6021 | # |
||
6022 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6023 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6024 | # again, it is most useful during parts placement. It really is time for some |
||
6025 | # additional non-fab layers... |
||
6026 | |||
6027 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6028 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6029 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6030 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6031 | |||
6032 | ) |
||
6033 | # grab the input values and convert to 1/100 mil |
||
6034 | |||
6035 | |||
6036 | |||
6037 | |||
6038 | |||
6039 | |||
6040 | |||
6041 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6042 | |||
6043 | # clearance from planes [1/100 mil] |
||
6044 | |||
6045 | # silk screen width [1/100 mil] |
||
6046 | |||
6047 | # courtyard silk screen width [1/100 mil] |
||
6048 | |||
6049 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6050 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6051 | Element[0x00000000 "0805" "C1209" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6052 | ( |
||
6053 | # |
||
6054 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6055 | Pad[-3543 -393 |
||
6056 | -3543 393 |
||
6057 | 5118 2000 5718 "1" "1" "square"] |
||
6058 | Pad[3543 -393 |
||
6059 | 3543 393 |
||
6060 | 5118 2000 5718 "2" "2" "square"] |
||
6061 | |||
6062 | |||
6063 | ElementLine[-393 -2755 393 -2755 800] |
||
6064 | ElementLine[-393 2755 393 2755 800] |
||
6065 | |||
6066 | |||
6067 | # |
||
6068 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6069 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6070 | # again, it is most useful during parts placement. It really is time for some |
||
6071 | # additional non-fab layers... |
||
6072 | |||
6073 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6074 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6075 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6076 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6077 | |||
6078 | ) |
||
6079 | # grab the input values and convert to 1/100 mil |
||
6080 | |||
6081 | |||
6082 | |||
6083 | |||
6084 | |||
6085 | |||
6086 | |||
6087 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6088 | |||
6089 | # clearance from planes [1/100 mil] |
||
6090 | |||
6091 | # silk screen width [1/100 mil] |
||
6092 | |||
6093 | # courtyard silk screen width [1/100 mil] |
||
6094 | |||
6095 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6096 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6097 | Element[0x00000000 "0805" "C1108" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6098 | ( |
||
6099 | # |
||
6100 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6101 | Pad[-3543 -393 |
||
6102 | -3543 393 |
||
6103 | 5118 2000 5718 "1" "1" "square"] |
||
6104 | Pad[3543 -393 |
||
6105 | 3543 393 |
||
6106 | 5118 2000 5718 "2" "2" "square"] |
||
6107 | |||
6108 | |||
6109 | ElementLine[-393 -2755 393 -2755 800] |
||
6110 | ElementLine[-393 2755 393 2755 800] |
||
6111 | |||
6112 | |||
6113 | # |
||
6114 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6115 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6116 | # again, it is most useful during parts placement. It really is time for some |
||
6117 | # additional non-fab layers... |
||
6118 | |||
6119 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6120 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6121 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6122 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6123 | |||
6124 | ) |
||
6125 | # grab the input values and convert to 1/100 mil |
||
6126 | |||
6127 | |||
6128 | |||
6129 | |||
6130 | |||
6131 | |||
6132 | |||
6133 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6134 | |||
6135 | # clearance from planes [1/100 mil] |
||
6136 | |||
6137 | # silk screen width [1/100 mil] |
||
6138 | |||
6139 | # courtyard silk screen width [1/100 mil] |
||
6140 | |||
6141 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6142 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6143 | Element[0x00000000 "0805" "C1206" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6144 | ( |
||
6145 | # |
||
6146 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6147 | Pad[-3543 -393 |
||
6148 | -3543 393 |
||
6149 | 5118 2000 5718 "1" "1" "square"] |
||
6150 | Pad[3543 -393 |
||
6151 | 3543 393 |
||
6152 | 5118 2000 5718 "2" "2" "square"] |
||
6153 | |||
6154 | |||
6155 | ElementLine[-393 -2755 393 -2755 800] |
||
6156 | ElementLine[-393 2755 393 2755 800] |
||
6157 | |||
6158 | |||
6159 | # |
||
6160 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6161 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6162 | # again, it is most useful during parts placement. It really is time for some |
||
6163 | # additional non-fab layers... |
||
6164 | |||
6165 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6166 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6167 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6168 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6169 | |||
6170 | ) |
||
6171 | # grab the input values and convert to 1/100 mil |
||
6172 | |||
6173 | |||
6174 | |||
6175 | |||
6176 | |||
6177 | |||
6178 | |||
6179 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6180 | |||
6181 | # clearance from planes [1/100 mil] |
||
6182 | |||
6183 | # silk screen width [1/100 mil] |
||
6184 | |||
6185 | # courtyard silk screen width [1/100 mil] |
||
6186 | |||
6187 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6188 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6189 | Element[0x00000000 "0805" "C1106" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6190 | ( |
||
6191 | # |
||
6192 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6193 | Pad[-3543 -393 |
||
6194 | -3543 393 |
||
6195 | 5118 2000 5718 "1" "1" "square"] |
||
6196 | Pad[3543 -393 |
||
6197 | 3543 393 |
||
6198 | 5118 2000 5718 "2" "2" "square"] |
||
6199 | |||
6200 | |||
6201 | ElementLine[-393 -2755 393 -2755 800] |
||
6202 | ElementLine[-393 2755 393 2755 800] |
||
6203 | |||
6204 | |||
6205 | # |
||
6206 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6207 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6208 | # again, it is most useful during parts placement. It really is time for some |
||
6209 | # additional non-fab layers... |
||
6210 | |||
6211 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6212 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6213 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6214 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6215 | |||
6216 | ) |
||
6217 | # grab the input values and convert to 1/100 mil |
||
6218 | |||
6219 | |||
6220 | |||
6221 | |||
6222 | |||
6223 | |||
6224 | |||
6225 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6226 | |||
6227 | # clearance from planes [1/100 mil] |
||
6228 | |||
6229 | # silk screen width [1/100 mil] |
||
6230 | |||
6231 | # courtyard silk screen width [1/100 mil] |
||
6232 | |||
6233 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6234 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6235 | Element[0x00000000 "0805" "C1105" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6236 | ( |
||
6237 | # |
||
6238 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6239 | Pad[-3543 -393 |
||
6240 | -3543 393 |
||
6241 | 5118 2000 5718 "1" "1" "square"] |
||
6242 | Pad[3543 -393 |
||
6243 | 3543 393 |
||
6244 | 5118 2000 5718 "2" "2" "square"] |
||
6245 | |||
6246 | |||
6247 | ElementLine[-393 -2755 393 -2755 800] |
||
6248 | ElementLine[-393 2755 393 2755 800] |
||
6249 | |||
6250 | |||
6251 | # |
||
6252 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6253 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6254 | # again, it is most useful during parts placement. It really is time for some |
||
6255 | # additional non-fab layers... |
||
6256 | |||
6257 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6258 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6259 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6260 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6261 | |||
6262 | ) |
||
6263 | # grab the input values and convert to 1/100 mil |
||
6264 | |||
6265 | |||
6266 | |||
6267 | |||
6268 | |||
6269 | |||
6270 | |||
6271 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6272 | |||
6273 | # clearance from planes [1/100 mil] |
||
6274 | |||
6275 | # silk screen width [1/100 mil] |
||
6276 | |||
6277 | # courtyard silk screen width [1/100 mil] |
||
6278 | |||
6279 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6280 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6281 | Element[0x00000000 "0805" "C1107" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6282 | ( |
||
6283 | # |
||
6284 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6285 | Pad[-3543 -393 |
||
6286 | -3543 393 |
||
6287 | 5118 2000 5718 "1" "1" "square"] |
||
6288 | Pad[3543 -393 |
||
6289 | 3543 393 |
||
6290 | 5118 2000 5718 "2" "2" "square"] |
||
6291 | |||
6292 | |||
6293 | ElementLine[-393 -2755 393 -2755 800] |
||
6294 | ElementLine[-393 2755 393 2755 800] |
||
6295 | |||
6296 | |||
6297 | # |
||
6298 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6299 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6300 | # again, it is most useful during parts placement. It really is time for some |
||
6301 | # additional non-fab layers... |
||
6302 | |||
6303 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6304 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6305 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6306 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6307 | |||
6308 | ) |
||
6309 | # grab the input values and convert to 1/100 mil |
||
6310 | |||
6311 | |||
6312 | |||
6313 | |||
6314 | |||
6315 | |||
6316 | |||
6317 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6318 | |||
6319 | # clearance from planes [1/100 mil] |
||
6320 | |||
6321 | # silk screen width [1/100 mil] |
||
6322 | |||
6323 | # courtyard silk screen width [1/100 mil] |
||
6324 | |||
6325 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6326 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6327 | Element[0x00000000 "0805" "C1109" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6328 | ( |
||
6329 | # |
||
6330 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6331 | Pad[-3543 -393 |
||
6332 | -3543 393 |
||
6333 | 5118 2000 5718 "1" "1" "square"] |
||
6334 | Pad[3543 -393 |
||
6335 | 3543 393 |
||
6336 | 5118 2000 5718 "2" "2" "square"] |
||
6337 | |||
6338 | |||
6339 | ElementLine[-393 -2755 393 -2755 800] |
||
6340 | ElementLine[-393 2755 393 2755 800] |
||
6341 | |||
6342 | |||
6343 | # |
||
6344 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6345 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6346 | # again, it is most useful during parts placement. It really is time for some |
||
6347 | # additional non-fab layers... |
||
6348 | |||
6349 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6350 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6351 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6352 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6353 | |||
6354 | ) |
||
6355 | # grab the input values and convert to 1/100 mil |
||
6356 | |||
6357 | |||
6358 | |||
6359 | |||
6360 | |||
6361 | |||
6362 | |||
6363 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6364 | |||
6365 | # clearance from planes [1/100 mil] |
||
6366 | |||
6367 | # silk screen width [1/100 mil] |
||
6368 | |||
6369 | # courtyard silk screen width [1/100 mil] |
||
6370 | |||
6371 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6372 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6373 | Element[0x00000000 "0805" "R204" "4k7" 0 0 -3150 -3150 0 100 ""] |
||
6374 | ( |
||
6375 | # |
||
6376 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6377 | Pad[-3543 -393 |
||
6378 | -3543 393 |
||
6379 | 5118 2000 5718 "1" "1" "square"] |
||
6380 | Pad[3543 -393 |
||
6381 | 3543 393 |
||
6382 | 5118 2000 5718 "2" "2" "square"] |
||
6383 | |||
6384 | |||
6385 | ElementLine[-393 -2755 393 -2755 800] |
||
6386 | ElementLine[-393 2755 393 2755 800] |
||
6387 | |||
6388 | |||
6389 | # |
||
6390 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6391 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6392 | # again, it is most useful during parts placement. It really is time for some |
||
6393 | # additional non-fab layers... |
||
6394 | |||
6395 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6396 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6397 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6398 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6399 | |||
6400 | ) |
||
6401 | # grab the input values and convert to 1/100 mil |
||
6402 | |||
6403 | |||
6404 | |||
6405 | |||
6406 | |||
6407 | |||
6408 | |||
6409 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6410 | |||
6411 | # clearance from planes [1/100 mil] |
||
6412 | |||
6413 | # silk screen width [1/100 mil] |
||
6414 | |||
6415 | # courtyard silk screen width [1/100 mil] |
||
6416 | |||
6417 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6418 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6419 | Element[0x00000000 "0805" "R203" "10k" 0 0 -3150 -3150 0 100 ""] |
||
6420 | ( |
||
6421 | # |
||
6422 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6423 | Pad[-3543 -393 |
||
6424 | -3543 393 |
||
6425 | 5118 2000 5718 "1" "1" "square"] |
||
6426 | Pad[3543 -393 |
||
6427 | 3543 393 |
||
6428 | 5118 2000 5718 "2" "2" "square"] |
||
6429 | |||
6430 | |||
6431 | ElementLine[-393 -2755 393 -2755 800] |
||
6432 | ElementLine[-393 2755 393 2755 800] |
||
6433 | |||
6434 | |||
6435 | # |
||
6436 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6437 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6438 | # again, it is most useful during parts placement. It really is time for some |
||
6439 | # additional non-fab layers... |
||
6440 | |||
6441 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6442 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6443 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6444 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6445 | |||
6446 | ) |
||
6447 | # grab the input values and convert to 1/100 mil |
||
6448 | |||
6449 | |||
6450 | |||
6451 | |||
6452 | |||
6453 | |||
6454 | |||
6455 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6456 | |||
6457 | # clearance from planes [1/100 mil] |
||
6458 | |||
6459 | # silk screen width [1/100 mil] |
||
6460 | |||
6461 | # courtyard silk screen width [1/100 mil] |
||
6462 | |||
6463 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6464 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6465 | Element[0x00000000 "0805" "R202" "100" 0 0 -3150 -3150 0 100 ""] |
||
6466 | ( |
||
6467 | # |
||
6468 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6469 | Pad[-3543 -393 |
||
6470 | -3543 393 |
||
6471 | 5118 2000 5718 "1" "1" "square"] |
||
6472 | Pad[3543 -393 |
||
6473 | 3543 393 |
||
6474 | 5118 2000 5718 "2" "2" "square"] |
||
6475 | |||
6476 | |||
6477 | ElementLine[-393 -2755 393 -2755 800] |
||
6478 | ElementLine[-393 2755 393 2755 800] |
||
6479 | |||
6480 | |||
6481 | # |
||
6482 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6483 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6484 | # again, it is most useful during parts placement. It really is time for some |
||
6485 | # additional non-fab layers... |
||
6486 | |||
6487 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6488 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6489 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6490 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6491 | |||
6492 | ) |
||
6493 | # grab the input values and convert to 1/100 mil |
||
6494 | |||
6495 | |||
6496 | |||
6497 | |||
6498 | |||
6499 | |||
6500 | |||
6501 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6502 | |||
6503 | # clearance from planes [1/100 mil] |
||
6504 | |||
6505 | # silk screen width [1/100 mil] |
||
6506 | |||
6507 | # courtyard silk screen width [1/100 mil] |
||
6508 | |||
6509 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6510 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6511 | Element[0x00000000 "0805" "R201" "10k" 0 0 -3150 -3150 0 100 ""] |
||
6512 | ( |
||
6513 | # |
||
6514 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6515 | Pad[-3543 -393 |
||
6516 | -3543 393 |
||
6517 | 5118 2000 5718 "1" "1" "square"] |
||
6518 | Pad[3543 -393 |
||
6519 | 3543 393 |
||
6520 | 5118 2000 5718 "2" "2" "square"] |
||
6521 | |||
6522 | |||
6523 | ElementLine[-393 -2755 393 -2755 800] |
||
6524 | ElementLine[-393 2755 393 2755 800] |
||
6525 | |||
6526 | |||
6527 | # |
||
6528 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6529 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6530 | # again, it is most useful during parts placement. It really is time for some |
||
6531 | # additional non-fab layers... |
||
6532 | |||
6533 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6534 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6535 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6536 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6537 | |||
6538 | ) |
||
6539 | # grab the input values and convert to 1/100 mil |
||
6540 | |||
6541 | |||
6542 | |||
6543 | |||
6544 | |||
6545 | |||
6546 | |||
6547 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6548 | |||
6549 | # clearance from planes [1/100 mil] |
||
6550 | |||
6551 | # silk screen width [1/100 mil] |
||
6552 | |||
6553 | # courtyard silk screen width [1/100 mil] |
||
6554 | |||
6555 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6556 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6557 | Element[0x00000000 "0805" "C1104" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6558 | ( |
||
6559 | # |
||
6560 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6561 | Pad[-3543 -393 |
||
6562 | -3543 393 |
||
6563 | 5118 2000 5718 "1" "1" "square"] |
||
6564 | Pad[3543 -393 |
||
6565 | 3543 393 |
||
6566 | 5118 2000 5718 "2" "2" "square"] |
||
6567 | |||
6568 | |||
6569 | ElementLine[-393 -2755 393 -2755 800] |
||
6570 | ElementLine[-393 2755 393 2755 800] |
||
6571 | |||
6572 | |||
6573 | # |
||
6574 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6575 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6576 | # again, it is most useful during parts placement. It really is time for some |
||
6577 | # additional non-fab layers... |
||
6578 | |||
6579 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6580 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6581 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6582 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6583 | |||
6584 | ) |
||
6585 | # grab the input values and convert to 1/100 mil |
||
6586 | |||
6587 | |||
6588 | |||
6589 | |||
6590 | |||
6591 | |||
6592 | |||
6593 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6594 | |||
6595 | # clearance from planes [1/100 mil] |
||
6596 | |||
6597 | # silk screen width [1/100 mil] |
||
6598 | |||
6599 | # courtyard silk screen width [1/100 mil] |
||
6600 | |||
6601 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6602 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6603 | Element[0x00000000 "0805" "C1103" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6604 | ( |
||
6605 | # |
||
6606 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6607 | Pad[-3543 -393 |
||
6608 | -3543 393 |
||
6609 | 5118 2000 5718 "1" "1" "square"] |
||
6610 | Pad[3543 -393 |
||
6611 | 3543 393 |
||
6612 | 5118 2000 5718 "2" "2" "square"] |
||
6613 | |||
6614 | |||
6615 | ElementLine[-393 -2755 393 -2755 800] |
||
6616 | ElementLine[-393 2755 393 2755 800] |
||
6617 | |||
6618 | |||
6619 | # |
||
6620 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6621 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6622 | # again, it is most useful during parts placement. It really is time for some |
||
6623 | # additional non-fab layers... |
||
6624 | |||
6625 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6626 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6627 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6628 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6629 | |||
6630 | ) |
||
6631 | # grab the input values and convert to 1/100 mil |
||
6632 | |||
6633 | |||
6634 | |||
6635 | |||
6636 | |||
6637 | |||
6638 | |||
6639 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6640 | |||
6641 | # clearance from planes [1/100 mil] |
||
6642 | |||
6643 | # silk screen width [1/100 mil] |
||
6644 | |||
6645 | # courtyard silk screen width [1/100 mil] |
||
6646 | |||
6647 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6648 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6649 | Element[0x00000000 "0805" "C1102" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6650 | ( |
||
6651 | # |
||
6652 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6653 | Pad[-3543 -393 |
||
6654 | -3543 393 |
||
6655 | 5118 2000 5718 "1" "1" "square"] |
||
6656 | Pad[3543 -393 |
||
6657 | 3543 393 |
||
6658 | 5118 2000 5718 "2" "2" "square"] |
||
6659 | |||
6660 | |||
6661 | ElementLine[-393 -2755 393 -2755 800] |
||
6662 | ElementLine[-393 2755 393 2755 800] |
||
6663 | |||
6664 | |||
6665 | # |
||
6666 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6667 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6668 | # again, it is most useful during parts placement. It really is time for some |
||
6669 | # additional non-fab layers... |
||
6670 | |||
6671 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6672 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6673 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6674 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6675 | |||
6676 | ) |
||
6677 | # grab the input values and convert to 1/100 mil |
||
6678 | |||
6679 | |||
6680 | |||
6681 | |||
6682 | |||
6683 | |||
6684 | |||
6685 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6686 | |||
6687 | # clearance from planes [1/100 mil] |
||
6688 | |||
6689 | # silk screen width [1/100 mil] |
||
6690 | |||
6691 | # courtyard silk screen width [1/100 mil] |
||
6692 | |||
6693 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6694 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6695 | Element[0x00000000 "0805" "C1101" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6696 | ( |
||
6697 | # |
||
6698 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6699 | Pad[-3543 -393 |
||
6700 | -3543 393 |
||
6701 | 5118 2000 5718 "1" "1" "square"] |
||
6702 | Pad[3543 -393 |
||
6703 | 3543 393 |
||
6704 | 5118 2000 5718 "2" "2" "square"] |
||
6705 | |||
6706 | |||
6707 | ElementLine[-393 -2755 393 -2755 800] |
||
6708 | ElementLine[-393 2755 393 2755 800] |
||
6709 | |||
6710 | |||
6711 | # |
||
6712 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6713 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6714 | # again, it is most useful during parts placement. It really is time for some |
||
6715 | # additional non-fab layers... |
||
6716 | |||
6717 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6718 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6719 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6720 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6721 | |||
6722 | ) |
||
6723 | # grab the input values and convert to 1/100 mil |
||
6724 | |||
6725 | |||
6726 | |||
6727 | |||
6728 | |||
6729 | |||
6730 | |||
6731 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6732 | |||
6733 | # clearance from planes [1/100 mil] |
||
6734 | |||
6735 | # silk screen width [1/100 mil] |
||
6736 | |||
6737 | # courtyard silk screen width [1/100 mil] |
||
6738 | |||
6739 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6740 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6741 | Element[0x00000000 "0805" "C602" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
6742 | ( |
||
6743 | # |
||
6744 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6745 | Pad[-3543 -393 |
||
6746 | -3543 393 |
||
6747 | 5118 2000 5718 "1" "1" "square"] |
||
6748 | Pad[3543 -393 |
||
6749 | 3543 393 |
||
6750 | 5118 2000 5718 "2" "2" "square"] |
||
6751 | |||
6752 | |||
6753 | ElementLine[-393 -2755 393 -2755 800] |
||
6754 | ElementLine[-393 2755 393 2755 800] |
||
6755 | |||
6756 | |||
6757 | # |
||
6758 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6759 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6760 | # again, it is most useful during parts placement. It really is time for some |
||
6761 | # additional non-fab layers... |
||
6762 | |||
6763 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6764 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6765 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6766 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6767 | |||
6768 | ) |
||
6769 | # grab the input values and convert to 1/100 mil |
||
6770 | |||
6771 | |||
6772 | |||
6773 | |||
6774 | |||
6775 | |||
6776 | |||
6777 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6778 | |||
6779 | # clearance from planes [1/100 mil] |
||
6780 | |||
6781 | # silk screen width [1/100 mil] |
||
6782 | |||
6783 | # courtyard silk screen width [1/100 mil] |
||
6784 | |||
6785 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6786 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6787 | Element[0x00000000 "0805" "C601" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6788 | ( |
||
6789 | # |
||
6790 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6791 | Pad[-3543 -393 |
||
6792 | -3543 393 |
||
6793 | 5118 2000 5718 "1" "1" "square"] |
||
6794 | Pad[3543 -393 |
||
6795 | 3543 393 |
||
6796 | 5118 2000 5718 "2" "2" "square"] |
||
6797 | |||
6798 | |||
6799 | ElementLine[-393 -2755 393 -2755 800] |
||
6800 | ElementLine[-393 2755 393 2755 800] |
||
6801 | |||
6802 | |||
6803 | # |
||
6804 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6805 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6806 | # again, it is most useful during parts placement. It really is time for some |
||
6807 | # additional non-fab layers... |
||
6808 | |||
6809 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6810 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6811 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6812 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6813 | |||
6814 | ) |
||
6815 | # grab the input values and convert to 1/100 mil |
||
6816 | |||
6817 | |||
6818 | |||
6819 | |||
6820 | |||
6821 | |||
6822 | |||
6823 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6824 | |||
6825 | # clearance from planes [1/100 mil] |
||
6826 | |||
6827 | # silk screen width [1/100 mil] |
||
6828 | |||
6829 | # courtyard silk screen width [1/100 mil] |
||
6830 | |||
6831 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6832 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6833 | Element[0x00000000 "0805" "C1219" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6834 | ( |
||
6835 | # |
||
6836 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6837 | Pad[-3543 -393 |
||
6838 | -3543 393 |
||
6839 | 5118 2000 5718 "1" "1" "square"] |
||
6840 | Pad[3543 -393 |
||
6841 | 3543 393 |
||
6842 | 5118 2000 5718 "2" "2" "square"] |
||
6843 | |||
6844 | |||
6845 | ElementLine[-393 -2755 393 -2755 800] |
||
6846 | ElementLine[-393 2755 393 2755 800] |
||
6847 | |||
6848 | |||
6849 | # |
||
6850 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6851 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6852 | # again, it is most useful during parts placement. It really is time for some |
||
6853 | # additional non-fab layers... |
||
6854 | |||
6855 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6856 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6857 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6858 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6859 | |||
6860 | ) |
||
6861 | # grab the input values and convert to 1/100 mil |
||
6862 | |||
6863 | |||
6864 | |||
6865 | |||
6866 | |||
6867 | |||
6868 | |||
6869 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6870 | |||
6871 | # clearance from planes [1/100 mil] |
||
6872 | |||
6873 | # silk screen width [1/100 mil] |
||
6874 | |||
6875 | # courtyard silk screen width [1/100 mil] |
||
6876 | |||
6877 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6878 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6879 | Element[0x00000000 "0805" "C1216" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6880 | ( |
||
6881 | # |
||
6882 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6883 | Pad[-3543 -393 |
||
6884 | -3543 393 |
||
6885 | 5118 2000 5718 "1" "1" "square"] |
||
6886 | Pad[3543 -393 |
||
6887 | 3543 393 |
||
6888 | 5118 2000 5718 "2" "2" "square"] |
||
6889 | |||
6890 | |||
6891 | ElementLine[-393 -2755 393 -2755 800] |
||
6892 | ElementLine[-393 2755 393 2755 800] |
||
6893 | |||
6894 | |||
6895 | # |
||
6896 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6897 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6898 | # again, it is most useful during parts placement. It really is time for some |
||
6899 | # additional non-fab layers... |
||
6900 | |||
6901 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6902 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6903 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6904 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6905 | |||
6906 | ) |
||
6907 | # grab the input values and convert to 1/100 mil |
||
6908 | |||
6909 | |||
6910 | |||
6911 | |||
6912 | |||
6913 | |||
6914 | |||
6915 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6916 | |||
6917 | # clearance from planes [1/100 mil] |
||
6918 | |||
6919 | # silk screen width [1/100 mil] |
||
6920 | |||
6921 | # courtyard silk screen width [1/100 mil] |
||
6922 | |||
6923 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6924 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6925 | Element[0x00000000 "0805" "C1217" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
6926 | ( |
||
6927 | # |
||
6928 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6929 | Pad[-3543 -393 |
||
6930 | -3543 393 |
||
6931 | 5118 2000 5718 "1" "1" "square"] |
||
6932 | Pad[3543 -393 |
||
6933 | 3543 393 |
||
6934 | 5118 2000 5718 "2" "2" "square"] |
||
6935 | |||
6936 | |||
6937 | ElementLine[-393 -2755 393 -2755 800] |
||
6938 | ElementLine[-393 2755 393 2755 800] |
||
6939 | |||
6940 | |||
6941 | # |
||
6942 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6943 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6944 | # again, it is most useful during parts placement. It really is time for some |
||
6945 | # additional non-fab layers... |
||
6946 | |||
6947 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6948 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6949 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6950 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6951 | |||
6952 | ) |
||
6953 | # grab the input values and convert to 1/100 mil |
||
6954 | |||
6955 | |||
6956 | |||
6957 | |||
6958 | |||
6959 | |||
6960 | |||
6961 | # how much to grow the pads by for soldermask [1/100 mil] |
||
6962 | |||
6963 | # clearance from planes [1/100 mil] |
||
6964 | |||
6965 | # silk screen width [1/100 mil] |
||
6966 | |||
6967 | # courtyard silk screen width [1/100 mil] |
||
6968 | |||
6969 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
6970 | # text_x, text_y, text_direction, text_scale, text_flags |
||
6971 | Element[0x00000000 "1210" "C112" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
6972 | ( |
||
6973 | # |
||
6974 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
6975 | Pad[-5905 -2755 |
||
6976 | -5905 2755 |
||
6977 | 5118 2000 5718 "1" "1" "square"] |
||
6978 | Pad[5905 -2755 |
||
6979 | 5905 2755 |
||
6980 | 5118 2000 5718 "2" "2" "square"] |
||
6981 | |||
6982 | |||
6983 | ElementLine[-1968 -5314 1968 -5314 800] |
||
6984 | ElementLine[-1968 5314 1968 5314 800] |
||
6985 | |||
6986 | |||
6987 | # |
||
6988 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
6989 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
6990 | # again, it is most useful during parts placement. It really is time for some |
||
6991 | # additional non-fab layers... |
||
6992 | |||
6993 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6994 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6995 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
6996 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
6997 | |||
6998 | ) |
||
6999 | # grab the input values and convert to 1/100 mil |
||
7000 | |||
7001 | |||
7002 | |||
7003 | |||
7004 | |||
7005 | |||
7006 | |||
7007 | # how much to grow the pads by for soldermask [1/100 mil] |
||
7008 | |||
7009 | # clearance from planes [1/100 mil] |
||
7010 | |||
7011 | # silk screen width [1/100 mil] |
||
7012 | |||
7013 | # courtyard silk screen width [1/100 mil] |
||
7014 | |||
7015 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
7016 | # text_x, text_y, text_direction, text_scale, text_flags |
||
7017 | Element[0x00000000 "1210" "C111" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
7018 | ( |
||
7019 | # |
||
7020 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
7021 | Pad[-5905 -2755 |
||
7022 | -5905 2755 |
||
7023 | 5118 2000 5718 "1" "1" "square"] |
||
7024 | Pad[5905 -2755 |
||
7025 | 5905 2755 |
||
7026 | 5118 2000 5718 "2" "2" "square"] |
||
7027 | |||
7028 | |||
7029 | ElementLine[-1968 -5314 1968 -5314 800] |
||
7030 | ElementLine[-1968 5314 1968 5314 800] |
||
7031 | |||
7032 | |||
7033 | # |
||
7034 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
7035 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
7036 | # again, it is most useful during parts placement. It really is time for some |
||
7037 | # additional non-fab layers... |
||
7038 | |||
7039 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7040 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7041 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7042 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7043 | |||
7044 | ) |
||
7045 | # grab the input values and convert to 1/100 mil |
||
7046 | |||
7047 | |||
7048 | |||
7049 | |||
7050 | |||
7051 | |||
7052 | |||
7053 | # how much to grow the pads by for soldermask [1/100 mil] |
||
7054 | |||
7055 | # clearance from planes [1/100 mil] |
||
7056 | |||
7057 | # silk screen width [1/100 mil] |
||
7058 | |||
7059 | # courtyard silk screen width [1/100 mil] |
||
7060 | |||
7061 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
7062 | # text_x, text_y, text_direction, text_scale, text_flags |
||
7063 | Element[0x00000000 "1210" "C110" "10uF" 0 0 -3150 -3150 0 100 ""] |
||
7064 | ( |
||
7065 | # |
||
7066 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
7067 | Pad[-5905 -2755 |
||
7068 | -5905 2755 |
||
7069 | 5118 2000 5718 "1" "1" "square"] |
||
7070 | Pad[5905 -2755 |
||
7071 | 5905 2755 |
||
7072 | 5118 2000 5718 "2" "2" "square"] |
||
7073 | |||
7074 | |||
7075 | ElementLine[-1968 -5314 1968 -5314 800] |
||
7076 | ElementLine[-1968 5314 1968 5314 800] |
||
7077 | |||
7078 | |||
7079 | # |
||
7080 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
7081 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
7082 | # again, it is most useful during parts placement. It really is time for some |
||
7083 | # additional non-fab layers... |
||
7084 | |||
7085 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7086 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7087 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7088 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7089 | |||
7090 | ) |
||
7091 | # grab the input values and convert to 1/100 mil |
||
7092 | |||
7093 | |||
7094 | |||
7095 | |||
7096 | |||
7097 | |||
7098 | |||
7099 | # how much to grow the pads by for soldermask [1/100 mil] |
||
7100 | |||
7101 | # clearance from planes [1/100 mil] |
||
7102 | |||
7103 | # silk screen width [1/100 mil] |
||
7104 | |||
7105 | # courtyard silk screen width [1/100 mil] |
||
7106 | |||
7107 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
7108 | # text_x, text_y, text_direction, text_scale, text_flags |
||
7109 | Element[0x00000000 "0805" "C1214" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
7110 | ( |
||
7111 | # |
||
7112 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
7113 | Pad[-3543 -393 |
||
7114 | -3543 393 |
||
7115 | 5118 2000 5718 "1" "1" "square"] |
||
7116 | Pad[3543 -393 |
||
7117 | 3543 393 |
||
7118 | 5118 2000 5718 "2" "2" "square"] |
||
7119 | |||
7120 | |||
7121 | ElementLine[-393 -2755 393 -2755 800] |
||
7122 | ElementLine[-393 2755 393 2755 800] |
||
7123 | |||
7124 | |||
7125 | # |
||
7126 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
7127 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
7128 | # again, it is most useful during parts placement. It really is time for some |
||
7129 | # additional non-fab layers... |
||
7130 | |||
7131 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7132 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7133 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7134 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7135 | |||
7136 | ) |
||
7137 | # grab the input values and convert to 1/100 mil |
||
7138 | |||
7139 | |||
7140 | |||
7141 | |||
7142 | |||
7143 | |||
7144 | |||
7145 | # how much to grow the pads by for soldermask [1/100 mil] |
||
7146 | |||
7147 | # clearance from planes [1/100 mil] |
||
7148 | |||
7149 | # silk screen width [1/100 mil] |
||
7150 | |||
7151 | # courtyard silk screen width [1/100 mil] |
||
7152 | |||
7153 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
7154 | # text_x, text_y, text_direction, text_scale, text_flags |
||
7155 | Element[0x00000000 "0805" "C1212" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
7156 | ( |
||
7157 | # |
||
7158 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
7159 | Pad[-3543 -393 |
||
7160 | -3543 393 |
||
7161 | 5118 2000 5718 "1" "1" "square"] |
||
7162 | Pad[3543 -393 |
||
7163 | 3543 393 |
||
7164 | 5118 2000 5718 "2" "2" "square"] |
||
7165 | |||
7166 | |||
7167 | ElementLine[-393 -2755 393 -2755 800] |
||
7168 | ElementLine[-393 2755 393 2755 800] |
||
7169 | |||
7170 | |||
7171 | # |
||
7172 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
7173 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
7174 | # again, it is most useful during parts placement. It really is time for some |
||
7175 | # additional non-fab layers... |
||
7176 | |||
7177 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7178 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7179 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7180 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7181 | |||
7182 | ) |
||
7183 | # grab the input values and convert to 1/100 mil |
||
7184 | |||
7185 | |||
7186 | |||
7187 | |||
7188 | |||
7189 | |||
7190 | |||
7191 | # how much to grow the pads by for soldermask [1/100 mil] |
||
7192 | |||
7193 | # clearance from planes [1/100 mil] |
||
7194 | |||
7195 | # silk screen width [1/100 mil] |
||
7196 | |||
7197 | # courtyard silk screen width [1/100 mil] |
||
7198 | |||
7199 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
7200 | # text_x, text_y, text_direction, text_scale, text_flags |
||
7201 | Element[0x00000000 "0805" "C1210" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
7202 | ( |
||
7203 | # |
||
7204 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
7205 | Pad[-3543 -393 |
||
7206 | -3543 393 |
||
7207 | 5118 2000 5718 "1" "1" "square"] |
||
7208 | Pad[3543 -393 |
||
7209 | 3543 393 |
||
7210 | 5118 2000 5718 "2" "2" "square"] |
||
7211 | |||
7212 | |||
7213 | ElementLine[-393 -2755 393 -2755 800] |
||
7214 | ElementLine[-393 2755 393 2755 800] |
||
7215 | |||
7216 | |||
7217 | # |
||
7218 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
7219 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
7220 | # again, it is most useful during parts placement. It really is time for some |
||
7221 | # additional non-fab layers... |
||
7222 | |||
7223 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7224 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7225 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7226 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7227 | |||
7228 | ) |
||
7229 | # grab the input values and convert to 1/100 mil |
||
7230 | |||
7231 | |||
7232 | |||
7233 | |||
7234 | |||
7235 | |||
7236 | |||
7237 | # how much to grow the pads by for soldermask [1/100 mil] |
||
7238 | |||
7239 | # clearance from planes [1/100 mil] |
||
7240 | |||
7241 | # silk screen width [1/100 mil] |
||
7242 | |||
7243 | # courtyard silk screen width [1/100 mil] |
||
7244 | |||
7245 | # element_flags, description, pcb-name, value, mark_x, mark_y, |
||
7246 | # text_x, text_y, text_direction, text_scale, text_flags |
||
7247 | Element[0x00000000 "0805" "C710" "100nF" 0 0 -3150 -3150 0 100 ""] |
||
7248 | ( |
||
7249 | # |
||
7250 | # Pad[x1, y1, x2, y2, thickness, clearance, mask, name , pad number, flags] |
||
7251 | Pad[-3543 -393 |
||
7252 | -3543 393 |
||
7253 | 5118 2000 5718 "1" "1" "square"] |
||
7254 | Pad[3543 -393 |
||
7255 | 3543 393 |
||
7256 | 5118 2000 5718 "2" "2" "square"] |
||
7257 | |||
7258 | |||
7259 | ElementLine[-393 -2755 393 -2755 800] |
||
7260 | ElementLine[-393 2755 393 2755 800] |
||
7261 | |||
7262 | |||
7263 | # |
||
7264 | # This draws a 1 mil placement courtyard outline in silk. It should probably |
||
7265 | # not be included since you wont want to try and fab a 1 mil silk line. Then |
||
7266 | # again, it is most useful during parts placement. It really is time for some |
||
7267 | # additional non-fab layers... |
||
7268 | |||
7269 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7270 | # ElementLine[eval(-1*V1/2) eval(-1*V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7271 | # ElementLine[eval( V1/2) eval( V2/2) eval( V1/2) eval(-1*V2/2) CYW] |
||
7272 | # ElementLine[eval( V1/2) eval( V2/2) eval(-1*V1/2) eval( V2/2) CYW] |
||
7273 | |||
7274 | ) |
||
92 | jelle | 7275 | Layer(1 "solder") |
7276 | ( |
||
7277 | ) |
||
7278 | Layer(2 "GND-sldr") |
||
7279 | ( |
||
7280 | ) |
||
7281 | Layer(3 "Vcc-sldr") |
||
7282 | ( |
||
7283 | ) |
||
7284 | Layer(4 "component") |
||
7285 | ( |
||
7286 | ) |
||
7287 | Layer(5 "GND-comp") |
||
7288 | ( |
||
7289 | ) |
||
7290 | Layer(6 "Vcc-comp") |
||
7291 | ( |
||
7292 | ) |
||
7293 | Layer(7 "unused") |
||
7294 | ( |
||
7295 | ) |
||
7296 | Layer(8 "unused") |
||
7297 | ( |
||
7298 | ) |