?

Log in

Это последний этап разработки и последний пост на тему "gEDA как начать работу". Принципиальная схема и перечень элементов уже готовы. Нужна еще кое-какая конструкторская информация: это форма и размеры платы, а также ограничения по высоте с обеих сторон платы. После ее уточнения можно создавать контур платы и размещать компоненты. Иногда контур делают в последнюю очередь, если нет ограничений на плату. После размещения компонентов проводят монтажные дорожки, соединяющие выводы компонентов между собой и переходными отверстиями (если они имеются на плате).

Наш случай требует размещения платы в коробке от стандартного выключателя. Размеры платы 55х55 мм, по четырем углам есть отверстия 3 мм для крепления на стоечки или опоры в коробке. Глубина коробки 50 мм, а высота над крышкой с клавишей или мембраной (кнопкой) 10 мм. Это и является ограничениями, которых нам необходимо придерживаться. Все компоненты с большой высотой надо перенести на обратную сторону платы. (Обратная сторона - это сторона, обращенная внутрь коробухи.) На передней или верхней стороне остаются: кнопка, микросхема, чип-резисторы и чип-конденсаторы. В общем, это не самый легкий случай, если речь идет о начинающих разработчиках, но вполне посильный.

Сначала нарисуем плату в слое Outline. Сделаем в ней отверстия под винты. На этом этапе координатная сетка настроена на шаг 1 мм.



Проще всего плату нарисовать так. Выберем начало координат, затем относительно них выберем точку 3,3 и вставим в нее переходное отверстие. Внешний диаметр нужно установить 3, а внутренний подогнать к нему вплотную. На самом деле, такие отверстия делаются иначе, это просто для наглядности. С левой стороны инструментом Arc делаем дугу, концы которой касаются воображаемого квадрата контуров платы. Выделяем и копируем дугу и отверстие в буфер. В меню буфера выбераем команду поворота на 90 градусов по часовой стрелке: Buffer | Rotate buffer 90 deg CW. Перенесем центр выделения в точку 52,3 и вставим. И так далее. Затем замкнем контур платы отрезками.

Теперь можно импортировать схему из файла ltimer.sch Все атрибуты footprint уже должны быть добавлены. Для импорта есть команда меню: File | Import Schematics где надо указать имя файла. Все комплектующие сразу будут вывалены на плату:



Обычно они попадают в середину рабочей области (размеры которой, кстати, тоже настраиваются), а у нас контур платы находится в уголке. Поэтому можно выделить все элементы и передвинуть их на плату.

Начинающих разработчиков, такой хаос, как на картинке выше, может обескуражить, но не все так страшно, как кажется. Во-первых, у нас всегда есть линии связи (rats) освежить которые, вернее, изображение которых, можно клавишей O. Как бы, и что бы, и куда бы мы не двигали, всегда можно проследить связи между компонентами. Изображение каждого слоя можно скрыть кликнув по нему в списке. Слои есть для меди, для краски (шелкография), для маски, для контактных площадок и для переходных отверстий.

Как элементы, так и их позиционные обозначения можно свободно двигать и вращать. Внимательно рассмотрите кнопки панели инструментов. Попробуйте растащить элементы по плате для получения более-менее внятной картины. Ваши страхи немного рассеятся.

Теперь можно подумать о том, как перенести большие элементы на обратную сторону платы. Это очень просто. Конечно, сначала надо выделить элемент. Затем просто нажать Shift-B. И он окажется с обратной стороны. Возможно, что он куда-то улетел и пропал из вида. Но ничего страшного, он остался в рабочей области. Элементы, принадлежащие обратной стороне, включая их контактные площадки, обозначаются белым цветом. Если они содержат штыревые (не-smd) выводы, то они видны без изменений, так как такие выводы, как мы помним, происходят от переходных отверстий (но ими уже не являются! И ведут себя по другому.).



Рисунок показывает, что часть элементов, по высоте больших 10 мм, перенесена на обратную сторону, и будет направлена в глубину коробки, где у нас есть запас по высоте. Кстати, переключаться между сторонами платы можно нажатием Shift-Tab, но для этого удобно, чтобы плата была расположена по центру рабочей области и не летала туда-сюда при перевертывании. Добившись чернового расположения:



можно попытаться переключить координатную сетку на более удобный масштаб, хотя бы и в mil единицах, и попытаться улучшить расположение элементов и надписей.



Можно отключать слой far side чтобы прятать элементы обратной стороны, если они мешают, но не стоит этим сильно увлекаться, потому, что можно упустить из вида важные вещи. Какие? А в том и дело, что сразу их не видно, а потом почти поздно, хоть начинай все с начала.

Начать можно с любой из дорожек. Главное условие - избегать лишних пересечений. Плату необязательно переворачивать, чтобы разводить с обратной стороны. Нижний слой называется bottom и имеет другой цвет. Ширину линий дорожек следует брать по величине тока, протекающего в цепи. Вообще, на этой плате в большинстве случаев подойдет стиль линий Power.

Если какая-то цепь имеет неочевидную трассу, то можно навести на нее мышку и нажать F. Тогда вся цепь будет показана зеленым цветом, что очень облегчает поиск. Уже разведенные дорожки полезно освежить клавишей O, при этом исчезнут неактуальные линии rats, "крысы разбегутся".



Контуры плат могут приводить к недоразумением с цепями. Например, на картинке выше хорошо видно, что некоторые элементы показаны оранжевым цветом:



Это признак ошибок в соединениях. И линии связей (rats) идут непонятно куда. Причина очень простая: край платы приходится как раз на площадки выводов. Это замыкает их. Нужно просто аккуратно выделить все, что относится к плате, а именно: ее контур и отверстия по углам, и немного перенести вправо. Нажав O мы увидим, что все ошибки исчезли:



Иногда возникает ситуация, когда дорожка окружена пересекающими ее другими дорожками такого же уровня. Как либо обойти ее невозможно. Пример показан ниже:



Тогда часть дорожки переносят на другую сторону платы:



Вид из слоя bottom:



Вид из слоя top:



Участок рядом с указателем перенесен в слой bottom при помощи первого переходного отверстия, там он проходит короткий путь до второго переходного отверстия и снова поднимается в слой top. В точности, как подземный переход.

Наконец, когда все дорожки разведены, плата приобретает вид:



Может быть, это и не самое идеальное решение, но оно будет работать. Если плату изготовить промышленным способом, то она будет выглядеть так:



В меню экспорта программы pcb (Export layout...) есть множество вариантов, как для промышленного изготовления, так и для метода утюга или фоторезиста. Для печати на принтере отлично подходит формат ps (или eps). Файл формата ps очень удобно править при необходимости в редакторе векторной графики Inkscape.

В ps чертежи платы выводятся с точнейшим соблюдением размеров. На всякий случай, в редакторе pcb есть меню калибровки принтера.

Для ручного изготовления платы можно сделать версию, в которой внешние размеры переходных отверстий и отверстий под выводы элементов немного увеличены. Это придаст прочности медным колечкам при сверлении отверстий, при котором их может свернуть сверлом в случае небольшой ширины меди вокруг. Сверление лучше всего производить в условиях, которые исключают соскальзывание или увод сверла в сторону. В общем, нужен небольшой станочек.

Если проблемы сверления являются значительными, то большую часть компонентов для неподвижных бытовых конструкций можно разместить как SMD. Даже элементы с выводами, и микросхемы в корпусе DIP. Только достаточно тяжелые и те, которые ограничивают паяльнику доступ, элементы придется паять в высверленные отверстия. Также стоит помнить о том, что даже если вы изготовите двухстороннюю плату, то у вас нет металлизации отверстий и это может разорвать цепь.
Для изготовления печатной платы крайне важна информация о посадочных местах компонентов (footprint). Это проекция на плоскость монтажа контуров элементов и их выводов, а также сведения о типе выводов: сквозное отверстие (via) или контактная площадка поверхностного монтажа (pad). Редактор pcb имеет более или менее обширные библиотеки распространенных посадочных мест, но часто приходится создавать пользовательские.

Редактор печатных плат, работающий с утилитами gEDA называется pcb. От других, значительно более известных, приложений, таких как как P-CAD (теперь Altium), его отличает очень большая простота использования. При этом он позволяет делать вполне профессиональные печатные платы. В pcb можно сразу импортировать файл схемы, если у каждого компонента имеется установленный атрибут footprint. Вот ими для начала и займемся.

Откроем схему ltimer.sch, которая была получена у нас в конце прошлого поста и добавим атрибуты всем элементам. Какие? Это увидите из дальнейшего.

gnetlist имеет возможность создать перечень элементов схем. В рабочем каталоге, куда надо закинуть ltimer.sch, создадим очень простой файл attribs всего с двумя строчками:

value
footprint

После этого выдадим команду:

$ gnetlist -g bom ltimer.sch -o ltimer.bom

В результате у нас должен образоваться такой файл:

refdes	value	footprint
F1	0.5A	fuse
C1	3300u	c_el
C3	3300u	c_el
C5	330u	c_el
R1	100	0805
S1	switch	btn
R3	100k	pot
R2	1k	0805
C2	0.1u	0805
U1	ne555	DIP8
T3	pin	P1
T2	pin	P1
T1	pin	P1
C6	0.68u	c_a
R5	180	0.5wa
D1	zen12	zen
D2	dg	dio
C4	0.1u	0805
VS1	triac	TO92
R4	300	0805

Разумеется, юниксоиды при помощи awk, perl или python могут расписать его получше, если число позиций занимает несколько страниц. Формат файла очень прост и понятен. В attribs можно добавить любые атрибуты (refdes добавляется по умолчанию).

Есть также GUI утилита gattrib, для массовой правки атрибутов, но она кажется не слишком удачно сделанной. Можно написать и скрипт для этих же целей: составлять списки атрибутов и управлять их видимостью, ведь формат файлов sch является открытым и хорошо документирован. Например:

*
* Перечень элементов
*
refdes value \footprint
R1     10k   ar1     
R2     1k    ar3
C1     \1uF  0805
C2     \10uF ca
. . .

Косая черта (или другой символ, или скобки) делает атрибут скрытым на схеме: в приведенном примере, в случае footprint скрыта сразу вся колонка, а в случае типов/номиналов скрыты только значения емкостей конденсаторов. Этот же скрипт может заменять gnetlist с опцией bom. Но это лишь идея, кому-то и gattrib покажется достаточно хорошим.

Сейчас представляется самым важным назначить атрибут footprint. Выбрать посадочные места можно из библиотек pcb. Кое-что подходящее у нас уже есть. Запустим pcb и получим элементарные навыки обращения с ним.



Интерфейс программы очень простой и понятный. Серый прямоугольник в окне - это "заготовка" платы. Ее очень легко можно масштабировать колесиком мыши и перемещать при нажатой правой кнопке мыши. Попробуйте сами.

С левой стороны список выбора активного слоя, ниже - кнопки инструментов, а еще ниже - круглые переключатели для выбора предустановленной ширины линии/дорожки. Все это можно настроить. Как и в gschem в pcb имеется "многостраничный" буфер обмена, который помогает работать со сложной правкой.

Библиотечные элементы выбираются командой I - появляется окно со списком и фильтром, очень похожее на то, что есть в gschem. Подберем, например, посадочное место под конденсатор C1. Это "банка", размером 16х25 мм (диаметр х высота). 16 мм - это 620 mil, тысячных долей дюйма (25,4 мм). В фильтре библиотеки пишем rcy300 (300 mil это радиус):



Пока ничего никуда не надо вставлять. Просто укажем значение RCY300P в качестве footprint для конденсаторов C1 и С3. Запишем пока в файл ltimer.bom в колонку footprint. Для C2 выберем RCY200P. Конденсатор C6 аксиальный, но скорее типа К73-17 с расстоянием между выводами 20 мм. Поищем в библиотеке acy800. Есть такой, запишем его. Резистор мощностью 0.5 Вт имеет расстояние между выводами 12-15 мм. Поищем элемент acy500. Переменный резистор R3 я выбираю BOURNS_3224W для поверхностного монтажа, потому, что у меня есть как раз такие несколько штук. Если у вас другие, то ничего страшного, мы очень скоро как раз перейдем к созданию своих посадочных мест. Это очень важная тема и ее никак нельзя обойти.

Таким образом, список материалов приобретает у нас пока вид:

ref val       footprint
---------------------------
F1  0.5A      FU ------- ??
T3  CONN1     P1 ------- ??
T2  CONN1     P1
T1  CONN1     P1
S1  switch    BT ------- ??
C1  3300u     RCY300P
C3  3300u     RCY300P
C5  330u      RCY200P
R1  100       0805
R3  100k      BOURNS_3224W
R2  1k        0805
C2  0.1u      0805
U1  LM555     DIP8
C6  0.68u     ACY800
R5  180       ACY500
D1  1N4742A   DO-41
D2  1N4004    DO-41
C4  0.1u      0805
VS1 BT131-600 TO92
R4  300       0805

В верхние строчки вынесены посадочные места, которые не удалось найти. Мы создадим их сами. В качестве разминки, для знакомства с редактором, создадим печатную плату с тремя впаянными на нее предохранителями. Я отдаю себе отчет в бессмысленности этой платы, но как ознакомительный пример - это то, что надо.

Начнем с пользовательских библиотек. Прежде всего, все посадочные места хранятся в файлах .fp (footprint) в каталогах библиотек. Кроме системных библиотек, могут быть указаны и пользовательские. В pcb это делается привычным для большинства пользователей образом. Надо указать путь в каталог с пользовательской библиотекой из меню File | Preferences... | Library



Конечно, это только пример. Вы можете выбирать свой путь в домашнем каталоге. А в данном примере библиотечный каталог fplib для посадочных мест, будет содержать недостающие модели.

Начнем с посадочного места под предохранитель. Пусть мы напаиваем его на плату, как smd-элемент. Этот вариант хорош тем, что не требует никаких держателей и сам предохранитель горит довольно редко. Начинать надо с геометрии компонента. Обычный предохранитель представляет собой цилиндр диаметром 5 мм и длиной 20 мм. Значит, центры площадок должны быть разнесены на 20 мм. Ширина площадок 5 мм. Получаются два квадрата 5x5 мм, разнесенные относительно центров на 20 мм.

Эти квадраты надо сделать на верхнем слое платы. Начнем с первого квадрата. Убедимся, что выбран слой top и настроим координатную сетку. Сейчас удобно ее переключить в миллиметры. Это можно сделать кнопкой в правом верхнем углу окна (по умолчанию там mil). Обнулим текущую сетку нажав комбинацию клавиш Shift-G несколько раз, пока в строке состояния не будет обозначено, что grid=0.0000 mm. Кстати, заодно и включим отображение сетки, выбрав из меню View флажок Enable Visible Grid. Затем установим шаг сетки равным аж 5 мм. Это делается нажатием клавиш Ctrl-G нужное число раз (удержанием при большом числе шагов) и смотрим на индикатор, чтобы не прозевать свою остановку.

После этого выполнить точнейшее построение будет раз плюнуть. Выбираем инструмент RECT и делаем первый квадрат в самом углу. Второй квадрат делаем на четыре квадрата правее. Переключаем шаг сетки координат на 2.5 мм, нажимая клавиши Shift-Ctrl-G. Теперь указатель попадает точно в центры квадратов. Можно было бы скопировать квадраты в буфер, но добавим им немного рисунка в слое шелкографии. Приучаемся сразу к точности! Вместо рисования линий от балды поставим задачу: обозначить предохранитель двумя линиями, отстоящими от каждого квадрата на 1 мм.

Для этого переключим слой на Silk (черный цвет). Координатную сетку переключим на 1 мм. Привяжем координаты к одной стороне квадрата следующим образом. Выберем команду меню View | Realign grid. Наведем указатель на угол левого квадрата - он прилипнет к нему - и кликнем. Координатная сетка привязана.

Выберем в инструментах команду Line и проведем линию в нужном месте. Затем повторим вторую линию:



После этого вернем шаг координатной сетки 2.5 мм и привяжем сетку к углу квадрата. Снова переключимся на слой Top и выделим оба квадрата и нарисованные линии. Это можно сделать, обведя объекты рамкой или кликая поочередно при нажатой клавише Shift. Установим курсор на центре первого квадрата (это важно!) и нажмем Ctrl-X. Элементы будут вырезаны в буфер.

Теперь вырезанное надо преобразовать в элемент. Это делается командой Buffer | Convert buffer to element. Можно попробовать вставить элемент в рабочую область, чтобы посмотреть, как он выглядит. Но сейчас самое важное - сохранить его в файле. Выберем команду Buffer | Save buffer elements to file. Сохраним его в файле FU.fp в каталоге fplib.

Теперь изготовим еще один элемент. Это монтажная точка со сквозным отверстием. Она будет использоваться для пайки внешних соединений. Она состоит из двух квадратных контактных площадок с переходным отверстием. Пусть сторона квадрата будет равна 4 мм, а отверстие посередине будет диаметром 1 мм.

Выберем инструмент Via (переходные отверстия). По умолчанию оно довольно маленькое. Клавишами Shift-V будем увеличивать его размер, следя за строкой состояния. Чтобы легче было следить за внешним размером в миллиметрах, начала в слое шелка нарисуем временные линии - квадрат со стороной 4 мм. Шаг координат надо установить 2 мм и центр квадрата должен быть одним из узлов координатной сетки. Увеличим внешний размер переходного отверстия до совпадения с квадратом. Удалим вспомогательные линии, чтобы они не мешали.

Затем увеличим размер внутреннего отверстия до 1 мм. Это лучше сделать выбирая команду меню Select | Change drilling hole of selected object | Vias + 10 mil несколько раз. (Сочетание клавиш Alt-V которое по умолчанию предусмотрено для увеличения внутреннего отверстия, может конфликтовать с сочетаниями оконного менеджера. У меня Xfce, так что мне стоило бы переписать конфиг и переназначить сочетание клавиш.)

Получить информацию о геометрии и принадлежности объекта можно, когда мышь находится над ним и мы нажимаем сочетание Ctrl-R. Так мы узнаем о диаметре внутреннего отверстия. Добившись нужного размера, копируем переходное отверстие в буфер и конвертируем в элемент. Сохраняем его в файле P1.fp

Оба созданных элемента будут доступны из библиотеки после выхода и повторного запуска pcb. Чтобы создать плату теперь достаточно вставить в рабочую область несколько "предохранителей", контактов и соединить их дорожками (инструментом Line) в слое Top. Обратите внимание: все выводы элементов строго пронумерованы! Это имеет очень больше значение для элементов, в которых недопустимо путать выводы, например, полярные конденсаторы, диоды, не говоря уже о транзисторах и микросхемах.

Если мы хотим, чтобы площадки под контакты были квадратными, то следует просто навести на площадку мышь и нажать клавишу Q. Файлы .fp - это обычные текстовые файлы и все элементы имеют определенные флаги. Если мы хотим, чтобы площадки были квадратными по умолчанию, то вместо:

Element["" "" "" "" 31496 31496 0 0 0 100 ""]
(
	Pin[0 0 15600 2000 16200 4000 "" "1" ""]

	)

файл P1.fp должен выглядеть так:

Element["" "" "" "" 31496 31496 0 0 0 100 ""]
(
	Pin[0 0 15600 2000 16200 4000 "" "1" "square"]

	)

Расположив элементы на плате, мы можем добавить надписи в слое Silk. Затем снова переходим в слой Top, выбираем стиль дорожек Power и проводим их согласно необходимой топологии. Если толщина дорожек нас не устраивает, то можно увеличить ее несколько раз нажимая на клавишу S.

Затем переходим в слой Outline и рисуем контуры платы. Плата должна принять примерно такой вид:



Если эту плату изготовить промышленным способом, то она будет иметь вот такой вид:



Теперь нам остается изготовить посадочное место под кнопку и можно будет двигаться дальше. Мы возьмем маленькую, так называемую "тактовую" кнопку, которую используют на пультах и небольших клавиатурах. Имея фрагмент ее чертежа:



расположим переходные отверстия строго по координатам, привязанным к размерным цепям чертежа, как можно точнее. Иначе при монтаже придется гнуть выводы и ломать их. Кстати, выводы кнопок обычно изготовлены из фосфористой бронзы с луженым покрытием, так что они довольно ломкие.

Вот так выглядит посадочное место под кнопку в редакторе pcb:



Линий, обозначающих кнопку в слое Silk, можно не делать, но обычно такие графические элементы помогают на сборочных чертежах платы, даже если плату изготавливают в кустарных условиях.

Делая это посадочное место сначала выберем шаг координат равным 0.5 мм. Переходное отверстие выберем, предварительно включив стиль разводки Fat. Нам нужно достаточно большое отверстие. Получив информацию о нем (Ctrl-R) мы видим, что внутренний диаметр отверстия меньше требуемого 0.8890 мм. Увеличим его на шаг (10 mil), как было описано выше. Диаметр получится чуть больше миллиметра, но это не так уж и плохо, за счет металлизации переходных отверстий их реальный диаметр становится меньше. Затем нужно увеличить и внешний диаметр меди, иначе пайка получится слабой, тем более, что это компонент, находящийся под переменной механической нагрузкой.

Это первое отверстие и, как вывод, оно будет иметь первый номер в последовательности. Можно установить в его центре относительные координаты 0,0. Для этого наведем мышь на центр отверстия и нажмем Ctrl-M. Появится маркер-крестик, и координаты будут отсчитываться относительно него. В строке меню справа есть две рамки. В левой из них и показаны относительные координаты в текущих единицах. Выделим и скопируем в буфер первое отверстие.

Второе, третье и четвертое отверстие легко разносятся со вставкой по имеющимся координатам согласно размерам из чертежа. Последнее отверстие потребует уточнения координат. Выберем шаг координат 0.25 мм и поставим маркер в центр прямоугольника, вершины которого лежат в центрах отверстий. Можно помочь себе, если включить в меню Settings 'All direction' lines а затем нарисовать крест по диагоналям в слое Silk. Установив маркер на перекрестие (два раза нажимаем Ctrl-M: первое нажатие выключает прежний маркер), убираем вспомогательные линии.

Последнее отверстие имеет теперь относительные координаты 0, -4.1 мм. Переключим координатную сетку на 0.05 мм и вставим последнее отверстие из буфера. Затем можно снова установить шаг сетки на 1 мм. Полученные отверстия выделим и скопируем в буфер. Перед этим установим курсор на центр первого отверстия. Конвертируем выделение в элемент и сохраним в файл BT.fp в каталоге fplib.

Принципиальную схему снабдим всеми атрибутами, которые перечислены у нас в самой последней версии списка материалов. Это можно сделать как в редакторе gschem, так и при помощи утилиты gattrib.

Получилось довольно много и пора заканчивать. Следующий пост будет последним в этой серии. Там плата будет окончательно разведена. Кроме того, мы увидим, как и в какие форматы можно экспортировать результат.
В прошлом посте таймер оказался немного подгоревшим, подавать его к столу рановато. На моей кухне случился небольшой заеб, то есть, слишком много тем для одного материала. Я не стал его проверять как следует. Поэтому здесь мы начнем с исправления косяков, затем получим окончательную схему всего устройства. Будет кое-что в смысле улучшения работы с проектом. И в конце поговорим о, так сказать, стратегиях симуляций, чем немного закроем тему.

Начнем с общего обзора. Вот как выглядит каталог проекта:


В подкаталогах находятся библиотеки: analog и digsim - символы элементов, sktlib - подсхемы и модели. Таким образом, имея достаточный набор пользовательских данных, можно работать на любом компьютере, где есть возможность использовать набор приложений gEDA. Не знаю, получится ли это на системе Windows если там сначала установить cygwin, но попробовать можно. Вероятно, кому-то это покажется удобным. Мне гораздо удобнее держать просто раздел на диске, где установлена Windows, для игрушек и некоторых случаев, когда нужна именно эта ось. Когда я загружаю Windows, то мне кажется, что я увижу слой пыли с палец толщиной, так редко я там бываю.

Файл gafrc - это конфигурация для всех утилит geda, если он находится в каком-либо каталоге, то, как говорил Лева Задов: "кому Лева друг - у того девятка на руках". Вот содержимое это файла:

( source-library-search "." )
( component-library "digsym" "My Digsym" )
( component-library "analog" "My Analog" )

В первой строке - указание искать библиотеки во всех подкаталогах текущего каталога. Вторые две строки - это явное указание редактору схем gschem, чтобы тот поместил указанные библиотеки в свой список для команды выбора компонентов. Конечно, gschem должен быть запущен из текущего каталога.

Файл sim - это исполняемый скрипт bash. Мы уже знакомы с ним, но это его новая версия, заслуживающая пары слов для обсуждения:

#!/bin/bash

# Скрипт для симуляции иерархических проектов
# сделанных в редакторе gschem.
# Использование:

# $ sim <файл1> [ <файл2> ... ] 

# Имя выходного файла: <файл1>.cir

m=${1%.*}

for i in $*
do
    list=$list" "${1%.*}
    shift
done

for i in $list
do
    cat $i.sch | awk '
/^source/{ print "comment=stub"; next }
{ print $0 }' > $i.t~
done
gnetlist -g spice-sdb -o $m.cir $(ls *.t~)
rm *.t~


# Пишем свою шапку:

cat << END > t
* $1.cir
*
*
*
END

# Расставим квадратные скобки в файле .cir

cat $m.cir | awk '
/^A.*adc *$/||/^A.*dac *$/{
    print $1" ["$2"] ["$3"] "$4; next }
/^A.*nand *$/||/^A.*nor *$/{ s = $1" ["
    for( i=2; i<NF-1; i++ ) s = s""$(i)" "
    s = substr( s, 1, length(s)-1 )
    print s"] "$(NF-1)" "$(NF); next }
/^[*]+/{
    next }
{   print $0; next }' >> t
mv t $m.cir

Новым здесь является то, что мы выделяем главное имя - имя выходного файла, и составляем список всех файлов из командной строи, убрав расширение. Так что, если вы укажете: sim file.sch, это не будет ошибкой. С другой стороны, конечно, тут ожидаются файлы .sch, а не какие-нибудь другие. Смысл и основная функция скрипта сохраняется - быть оберткой для gnetlist, придающей утилите недостающую функциональность. sim используется для расстановки квадратных скобок для обозначения массивов выводов (векторов) в цифровых элементах.

Совсем новой штукой у нас является известная каждому, системному и не очень, программисту утилита make. Она с большущим успехом может применяться не только для компиляции программ на С/C++ или ассемблере, для чего в основном и юзается, но с ее помощью можно делать очень многие непростые вещи, обходясь простым текстовым редактором. Для этого достаточно иметь в рабочем каталоге текстовый файл, называющийся просто makefile. "Просто Мюллер. Категорично и со вкусом."



Принцип работы make очень прост. На примере данного файла: make понимает, что test.cir - это главная цель, то, что надо сделать. Главная цель зависит от следующих файлов: ne555.cir comp.cir gain.cir и еще двух схем в рабочем каталоге. make читает makefile дальше и видит новые цели, а это одна или несколько зависимостей главной цели. У каждой из целей второго уровня есть своя (свои) зависимости.

Например, пусть дата/время последнего изменения файла ne555.sch 12:30, а файл главной цели был изменен в 12:29 или вообще, на доли секунды раньше 12:30. Что это значит? Логика очевидная - главная цель уже не соответствует реальному положению вещей, она изменилась, и ее надо переделать. Но сначала переделываются цели второго уровня. Если это ne555.sch, то сначала выполняются команды под строкой 9, затем выполняются команды первого уровня для исправленных зависимостей. В конкретном случае последовательность номеров строк команд следующая: 10, 11, 12, 7, 8.

Кроме целей-файлов, могут быть цели-действия. Например, если мы запустим make (это делается просто: make) но файлы не изменялись, то make так и напишет: 'test.cir' is up to date. Для этого и предусмотрена цель-действие go (это имя можете выбрать сами). Если make сообщает, что цель актуальна, то пишем: make go и выполняются команды в строке 23. Если мы захотим почистить проект от временных ненужных файлов, то даем команду: make cleanup и выполняется строка 21, но остальное выполняться не будет.

В таймере была ошибка с логикой. Вместо элементов И-НЕ должны были использоваться ИЛИ-НЕ. Вот схемы рабочей версии:

Файл power.sch - источники питания, тестовых сигналов, всяких кирпичей с директивами и опциями:



Здесь есть источник питания таймера и источник, работающий подобно кнопке, его сигнал посылается по узлу с именем in. UIC - это User Initial Conditions, иы используем их для того, чтобы в начале симуляции конденсатор времязадающей цепи был заряжен до напряжения источника питания, директива: .ic v(tr)=5 В этот лист схемы также включен файл ne555.cir, мы рассмотрим его чуть позже. Оба файла открыты в gschem и переключаться между ними можно клавишами PgUp и PgDn или командами меню. Файл ctrl.txt содержит "сценарий" того, что должен делать ngspice после загрузки файла.

*
* Команды для симуляции
*
.control
    run
    plot v(tr) v(out) v(in)
.endc

В файле test.sch находится схема одновибратора, собранного на 555. Здесь все более-менее ясно:



Сделав правый клик по "корпусу" таймера, и выбирая нужную контекстную команду, можно попасть в его внутреннее устройство, где были исправлены ошибки:



Из этого файла включается все остальное, что необходимо для его работы. Стоит заметить, что библиотечные файлы lib приходится включать с указанием относительного пути к ним. Используемые подсхемы открываются прямо из основного каталога. Сейчас их нет, но их создаст gnetlist, вызванный из файла makefile. Достаточно просто открыть терминал в рабочем каталоге и сразу можно писать в командной строке make. Результат получается немедленно:



На графике видно, что таймер сработал почти точно в десятиминутном интервале. Номинал 100k для резистора, заряжающего конденсатор, является достаточно большим. Больше брать нельзя, так как утечки по плате при повышенной влажности будут влиять на время срабатывания, и вообще, сделают работу таймера неустойчивой. Емкость в 5000 мФ можно набрать, не покупая дорогого ионистора. Конечно, желательно брать качественные конденсаторы, а не набранные с радиопомойки. Но выбор комплектующих еще впереди.

Было бы интересно посмотреть на время, необходимое для разряда конденсатора и "взвода" таймера:



Отчего оно зависит? От сопротивления в цепи открытого транзистора. Его модель npn1 из файла analog.lib:

*
* ==== модели диодов и транзисторов ====
*

* модели транзисторов
.model npn1 npn(is=1p bf=100 rc=10)

* модели диодов
.model diode d(is=3p cjo=5p)

является очень упрощенной. Сопротивление в цепи коллектора составляет 10 Ом (сопротивление открытого транзистора). У реальных транзисторов оно может быть меньше, к тому же поддается измерению в самой микросхеме, если открыть транзистор разрядной цепи нужной комбинацией входных сигналов. Как бы там ни было, время разряда конденсаторов было рассчитано ка 0.2 сек, а нажатие на кнопку продолжается полсекунды. Вот видите, какие "мелочи" можно обнаружить в симуляторе еще до сборки самого первого образца схемы?

Изменяя схему, можно легко получать ответы на любые вопросы. Например, чтобы измерить ток разряда конденсатора, достаточно только изменить схему, возможно, и файл управления симулятором, сохранить файл test.sch и выполнить make. Все остальное сделается само собой:



Теперь можно создавать полную принципиальную схему устройства. Она не нуждается в том, чтобы делать симуляцию. Все, что нам было нужно, мы уже узнали. Сложные схемы не симулируют. В крайнем случае, их описания поднимают на достаточно высокий функциональный уровень и создают схему из абстрактных устройств, в которых оставлено только самое необходимое. Что, например, делать с глобальной системой космической связи? Неужели все блоки и модули должны принимать участие в общих расчетах? Конечно нет. От всего остается пара-тройка источников и пара линий передачи с нагрузкой. В модели изучаются шумы и статистика ошибок для сигналов с различной модуляцией.

Если изучаются цифровые схемы, то начинка отлаженной единицы заменяется более простым устройством, выполняющим те же логические функции, для этого в XSPICE есть полный набор устройств: триггеры, счетчики, машины состояний, и даже память. Из всего этого можно собрать целый микропроцессор, способный выполнять код из настоящих файлов прошивки для настоящего камня.

Еще пару замечаний нужно сделать о времени и конвергенции. Время симуляции должно выбираться с оптимальным шагом. Не стоит гонять компьютер, особенно там, где процесс не испытывает резких изменений. Если у вас есть схема, работающая продолжительное время, то для изучения этого отрезка вам понадобится шаг покрупнее. Если в пределах этого интервала времени есть участки с какими-нибудь короткими импульсами, то его надо изучать с использованием мелкого шага и заданием начальных условий.

Цепи с сильными сигналами могут вызывать проблемы конвергенции (сходимости). Симулятор останавливается и отказывается считать дальше. В этом просто нет смысла. Это из-за того, что величины производных зашкаливают за пределы вещественного числового типа. Необходимо помнить, что очень коварной штукой, даже в схемах с малым сигналом, могут оказаться обычные источники токов и напряжений, индуктивности и даже конденсаторы, потому, что это идеальные модели.

Так, например, наш конденсатор в зарядной цепи таймера, если он реальный, имеет ток утечки и может вести себя немного иначе, чем в симуляторе. Поэтому производители и поставляют такие сложные spice-модели своих компонентов - они созданы на основе эквивалентных схем, точно описывающих их поведение и учитывающих паразитные параметры. В цепях с идеальными источниками, емкостями и индуктивностями следует использовать резисторы для ограничения токов.

Главный принцип при симуляции схем: получение наиболее точных данных при минимальных затратах времени и памяти. Это не всегда удается, но если специально не заботиться об этом, то неудаваться будет всегда.

Теперь к принципиальной схеме:



После всего сказанного, здесь практически нечего объяснять. Резистор R1 немного ограничивает ток, а кнопка S1 запускает таймер.

Эта схема может быть распечатана, но не только. Ее можно загрузить в редактор печатных плат pcb, чтобы без ошибок развести монтажные дорожки. Но это потребует кое-какой дополнительной информации и подготовки. Об этом в следующий раз. Мы вплотную подошли к теме печатных плат.
Перестроим наш проект таким образом, чтобы использовать иерархию схем. Поскольку тема изучения gEDA, в конечном счете, важнее проектируемой вещицы, мы сделаем несколько небольших отступлений. Иерархические схемы, это когда ты кликаешь символ компонента, а перед тобой открывается его внутреннее устройство. Если ты еще при этом можешь что-то изменить, вернуться обратно и получить новые данные, то это уже иерархическая симуляция. Мы увидим, что возможности автоматизации работы в бесплатном комплекте программ gEDA ничем не уступают коммерческим продуктам, если чуть-чуть поработать напильником и мозгами.

Начнем с того, что можно сделать весь проект в большой степени, если вообще не полностью, независимым от системных библиотек. Это очень полезно, если у нас большие расхождения, например, в графических обозначениях, пинах или мы используем что-то нестандартное. Немалая выгода есть и в переносимости с места на место. Весь проект можно перенести на другой компьютер, где есть программы gEDA, и работать там с правами обычного пользователя, как на собственном.

Создадим пустой каталог с любым именем. (Я создал hisim.) В этот каталог поместим файл с именем gafrc со следующим содержимым на языке, очень похожем на LISP:

( source-library "sktlib" )
( component-library "digsym" "My Digsym" )
( component-library "analog" "My Analog" )

И создадим три каталога с именами analog, digsim, и sktlib. Переименуем старый digsim, чтобы он стал невидимым из системной конфигурации. Это будет нам мешать.

Теперь мы можем запускать gschem и gnetlist из этого нового каталога и все утилиты увидят и прочитают файл gafrc. И мы увидим в окне статуса, что этот файл прочитан. Он обеспечит нам все необходимые пути к файлам. Таким образом, мы получим независимость от системных библиотек.

В каталог digsim скопируем все наши цифровые символы, а в каталоге analog сделаем что-нибудь еще. Например, пусть это будут символы для усилителя с одним входом, и символ таймера ne555. Последний мы можем нарисовать сами или скопировать lm555-1.sym из системной библиотеки и добавить к нему недостающие атрибуты.

Поскольку в схемах символы ссылаются друг на друга, то можно устроить путешествие по страницам подсхем. В этом и состоит иерархическая организация схем. Каталог sktlib будет содержать подсхемы, связанные с теми или иными символами, которые мы создаем.

Теперь закинем в hisim файл comp.sch, где у нас была подсхема компаратора. Проследим, чтобы пины были названы корректно, например: P1, P2, ... Пусть полежит.

Займемся другой схемой. Нам понадобится усилитель сигнала после триггера. Мы могли бы взять модель xspice gain, но на самом деле тут есть одна неприятная вещь. Модель gain "усилителя" выходного сигнала, которую мы можем взять из XSPICE-расширений симулятора, - неуправляемая. А нам нужно, чтобы выходное напряжение таймера не превосходило напряжения его питания. Поэтому мы можем собрать собственную модель на основе компаратора, которым занимались недавно. Для этого удалим один вход и перепишем условие для источника B1:



Подсхему gain тоже скопируем в каталог sktlib.

Создадим пустую схему test.sch. Нам придется создать свои символы, так как библиотечные имеют неудачные метки пинов. Поэтому откроем символ opamp-1.sym или opamp-2.sym и просто сохраним его копию в нашей библиотеке analog (не подумайте, что она имеет отношение к почтенной компании из Норвуда, Массачусетс. Просто там у нас "аналоговые" элементы, чтобы не смешивать их с цифровыми.) как comp.sym. Выправить файл можно вручную, в текстовом редакторе, правя нужные атрибуты и удаляя лишние.

Затем откроем этот же файл в gschem и убедимся, что все в порядке. Сохраним его копию как gain.sym и будем ее править. Надо удалить одну ногу на входе и переименовать/перенумеровать все пины.

Теперь начнем постепенно собирать модель таймера, проверяя ее работу на каждом этапе. Такой подход позволяет отловить ошибки в момент их возникновения. Первое, что нам нужно сделать, это обеспечить иерархию схем. Сделать это совершенно несложно. Вот тестовая схема из файла test.sch:



На ней источник питания, генератор треугольного сигнала и схемка тестируемого компаратора. Элемент X1 - это подсхема, и он имеет атрибут value=comp. Но у X1 есть еще один атрибут: source=comp.sch Если будете повторять схему, добавьте этот атрибут, а потом откройте файл test.sch в текстовом редакторе и сами найдите строку с этим атрибутом. Поэтому, когда мы кликнем по значку выделенного элемента правой кнопкой мыши и выберем соответствующий пункт:


Перед нами откроется его подсхема:



Точно так же мы можем перейти наверх командой Up. Те же команды можно найти в меню Hierarchy.

Файл comp.sch находится, должен находиться, в каталоге sktlib, библиотеке подсхем. Мы прописали это в файле gafrc в нашем рабочем каталоге.

Но что, если мы попробуем сгенерить нетлист: gnetlist -g spice-sdb -o test.cir test.sch? Мы получим:

*******************************
* Begin .SUBCKT model         *
* spice-sdb ver 4.28.2007     *
*******************************
.SUBCKT comp 
*==============  Begin SPICE netlist of main design ============
.include comp.cir
R2 0 1 1k  
R1 1 Vcc 1k  
X1/R4 2 out 100  
X1/R3 0 Vcc 8k  
X1/B1 2 0 V = V(in_p)-V(in_n) > 0 ? V(vcc)*0.9 : V(vcc)*0.1
X1/R2 in 0 100k  
X1/R1 1 0 100k  
V2 in 0 pwl( 0 0 0.1 5 0.2 0 )
.tran 1m 0.2
V1 Vcc 0 5V
.ends comp
*******************************

Но это совсем не то, что нам нужно. Это не будет работать. Здесь нарушен синтаксис SPICE. Попробуйте сами передать эту туфту ngspice. Смотреть схемы "в глубину", это здорово, но что делать с таким геморроем? gnetlist имеет еще кое-какие возможности по работе с иерархическими схемами, я еще не разобрался с ними. "Но я буду работать над этим. Пока у меня не получится." (лт. Коломбо)

Пока одним из решений, самым простым, будет убрать или заменить атрибут source. Тогда будет сгенерирована нормальная схема и все будет по-человечески. Но каждый раз кликать и править... а если еще таких подсхем косой десяток? Но мы ведь не пользователи Windows, которые годами униженно бьют поклоны разработчикам коммерческих продуктов. А потом радуются, как дети, получив долгожданную пиченьку. (Ура, бля! Вышла новая версия штанов. С пришитыми пуговицами!) Сейчас мы мигом все исправим. Для этого мы напишем простой скрипт:

#!/bin/bash

# Скрипт для симуляции иерархических проектов
# сделанных в редакторе gschem.
# Использование:

# $ sim <имя_файла>

# Файл указывается без расширения! Оно
# подразумевается как .sch

# Ищем в переданном файле строки source и
# фильтруем их во временном файле t. Мы
# подставляем допустимый, и ни на что не
# влияющий атрибут компонента.

cat $1.sch | awk '
/^source/{ print "comment=stub"; next }
{ print $0 }' > t
gnetlist -g spice-sdb -o $1.cir t
unlink t

Сделаем его исполняемым (по образцу sim из ранних постов по теме). И теперь совсем другое дело:

* gnetlist -g spice-sdb -o test.cir t
*********************************************************
* Spice file generated by gnetlist                      *
* spice-sdb version 4.28.2007 by SDB --                 *
* provides advanced spice netlisting capability.        *
* Documentation at http://www.brorson.com/gEDA/SPICE/   *
*********************************************************
*==============  Begin SPICE netlist of main design ============
.include comp.cir
R2 0 1 1k  
R1 1 Vcc 1k  
X1 1 in Vcc 0 out comp
V2 in 0 pwl( 0 0 0.1 5 0.2 0 )
.tran 1m 0.2
V1 Vcc 0 5V
.end

Файл comp.cir делается из схемы comp.sch и должен быть в рабочем каталоге. Поскольку схема comp.sch находится в библиотечном каталоге sktlib, то можно получить ее копию в рабочий каталог, получить файл comp.cir, и удалить ненужную копию - не оригинал из библиотеки! - comp.sch. В общем, должно действовать правило: из библиотеки берется только копия в рабочий каталог. Можно для каждой схемы .sch иметь файл .cir в библиотечном каталоге, это только вопрос организации хранения данных. Но, поскольку данные меняются, то появляется головная боль по поводу поддержания их в актуальном состоянии.

Это можно сделать при помощи утилиты make. Обычно ее используют для компиляции сложных проектов на языке C, но ее природа позволяет применить ее к чему угодно. Пока это идея только на заметку. Тем более, что еще есть над чем подумать в gnetlist.

Получим копию файла в текущий каталог и обработаем ее при помощи gnetlist:

$ cp sktlib/comp.sch ./
$ sim comp
. . .
$ rm comp.sch

Теперь можно запускать ngspice и изучать работу схемы. Убедившись, что компаратор работает, продолжаем дополнять схему новыми компонентами и связями:



Поскольку новых подсхем здесь не появилось, X2 не в счет, это дубликат, то нам остается только добавить библиотеку с цифровыми моделями digsim.lib. Снова делаем список узлов и расставляем квадратные скобочки для векторов:

* test.cir
*
* постепенная сборка таймера
*
A10 8 pullup
.include sktlib/digsim.lib
A6 [9] [q2] dac
A5 [7] [q1] dac
A4 [7 6] 9 nand
A3 [8 5 9] 7 nand
A2 [4] [6] adc
A1 [2] [5] adc
R3 0 3 5k  
X2 3 in Vcc 0 4 comp
.include comp.cir
R2 3 1 5k  
R1 1 Vcc 5k  
X1 in 1 Vcc 0 2 comp
V2 in 0 pwl( 0 0 0.1 5 0.2 0 )
.tran 1m 0.2
V1 Vcc 0 5V
.end

Испытываем работу "макета":



Пока все идет хорошо. Добавим инвертор к триггеру, как того требует логика 555.



Здесь мы добавим еще один сигнал reset, и ограничим ток в идеальных элементах резистором. Получим новый список соединений и определим там векторы. (Пора бы уже автоматизировать эту нудную работу.) Схема работает, но ее логика не совсем правильна.



Добавим еще один инвертор на выходе трехвходового элемента И-НЕ:


Теперь получаем нужный результат:



Графики показывают, ради чего, собственно, была изобретена схема 555. Это очень хороший, стабильный триггер Шмитта, с вспомогательными цепями, прекрасно подходящий для промышленных систем автоматики, которые работают в нелегких условиях, и по питанию, и по температуре. Неудивительно, что для этой схемы существует огромное количество приложений.

От выхода q1 должна работать разрядная цепь. Это транзистор с открытым коллектором. Также необходимо еще раз инвертировать сигнал от данной точки и усилить его простым усилителем с одним входом. Тогда таймер, наконец, заработает как функциональное устройство.

Но пора внести некоторые усовершенствования. Наш небольшой опыт с элементами вида A уже подсказывает несколько правил для несложного парсера, при помощи которого можно расставлять квадратные скобки:

1. Цифровые элементы начинаются с A.
2. Заканчиваются на adc, dac, nand (nor), not.
3. Векторов для adc и dac всегда два по одному.
4. Элемент nand (nor) имеет только 1 вектор на входе.
5. not всегда скалярный.
6. Число входов nand (nor) всегда можно определить.

По этим правилам можно написать скрипт. Вернее, дописать sim, чтобы он экономил нам драгоценные минуты. Возьмем awk и напишем:

#!/bin/bash

# Скрипт для симуляции иерархических проектов
# сделанных в редакторе gschem.
# Использование:

# $ sim <имя_файла>

# Файл указывается без расширения! Оно
# подразумевается как .sch

# Ищем в переданном файле строки source и
# фильтруем их во временном файле t. Мы
# подставляем допустимый, и ни на что не
# влияющий атрибут компонента.

cat $1.sch | awk '
/^source/{ print "comment=stub"; next }
{ print $0 }' > t
gnetlist -g spice-sdb -o $1.cir t

# Расставим квадратные скобки в файле .cir

cat $1.cir | awk '
/^A.*adc *$/||/^A.*dac *$/{
    print $1" ["$2"] ["$3"] "$4; next }
/^A.*nand *$/||/^A.*nor *$/{ s = $1" ["
    for( i=2; i<NF-1; i++ ) s = s""$(i)" "
    s = substr( s, 1, length(s)-1 )
    print s"] "$(NF-1)" "$(NF); next }
/^[*]+/{
    next }
{   print $0; next }' > t
mv t $1.cir

В этом файле код не на все случаи в жизни, а только на то, с чем мы здесь сталкивались. Но он работает, можете проверять его сколько угодно. При случае можно расширить список шаблонов и внести добавления в алгоритм, если это потребуется. Только что я потратил несколько минут и посмотрел на описания цифровых и гибридных моделей. Результаты обнадеживают. Больших проблем с квадратными скобками не предвидится.

Но вернемся к схеме. Добавим в нее разрядную цепь на транзисторе и еще один инвертор. Тогда схема подрастет и станет не очень обозримой. Тогда можно разбить схему на две страницы. По именам узлов gnetlist догадается, что надо сделать, если передать ему несколько файлов. Для этого надо слегка переделать скрипт, чтобы передавать ему произвольное число файлов схемных страниц из командной строки:

#!/bin/bash

# Скрипт для симуляции иерархических проектов
# сделанных в редакторе gschem.
# Использование:

# $ sim <файл1> [ <файл2> ... ] 

# Файл(ы) указывае(ю)тся без расширения! Оно
# подразумевается как .sch

# Имя выходного файла: <файл1>.cir

# Ищем в переданном файле строки source и
# фильтруем их во временном файле t. Мы
# подставляем допустимый, и ни на что не
# влияющий атрибут компонента.

for i in $*
do
    cat $i.sch | awk '
/^source/{ print "comment=stub"; next }
{ print $0 }' > $i.t~
done
gnetlist -g spice-sdb -o $1.cir $(ls *.t~)
rm *.t~

# Пишем свою шапку:

cat << END > t
* $1.cir
*
*
*
END

# Расставим квадратные скобки в файле .cir

cat $1.cir | awk '
/^A.*adc *$/||/^A.*dac *$/{
    print $1" ["$2"] ["$3"] "$4; next }
/^A.*nand *$/||/^A.*nor *$/{ s = $1" ["
    for( i=2; i<NF-1; i++ ) s = s""$(i)" "
    s = substr( s, 1, length(s)-1 )
    print s"] "$(NF-1)" "$(NF); next }
/^[*]+/{
    next }
{   print $0; next }' >> t
mv t $1.cir

Опять вернемся к схеме, на этот раз окончательно. Часть компонентов, а именно вспомогательных, всякие источники, генераторы, кирпичи с директивами и опциями, можно выделить и скопировать командой Y,C. Затем создадим новый лист схемы, назовем его, допустим, power.sch и вставим скопированное командой Y,P. Сохраним. gnetlist сам разберется с соединениями, если мы присвоили им имена. Надо лишь передать ему два файла: test.sch и power.sch

Для этого и был переписан скрипт. Кто разбирается в программировании для оболочки UNIX, тот уже все понял. Остальным нужно иметь в виду, что в конечном счете формируется вот такая командная строка: gnetlist -g spise-sdb -o test.cir test.t~ power.t~ Это уже обработанные файлы test.sch и power.sch, в которых мы подавили мешающий атрибут source. Теперь почти все делается на автомате.

Схемы выглядят так, power.sch:



и test.sch:



Цель этого этапа посмотреть, что будет на транзисторе. Мы получим этот результат последовательностью команд:

$ sim test power
...
$ ngspice test.cir

и дальнейшим диалогом с ngspice.

Простая модель транзистора находится в библиотеке analog.lib, в которой есть и модели comp и gain (закомментированные звездочками):

*
* ==== библиотека нецифровых моделей ====
*

* компаратор
*.SUBCKT comp in_p in_n vcc vdd out 
*R4 1 out 100  
*R3 vdd vcc 8k  
*B1 1 vdd V = V(in_p)-V(in_n) > 0 ?
*+ V(vcc)*0.9 : V(vcc)*0.1
*R2 in_n vdd 100k  
*R1 in_p vdd 100k  
*.ends comp

* усилитель
*.SUBCKT gain in vcc vdd out 
*R3 1 out 10  
*R2 vdd vcc 8k  
*B1 1 vdd V = V(in)*5 > V(vcc)*0.9 ? V(vcc)*0.9 :
*+ V(in)*5 < V(vcc)*0.1 ? V(vcc)*0.1 : V(in)*5
*R1 in vdd 100k  
*.ends gain

* модели транзисторов
.model npn1 npn(is=1p bf=100)

* модели диодов
.model diode d(is=3p cjo=5p)

Поскольку в схемы могут быть внесены изменения, то лучше было бы под конкретные проекты получать копии из библиотек в рабочий каталог. Но любая стандартизация - это результат длительного опыта, так что не стоит спешить тут с окончательным решением.

Последний шаг на пути к таймеру - это добавление каскада усиления выхода q. Поскольку на выходе A11 будет минимум 0.7 В, то усилитель с коэффициентом усиления 5 даст 3.5 В, что нам никак не подойдет. Мы могли бы установить еще пару диодов на выход элемента A11, как это сделано для транзистора. Но в таких случаях гораздо проще добавить смещение в формулу для выходного сигнала. И схема от этого упростится, и симулятору будет проще делать расчеты.

Вставляем gain, он получает атрибут source=gain.sch. Его схему надо немного переделать. Выражение для источника B1 выглядит слишком уж длинным. Поэтому немного упростим его. Вот способ сделать это:



Источник B2 воткнут в землю, и его потенциал висит в воздухе. На самом деле это просто способ ввести функцию, заданную уравнением в файл SPICE. Независимая переменная тут v(in) - входное напряжение, значение функции v(a) - смещенное и усиленное напряжение. Прежний B1 теперь играет роль лишь ограничителя напряжения. Добавляя источники B, заданные уравнением, можно сделать очень многое.

Кстати, вот еще важное замечание. Наши подсхемы могут работать как схемы с плавающим потенциалом. Сейчас они привязаны к земле, для простоты. Если вам когда-нибудь захочется симулировать схему, скажем, драйвера полумоста находящегося на высокой стороне, то в этом случае в аналогичной схеме вместо V(vcc) придется писать V(vcc)-V(vdd) что лишь немного усложняет выражения.

Наконец, таймер готов. Он ощипан и уже лежит в кастрюле. Сейчас мы его сварим и останется только подать:



* ne555.cir
*
* Таймер 555
*
.include digsim.lib 
.include analog.lib
.include comp.cir
.include gain.cir
.SUBCKT ne555 vdd 5 22 17 2 1 20 vcc 
X3 15 vcc vdd 22 gain
D1 21 19 diode 
R5 vdd 19 1k  
R4 13 21 400  
A9 [13] [18] adc
Q1 20 19 vdd npn1 
A10 18 14 not
A6 9 12 not
A5 [17] [16] adc
A2 16 10 not
A11 [14] [15] dac
A8 [12] [13] dac
A7 [9 8] 11 nand
A3 [10 7 11] 9 nand
A4 [6] [8] adc
A1 [3] [7] adc
R3 vdd 4 5k  
X2 4 5 vcc vdd 6 comp
R2 4 2 5k  
R1 2 vcc 5k  
X1 1 2 vcc vdd 3 comp
.ends ne555

Определенные неудобства вызывает нумерация пинов. Ведь gnetlist'у это абсолютно похер. В связи с этим возникает задача: описать алгоритм перестановки номеров на уже имеющемся их множестве. Мы берем первый (логический)пин девайса и смотрим, как он называется? Он называется vdd. Его всюду надо заменить на 1, а 1, соответственно, на vdd. Это не нарушит схему. Затем берем второй, и так далее. В конце, так как контекст имен уже совершенно безумен, хотя схема правильная, мы заменяем имена на номера, добавляя их к последнему и самому старшему. Это задачка по программированию, для профилактики склероза и маразма.

Задача поддержания работающей, не геморройной иерархии, она же "вертикаль", в проекте - это вопрос отношений на множестве файлов. Обрабатывающие скрипты (правила игры) должны быть логично привязаны к этой системе отношений. Тогда у разработчика будут развязаны руки и он сможет легко править схемы и модели, внося изменения на любую глубину.

С другой стороны, хорошо отлаженная модель не нуждается в бесконечных правках. Тогда можно сделать более горизонтальные отношения между моделями, но за счет некоторого дублирования кода и описаний. Ведь теперь каждый компонент содержит в себе все схемы и модели и имеет только внешнюю шкурку-символ. Его внутреннее описание становится недоступным, а сам он сложнее. Доверять ему становится рискованней, нужен больший опыт работы с ним.

Ладно, пусть таймер пока остывает, а в следующем посте будем подавать его к столу. Да и модель симистора добавим к библиотеке. Наконец, мы окончательно разберемся со схемой, а если повезет, внесем больше порядка в работу с проектами.

Близится время, когда мы возьмемся за разводку платы в редакторе pcb, и займемся темой посадочных мест - созданием своих компонентов и использованием их из системных библиотек, довольно обширных. Но, к сожалению, не всегда содержащих в точности необходимый компонент. Поэтому и приходится создавать свои.
В предыдущем посте мы дошли до схемы очень простого цифрового устройства. gnetlist показал нам кукиш и сейчас мы заставим его слушаться. Получив список соединений, будем подготавливать модели, управляемые событиями. Такими событиями могут быть тактовые сигналы часов, изменения логических состояний цифровых моделей, события от мостов типа аналог-цифра при смешанной симуляции, а также данные из файлов. Возможности симуляции ограничены только доступной вам памятью, которой в современных ПК и ноутбуках более, чем достаточно, для подобных целей.

Сначала разберемся с проблемой gnetlist. Почему он не хочет генерить нетлист? Ведь мы используем вполне законные префиксы для компонентов. Ответ можно усмотреть в диагностике, которую он выводит. Мы сделали наши символы доступными редактору gschem, но с gnetlist все обстоит по другому, он не может найти файлов. Вот что нам нужно, в принципе, сделать для решения проблем:

1. Поместить каталог с символами в каталог с системными библиотеками символов.
2. Подправить один из конфигурационных файлов.
3. Удалить ставший ненужным файл gschemrc из нашего рабочего каталога.

Вместо копирования каталога с символами в системный каталог, можно создать в последнем символьную ссылку на сам каталог. Это работает и это очень удобно. Мы можем править наши символы в любой момент, без прав админа. Но сначала эти права нам понадобятся (мы начинаем выполнять второй пункт). Запустим терминал и введем команду:

$ sudo scite /usr/share/gEDA/gafrc.d/geda-clib.scm
[sudo] password for ...:

Если у вас другой любимый редактор, gedit, например, или vim, указываете его. В файле, который открывается в редакторе, необходимо добавить строки, отмеченные номерами 18 и 19 на следующем снимке экрана:



Мы просто добавили данные для индексации моделей элементов, которая используется всеми утилитами пакета geda по стандартному соглашению разработчиков. Теперь gnetlist гарантированно увидит наш каталог, если он найдется по указанному пути. Сохраним данные и закроем редатор.

Теперь выполним вторую часть плана. Выполним еще одну команду:

$ sudo ln -s /usr/share/gEDA/sym /home/user/ваш-путь/symlib

В системном каталоге sym появится ссылка на каталог в домашнем каталоге пользователя user (это вы, разумеется, с поправкой на ваше имя в системе). Последняя команда также выполняется с административными привелегиями. После этого можно выйти из терминала.

И теперь можно удалить файл gschemrc из нашего рабочего каталога. Если нам когда-нибудь понадобится дополнительная конфигурация для gschem в каком-нибудь конкретном проекте, то мы будем знать, как это делается: просто создается файл gschemrc в рабочем каталоге. Пока он нам не нужен.

Таким способом можно добавить столько каталогов с компонентами, сколько вам нужно.

Теперь можно продолжать. Сейчас нам понадобится библиотека цифровых моделей. Опция XSPICE, скорее всего, была уже включена в компиляцию пакетов deb или rpm в репозиториях. Поэтому нам не придется компилировать ngspice из исходников. Поэтому мы можем использовать все кодовые модели: аналоговые, цифровые и мосты.

Даже для самой простой цифровой симуляции нам понадобятся "костыли" для привязки логических уровней к представляющим их напряжениям этих самых уровней. Иначе мы не сможем получить данные из цифровой симуляции. ngspice не может работать с абстрактными логическими величинами. Таким образом, цифровые модели - это лишь своеобразный способ "сжатия данных".

Поэтому мы немного расширим схемку из предыдущего поста, вот таким образом:



Элементы A5...7 это "ЦАП" для симулятора, эти самые костыли. Как разобраться с их графикой, вам уже известно. А инициализированы они так:

A/D: pinseq=1 pinnumber=1 pinlabel=A pintype=in; pinseq=2 pinnumber=2 pinlabel=D pintype=out; device=ADC; refdes=A?

D/A: pinseq=1 pinnumber=1 pinlabel=D pintype=in; pinseq=2 pinnumber=2 pinlabel=A pintype=out; device=DAC; refdes=A?

Разобравшись с назначением этих элементов, добавим новую библиотеку (digsim.lib):

*
* ==== библиотека цифровых моделей ====
*

* интерфейс аналог/цифр.
.model dac dac_bridge(
+ out_low = 0.7
+ out_high = 3.5
+ out_undef = 2.2
+ input_load = 5p
+ t_rise = 50n
+ t_fall = 20n )

* интерфейс цифр./аналог
.model adc adc_bridge(
+ in_low = 0.7
+ in_high = 3.5
+ t_rise = 50n
+ t_fall = 20n )

* резисторы подтяжки к земле и питанию
* они же низкий и высокий логич. уровни
.model pullup   d_pullup(load = 20p)
.model pulldown d_pulldown(load = 20p)

* инвертор
.model not d_inverter(
+ rise_delay = 1n
+ fall_delay = 1n
+ input_load = 1p )

* элемент nИ-НЕ
.model nand d_nand(
+ rise_delay = 1n
+ fall_delay = 1n
+ input_load = 1p )

* элемент nИЛИ-НЕ
.model nor d_nor(
+ rise_delay = 1n
+ fall_delay = 1n
+ input_load = 1p )

* набор двоичных векторов (цифровых данных)
.model vector d_source(input_file = "data.txt")

Смысл параметров моделей очень простой. На примере самой первой: out_low - напряжение низкого уровня, которое было бы на реальном устройстве логики (ТТЛ 5В), out_high, как нетрудно догадаться, высокий уровень. out_undef - напряжение неопределенного уровня, когда имеется "звон", неприятная штука, связанная с неправильным проектированием логических схем. Остальные параметры. input_load - это емкостная нагрузка на цифровой пин элемента. t_rise и t_fall это понятно, время нарастания и спада уровня.

Параметры остальных моделей имеют аналогичный смысл. Собственно говоря, уже из названия видно, что это за параметры, а кто хотя бы не может свободно читать по-английски в наши времена, тот, ящетаю нихера ниграматный. Откуда же еще черпать информацию?

Разумеется, в нашей библиотеке не все модели XSPICE, но начало положено.

Файл для двоичного вектора с именем data.txt:

*время 0  1
0.0    0z 0z
0.1    0s 0s
0.2    1s 0s
0.3    0s 1s
0.4    1s 1s
0.5    0s 0s

Теперь можно запускать gnetlist и получать файл digsim.net Он показан ниже, но в отредактированном виде. Изменения не слишком велики, но очень важные:

. . . шапка

*vvvvvvvv  Included SPICE model from digsim.lib vvvvvvvv
*
* ==== библиотека цифровых моделей ====
*

. . . содержание библиотеки (см. выше)


*^^^^^^^^  End of included SPICE model from digsim.lib ^^^^^^^^
*
*==============  Begin SPICE netlist of main design ============
A7 [3] [c] dac
A6 [2] [a] dac
A5 [1] [b] dac
.INCLUDE digsim.lib
.tran 0.1s 0.5s
A2 [2 1] 3 nand
A1 [1 2] vector
.control
	run
	plot v(a) v(b)+5 v(c)+10
.endc
.end

Очень важные элементы в конце файла - квадратные скобки, пары квадратных скобок. Они ограничивают векоры, которые конечно, могут быть и единичными. Пин 3 элемента nand, с другой стороны, НЕ является вектором, это скаляр, как значение логической функции. В файле руководства по ngspice, который легко и погуглить, и пояндексить, все пины всех встроенных моделей описаны.

В секции .control симулятор запускается, и рисует три интересующих нас графика, а чтобы они не накладывались друг на друга и не было непонятной хуетени, мы слегка сдвигаем их вверх по оси ординат. Запускаем симулятор командой ngspice digsim.net и должна появиться диаграмма:



Мы разделили полсекунды на 5 частей при помощи data.txt. В каждой из этих частей "система" находится в своем состоянии. В первой части элемент A1 просто отключен - 0z - от логического элемента. Во второй части на входах элемента устанавливаются низкие урони. Дальше следим и записываем все в таблицу истинности элемента 2И-НЕ:

a b c
-----
x x 1
0 0 1
0 1 1
1 0 1
1 1 0
0 0 1

Как можно видеть, для конъюнкции с инверсией ошибок нет. Так же можно испытывать и все остальные логические функции. Основы цифровой симуляции при помощи ngspice заложены.

Теперь эту же схему постараемся развить в цифровую начинку таймера 555. Там стоит RS-триггер, имеющий входы R и S, один инверсный вход R, и два выхода, прямой и инверсный. Для тестирования нам понадобится вектор из трех бит. Мы можем просто сделать еще один элемент, подобный предыдущему, с четырьмя битами (бог любит троицу, но вычислительная техника любит двоицу и ее степени) и переписать файл data.txt Заодно поинтересуемся, что бывает с неподключенными пинами.

Возьмем даташит на таймер NE555 (у меня SE555, а он эквивалентный). Там есть его функциональная схема:



Ну что, быстро создать трехвходовый элемент 3И-НЕ, используя 2И-НЕ как шаблон, это же как два пальца...

Создадим новую схему:



Рамка из штрихованых линий просто ограничивает новую схему для наглядности. Один из пинов четырехбитового "источника" не присоединен ни к чему, что, вообще говоря, считается ошибкой. Но об этом немного ниже.

Новый файл data.txt с тестовыми векторами:

*время nR R  S
* nR отключен
0.0    0z 0s 0s
0.1    0z 1s 0s
0.2    0z 0s 1s
0.3    0z 1s 1s
* nR низкий уровень
0.4    0s 0s 0s
0.5    0s 1s 0s
0.6    0s 0s 1s
0.7    0s 1s 1s
* nR высокий уровень
0.8    1s 0s 0s
0.9    1s 1s 0s
1.0    1s 0s 1s
1.1    1s 1s 1s
1.2    1s 0s 0s

Теперь создаем список соединений для новой схемы:

. . . шапка, содержимое библиотеки

*^^^^^^^^  End of included SPICE model from digsim.lib ^^^^^^^^
*
*==============  Begin SPICE netlist of main design ============
A2 1 4 6 2 nand
A4 5 4 3 unconnected_pin-1 vector
A3 5 6 not
A9 2 Q dac
A8 1 nQ dac
A7 5 nR dac
A6 3 S dac
A5 4 R dac
.INCLUDE digsim.lib
.tran 0.1 1.2
A1 3 2 1 nand
.end

Этот список соединений сложнее предыдущего, и нуждается в важных пояснениях. То, что gnetlist пометил как неподключенный пин, следует обозначить как NULL, чтобы не возникало ошибки в симуляторе. В остальном достаточно правильно расставить квадратные скобки, чтобы обозначить векторы, и не захомутать в них скаляры. Скалярами являются значения логических функций и вход элемента НЕ. Остальное - векторы.

Неплохо было бы написать скрипт, которому gnetlist передает данные по конвейеру и который пишет готовый файл. Сам gnetlist под цифровую симуляцию не заточен, к сожалению. Но, прежде чем мы сможем написать такой скрипт, необходимо будет как следует формализовать правила, по которым он будет парсить входные строки. Это может оказаться не очень простым делом, либо будет связано неудобными ограничениями.

Пока перебьемся ручной правкой. Для наших текущих целей этого будет вполне достаточно:

*==============  Begin SPICE netlist of main design ============
A2 [1 4 6] 2 nand
A4 [5 4 3] null vector
A3 5 6 not
A9 [2] [Q] dac
A8 [1] [nQ] dac
A7 [5] [nR] dac
A6 [3] [S] dac
A5 [4] [R] dac
.INCLUDE digsim.lib
.tran 0.1 1.2
A1 [3 2] 1 nand
.control
	run
	let nR=V(nR)
	let R=V(R)+5
	let S=V(s)+10
	let Q=V(Q)+15
	let nQ=V(nQ)+20
	plot nR R S Q nQ
.endc
.end

Мы расставляем квадратные скобки в соответствии с имеющимися векторами и "отключаем" неиспользуемый пин. Секция .control поможет быстро нарисовать понятные графики.

Все готово к запуску. Запускаем:



Эта диаграмма не очень похожа на таблицу истинности. Чтобы привыкнуть к такому представлению, можно представить себе воображаемые нули и единицы на каждом такте. Повернем картинку, чтобы она выглядела в большей степени похожей на таблицу.



 вход    выход
-------  -----
S R  nR  Q nQ
0 0  x   1 1
0 1  x   0 1
1 0  x   1 0
1 1  x   1 0
0 0  0   1 1
0 1  0   0 1
1 0  0   1 0
1 1  0   1 0
0 0  1   1 1
0 1  1   1 1
1 0  1   1 0
1 1  1   1 0
--------------

Так должна, по идее, вести себя логика в таймере 555. Правильно это или нет выяснится, если мы соберем таймер полностью и снова испытаем его, перебрав все сигналы на его входах. Окончательный ответ можно получить, взяв несколько микросхем и испытав их на простом стенде, который можно собрать на коленке: несколько резисторов, источник питания 5 В (заряжалка от мобильника или батарейка на 5-9 В), пара светодиодов.

Пост опять получился большим, поэтому окончательную сборку модели таймера мы оставим на следующий раз.
В этой записи будем делать таймер. Поскольку он состоит из нескольких функциональных частей, то их тоже придется создавать. Каждой из них соответствует своя подсхема имеющая свое поведение. Кстати, с подсхемами мы тоже кое-что сделаем в сторону улучшения. Мы должны сделать простую, но для наших целей достаточно реалистичную модель. Таймер 555 очень интересен тем, что в нем сочетаются аналоговые и цифровые компоненты. В симуляторах с этим сочетанием могут возникнуть проблемы.

Все дело в различной структуре данных для выполнения аналоговой и цифровой симуляции. Для аналоговой симуляции используются вещественные переменные типа double из 8 байт. Для цифровой симуляции это было бы чудовищным расточительством. Здесь вообще хватит одного бита, ведь каждая переменная имеет только два логических состояния. Но ngspice обещает справиться с этим. Посмотрим.

Начнем с аналогового устройства, компаратора. Это разновидность дифференциального, скорее операционного, усилителя без обратных связей. Он усиливает разность входных напряжений и очень чувствителен. Его выходной сигнал скачком изменяется от минимального значения до максимума, если разность сигналов положительна, или наоборот.

Компаратор оправдывает свое название тем, что на один его вход подают опорный сигнал, а на другой исследуемый. Как только исследуемый сигнал проходит опорный уровень, состояние выхода компаратора резко меняется.

Нашей целью будет создать простой компаратор. Мы могли бы собрать его как схему на транзисторах, но зачем? Куда более простая схема на моделях B-типа прекрасно справится. Как обычно, мы начнем с подсхемы, которую запустим как маленький самостоятельный проектик. Очень быстро он превратится в настоящую подсхему и мы закатаем его в нашу библиотеку. Назовем схему компаратора comp.sch и начнем рисовать его схему. Рамку, конечно, тоже лучше удалить, чтобы не мешала масштабировать схему целиком.

Совет. Если вы уже много чего нарисовали, то не расстраивайтесь. Лист зумится очень здорово. Выделите все, кроме рамки, передвиньте в сторону. Снимите выделение, выделите рамку целиком. Удалите. Выделите и задвиньте в самую середину вашу схему. Если что-то пошло не так, всегда можно выполнить команду отмены U, или даже несколько, и повторить неудачные действия.

Вот так выглядит настоящая подсхема в редакторе gschem:



До этого мы брали только самый минимум, чтобы быстрее получить результаты, а теперь добавляем остальное. Наша схема реализует самую основную функцию компаратора - сравнивать сигналы. Он ведет себя приблизительно так, как и должен настоящий, а для наших целей этого вполне достаточно.

В этой схеме мы используем специальные соединители для подсхем. Также добавлен новый компонент A1. Эти штуки можно найти в библиотеке:



С ними gnetlist создает не простую схему, а что-то более интересное:



на что не мешает посмотреть:

*******************************
* Begin .SUBCKT model         *
* spice-sdb ver 4.28.2007     *
*******************************
.SUBCKT comp in_p in_n vcc vdd out 
*==============  Begin SPICE netlist of main design ============
R4 1 out 100  
R3 vdd vcc 8k  
B1 1 vdd V = V(in_p)-V(in_n) > 0 ? V(vcc)*0.9 : V(vcc)*0.1
R2 in_n vdd 100k  
R1 in_p vdd 100k  
.ends comp
*******************************

Тут можно заметить, что пины обозначены именами узлов, которые к ним присоединены. Если мы уберем имена, то получим простую нумерацию выводов. Компонент A1 инициализирован так: model-name = comp, file = comp.sch

Теперь о работе самой схемы. Она вся в условном выражении, которое определяет источник B1. Если на входе "+" компаратора уровень выше, чем на входе "-" - выходное напряжение почти близко в напряжению питания, иначе оно близко к нулю, но не становится равным ему. Потому, что мы используем однополярное питание. Мы не моделируем быстродействие, частично моделируем потребляемый ток. То есть, берем то, чего будет достаточно. Зачем нам делать избыточные вычисления и тормозить работу?

После того, как мы создали подсхему c начинкой компаратора, создаем испытательную схему в файле comp-test.sch:



В качестве символа для компаратора вполне подойдет обычный операционный усилитель. Поэтому выберем в библиотеке элемент op (opamp-1.sym). Обозначим его просто X1, ведь это подсхема и синтаксис SPICE этого требует. Атрибуты model-name и file инициализируем так же, как и в предыдущем случае. Новый источник pwl - это кусочно-линейная (piece-wise linear) аппроксимация сигнала. Инициализируется точками графика, заданного в виде множества пар ti, vi - где t - время, а v - напряжение (или ток).

Получаем список узлов обычной командой gnetlist:

* gnetlist -g spice-sdb -o comp-test.net comp-test.sch
*********************************************************
* Spice file generated by gnetlist                      *
* spice-sdb version 4.28.2007 by SDB --                 *
* provides advanced spice netlisting capability.        *
* Documentation at http://www.brorson.com/gEDA/SPICE/   *
*********************************************************
*vvvvvvvv  Included SPICE model from comp.net vvvvvvvv
*******************************
* Begin .SUBCKT model         *
* spice-sdb ver 4.28.2007     *
*******************************
.SUBCKT comp in_p in_n vcc vdd out 
*==============  Begin SPICE netlist of main design ============
R4 1 out 100  
R3 vdd vcc 8k  
B1 1 vdd V = V(in_p)-V(in_n) > 0 ? V(vcc)*0.9 : V(vcc)*0.1
R2 in_n vdd 100k  
R1 in_p vdd 100k  
.ends comp
*******************************
*^^^^^^^^  End of included SPICE model from comp.net ^^^^^^^^
*
*==============  Begin SPICE netlist of main design ============
Rv1 0 2 1  
.tran 10m 2
R4 0 out 1k  
R3 3 in 10k  
R2 0 vref 10k  
R1 vref 1 10k  
V2 3 0 pwl 0 0 1 10 2 0
V1 1 2 dc 12V
X1 in vref 1 0 out comp
.end

Мы можем запустить симулятор, просто передав ему полученный список узлов: ngspice comp-test.net



Проанализировав эти графики, мы видим, что компаратор работает как было задумано.

Выходы компараторов в чипе 555 подключены к RS-триггеру. Это цифровой элемент. Чтобы получить представление о цифровой симуляции, лучше сделать еще один маленький проект, по образцу предыдущего. А он, в свою очередь, тащит за собой еще одну проблему. Можно сказать, что проекты размножаются как пузыри, но это естественный способ решать большую проблему - разбивать ее на небольшие самостоятельные части. Потом мы соберем результаты в одно целое.

Проблема из предыдущего абзаца состоит в том, что в библиотеках gschem не нашлось подходящего символа для триггера, который бы нам подошел. Значит, нам нужно сделать собственный символ и лучше всего хранить его в собственной же библиотеке. Можно ли это сделать? Вполне, и это не так сложно, как может показаться. Начнем с самого символа, для которого сразу создадим подкаталог в нашем проекте. Пусть этот каталог называется symlib - это только пример, конечно. Главное - он должен быть в нашем рабочем каталоге.

В этом же рабочем каталоге создадим файл с именем gschemrc - а здесь уже выбор другого имени не допускается, редактор gschem будет искать файл именно с таким именем. Это самый последний конфиг, который он ищет. В файл gschemrc запишем всего одну строку:

(component-library "${HOME}/ваш путь/symlib/" "Digsim Lib")

Вместо "ваш путь" впишите вашу собственную структуру каталогов, а концы пусть остаются. "ваш путь" приписывается к вашему домашнему каталогу, так что его указывать не нужно, иначе gschem заблудится.

Теперь запустим редактор gschem. Обратите внимание на следующее:


Файл gschemrc - это последний файл конфигурации, который читается gschem, если существует.

Теперь удалим рамку - обязательно! - и сохраним файл, дав ему имя по умолчанию. Это будет временный файл и мы скоро его удалим.

Можно создать символ с нуля, но проще использовать уже созданный, разобрав его на "запчасти". Это гораздо быстрее и продуктивней. Нам предстоит создать несколько символов цифровой логики в привычном, европейском стиле, совместимым, кстати, с российским ЕСКД. В библиотеках gschem есть только американские символы. Можно, конечно, работать и с ними, но когда-то же надо созданием своих.

Мы создадим изображения элементов 2И-НЕ, 2ИЛИ-НЕ, инвертор, пару "подтяжек": к высокому и низкому уровням и еще один элемент в качестве 2-битового счетчика для тестирования.

Начнем со вставки в рабочий лист элемента 7400. При вставке обязательно выберем режим Include component as individual objects:



В этом состоянии мы имеем уже не элемент, а просто набор графических примитивов. Можно смело удалять желтый текст - атрибуты пинов, мы назначим новые. Кликнув по пину дважды, откроем его свойства и удалим из списка дубликаты атрибутов (они образовались при вставке): pinseq=0 и pintype=unknown. Для этого кликнем по строке в списке и выберем Delete (или используем клавишу Del.

Удалим также дугу, а refdes присвоим значение A? Все это будет выглядеть так:


Затем проведем вертикальную линию, команда L (Line), чтобы замкнуть прямоугольник:


Сохраним файл untitled.sch и закроем gschem. Теперь мы поработаем над этим файлом в текстовом редакторе, он достаточно поучителен:

v 20130925 2
L 47600 44400 47600 45000 3 0 0 0 -1 -1
L 47600 45000 48000 45000 3 0 0 0 -1 -1
L 47600 44400 48000 44400 3 0 0 0 -1 -1
V 48050 44700 50 6 0 0 0 -1 -1 0 -1 -1 -1 -1 -1
P 48100 44700 48300 44700 1 0 1
{
T 48100 44650 5 8 0 1 0 2 1
pinseq=3
T 48045 44695 9 8 0 1 0 6 1
pinlabel=Y
T 47950 44700 5 8 0 1 0 8 1
pintype=out
}
P 47600 44500 47300 44500 1 0 1
{
T 47500 44450 5 8 0 1 0 8 1
pinseq=2
T 47655 44495 9 8 0 1 0 0 1
pinlabel=B
T 47650 44500 5 8 0 1 0 2 1
pintype=in
}
P 47600 44900 47300 44900 1 0 1
{
T 47500 44850 5 8 0 1 0 8 1
pinseq=1
T 47655 44895 9 8 0 1 0 0 1
pinlabel=A
T 47650 44900 5 8 0 1 0 2 1
pintype=in
}
T 47800 45100 5 10 0 0 0 0 1
device=7400
T 47800 45300 5 10 0 0 0 0 1
slot=1
T 47800 45500 5 10 0 0 0 0 1
numslots=4
T 47800 45700 5 10 0 0 0 0 1
slotdef=1:1,2,3
T 47800 45900 5 10 0 0 0 0 1
slotdef=2:4,5,6
T 47800 46100 5 10 0 0 0 0 1
slotdef=3:9,10,8
T 47800 46300 5 10 0 0 0 0 1
slotdef=4:12,13,11
T 47600 45100 8 10 1 1 0 0 1
refdes=A?
T 47800 46450 5 10 0 0 0 0 1
footprint=DIP14
T 47800 46650 5 10 0 0 0 0 1
description=4 NAND gates with 2 inputs
T 47800 47050 5 10 0 0 0 0 1
net=Vcc:14
T 47800 47250 5 10 0 0 0 0 1
net=GND:7
T 47800 46850 5 10 0 0 0 0 1
documentation=http://www-s.ti.com/sc/ds/sn74hc00.pdf
L 48000 45000 48000 44400 3 0 0 0 -1 -1

В первой строке - версия редактора gschem, ее менять нельзя, по понятным причинам, gschem это может смутить и он откажется читать файл. L - Это линии, V - окружности, T - текст. У всех этих элементов имеются свои внутренние атрибуты: координаты, толщина, тип линии. P - это пины, там целая группа атрибутов.

Атрибут slot - это неграфический элемент, он обозначает номер функциональной единицы в пределах корпуса микросхемы. numslots - общее число, например, логических элементов, оп. усилителей в корпусе и т.д. slotdef - это перечень пинов, относящихся к функциональному элементу. В данный момент нам ничего из этого не понадобится, поэтому удалим ненужные строки и в результате у нас должно остаться:

v 20130925 2
L 47600 44400 47600 45000 3 0 0 0 -1 -1
L 47600 45000 48000 45000 3 0 0 0 -1 -1
L 47600 44400 48000 44400 3 0 0 0 -1 -1
L 48000 45000 48000 44400 3 0 0 0 -1 -1
V 48050 44700 50 6 0 0 0 -1 -1 0 -1 -1 -1 -1 -1
P 48100 44700 48300 44700 1 0 1
{
T 48100 44650 5 8 0 1 0 2 1
pinseq=3
T 48045 44695 9 8 0 1 0 6 1
pinlabel=Y
T 47950 44700 5 8 0 1 0 8 1
pintype=out
}
P 47600 44500 47300 44500 1 0 1
{
T 47500 44450 5 8 0 1 0 8 1
pinseq=2
T 47655 44495 9 8 0 1 0 0 1
pinlabel=B
T 47650 44500 5 8 0 1 0 2 1
pintype=in
}
P 47600 44900 47300 44900 1 0 1
{
T 47500 44850 5 8 0 1 0 8 1
pinseq=1
T 47655 44895 9 8 0 1 0 0 1
pinlabel=A
T 47650 44900 5 8 0 1 0 2 1
pintype=in
}
T 47800 45100 5 10 0 0 0 0 1
device=
T 47600 45100 8 10 1 1 0 0 1
refdes=A?

Можете проверить последний вариант, сохранив его в файл sch. Этот элемент мы можем использовать как шаблон для быстрого построения остальных.

Снова откроем файл в редакторе схем. Выделим весь символ и скопируем его командой Y,C. Данные попадут в один из буферов, которые можно видеть в меню Buffer. Оттуда можно вставлять копию столько раз, сколько нужно.

Снимем выделение и с помощью текстового инструмента добавим в центр прямоугольника знак амперсанда. Чтобы получше выравнить букву, можно уменьшить шаг координатной сетки "[". Не забывайте возвращать ее к стандартному значению. Атрибут device инициализируем значением NAND2.

Преобразуем все это в символ. Для этого используем команду E,T (Edit Translate). Сохраним 0 в появившемся окошке и подтвердим OK. Сохраним файл командой F,A в каталоге symlib с именем nand2.sym Мы создали графический символ логического элемента 2И-НЕ.

Теперь создадим 2ИЛИ-НЕ. Сначала откроем новый файл: F,N (File New). Выделим и удалим рамку. Вставим из буфера шаблон и в центр прямоугольника впишем единицу. Атрибут device получит на этот раз значение NOR2. Транслируем построение в символ и сохраним как nor2.sym

Еще проще создать инвертор. Он уже почти готов. Это элемент 2ИЛИ-НЕ, у которого удалили второй входной пин, а третий пин стал вторым. device=NOT. Дальше поступаете аналогично двум предыдущим примерам.

При помощи всего одного элемента 2И-НЕ или 2ИЛИ-НЕ, одного не числом, а в качестве строительного материала, можно построить любой компьютер, поэтому такие элементы очень распространены. В действительности, из-за необходимости оптимизации аппаратуры были созданы целые серии т.н. стандартной логики.

Но нам понадобятся еще два специальных элемента: высокий логический уровень ("резистор" подтяжки к питанию) и низкий логический уровень (подтяжка к нулю). Здесь мы можем вставить уже имеющийся символ input-1.sym и немного его доработать. Вставляем его как "индивидуальные объекты" (см. выше). В середину символа надо вписать HI или LO, атрибут device примет значение PULL_UP или PULL_DOWN соответственно, а пин pinseq=1, pinnumber=1, pinlabel= HI или LO соответственно. Каждый из пинов имеет pintype=out. Символы сохраняются как hi.sym или lo.sym соответственно. Выглядят они так:



Сделаем последний, наиболее интересный элемент. Он выглядит так:



У этого символа нижний пин имеет атрибуты: pinseq=1, pinnumber=1, pinlabel=0, pintype=out. Верхний пин: pinseq=2, pinnumber=2, pinlabel=1, pintype=out. Атрибут device=VECTOR2.

Последний элемент будет представлять параллельную шину, на которую поступают двоичные данные из текстового файла в специальном и очень простом формате. Мы будем использовать его для тестирования созданной логики.

Теперь мы можем увидеть библиотеку Digsim Lib в списке библиотек диалога компонентов. Давайте создадим схему из наших элементов в новом файле, например, test-logic.sch



С одной стороны, схема как схема. Но если мы вызовем gnetlist, чтобы сделать список соединений, то он откажется это делать. Он не сможет найти наши символы.

Поскольку пост получился уже достаточно большим, то пора его заканчивать (на самом интересном месте). Как решить возникшую проблему, а также о том, как выполнять цифровую симуляцию, речь пойдет в следующем посте в самое ближайшее время. И я должен сказать, что ни на минуту не забыл о таймере для лампочки в туалете. Мы обязательно закончим этот проект, доведя дело до конца.
Займемся лучшей организацией. Если в теперешнем состоянии понадобится изменить схему, то сделать это будет также сложно, как и в первый раз. В редакторе gschem есть все, чтобы поместить в файл sch все необходимое для последующего преобразования, не только в нетлист, но и файл схемы для передачи ngspice. Кроме того, мы можем написать shell-скрипты, использовать perl, python и тому подобное для обработки данных. Все это поможет автоматизировать рутинные действия до пары нажатий на клавиши. И меняй схему как хочешь.

Во-первых, в нашем распоряжении есть великая вещь: возможность включения файлов. И сделать это можно прямо из редактора схем. Во-вторых, простой скрипт для оболочки сделает сначала файл cir, а затем вызовет для него ngspice. И, таким образом, исправление схемы никоим образом не будет тормозить нашу работу. А при разработке схем, не только исследование уже созданной, но и постоянное внесение изменений в существующую, обычное дело. Технические прибамбасы и лишние манипуляции, будут, конечно, отнимать время и раздражать.

Прежде всего, давайте сделаем библиотеку из нашего файла ltimer.cir. Можно просто получить копию: cat ltimer.cir > library.lib (имена и способ получения копии это целиком на ваше усмотрение). Затем отредактируем этот файл:

* library.lib
*
* Библиотека моделей и подсхем
*

*===== модели используемых элементов ==============
* ключ
.model swpwr sw(vt=0.645 vh=0.1 ron=0.5 roff=2meg)

* диоды
.model dac d(is=3e-12 cjo=5pf)
.model dg  d(is=1e-16 cjo=50pf rs=5)
*==================================================

.subckt triac A K G
D2 4 G dg 
R4 ctl 6 2  
C2 0 6 1u  
R3 3 5 1k  
D4 3 5 dac 
S2 A 5 6 0 swpwr 
Vm 3 K
Vg 4 K
Rg 4 G 1k  
D1 G 4 dg 
R1 ctl 2 2  
C1 0 2 1u  
B1 ctl 0 V=I(Vg)*40+abs(I(Vm))>0.015 ? 1 : 0 
R2 3 1 1k  
D3 1 3 dac 
S1 A 1 2 0 swpwr 
.ends

Как видите, все очень просто. Мы имели почти готовую библиотеку.

А теперь маленький трюк. Для добавления пути в наш блок переменных окружения я использую простую фишку: PATH=$(pwd):$PATH в самом обычном файле p. И вам не надо добавлять точку со слешем, чтобы запустить команду из текущего каталога. Этот экземпляр блока переменных окружения сохраняется до конца текущего сеанса терминала.



Заодно я делаю все остальное, т.е. создаю файл sim с командами и делаю его исполняемым. Чтобы изменить переменную окружения PATH, мне не надо выписывать всю команду в командную строку, достаточно поставить точку, пробел (обязательно, чтобы bash не подумал, что это скрытый файл .p) и указать имя файла. Текущий каталог будет добавлен к переменным окружения.

Теперь можно открыть ltimer.sch в редакторе gschem. В схему нужно добавить два особых элемента (в фильтре их легче всего найти набрав spice). Эти "кирпичи" нужно инициализировать значениями: SPICE include - file = library.lib и SPICE directive - value = .tran 10u 0.12

Это, как вы понимаете, то, что должно входить в файл схемы. Кроме того, надо переименовать VS в X... элемент, ибо это подсхема. Ну, допустим, X_VS. Параметры источников также должны быть явно указаны в редакторе схем. За исключением источника B1 из подсхемы триака. Он уже в библиотеке. В результате мы получаем следующую картину:



Все готово к запуску, но сначала заглянем в новый список узлов, который сделает gnetlist:

* gnetlist -g spice-sdb -o ltimer.cir ltimer.sch
*********************************************************
* Spice file generated by gnetlist                      *
* spice-sdb version 4.28.2007 by SDB --                 *
* provides advanced spice netlisting capability.        *
* Documentation at http://www.brorson.com/gEDA/SPICE/   *
*********************************************************
*vvvvvvvv  Included SPICE model from library.lib vvvvvvvv
* library.lib
*
* Библиотека моделей и подсхем
*

*===== модели используемых элементов ==============
* ключ
.model swpwr sw(vt=0.645 vh=0.1 ron=0.5 roff=2meg)

* диоды
.model dac d(is=3e-12 cjo=5pf)
.model dg  d(is=1e-16 cjo=50pf rs=5)
*==================================================

.subckt triac A K G
D2 4 G dg 
R4 ctl 6 2  
C2 0 6 1u  
R3 3 5 1k  
D4 3 5 dac 
S2 A 5 6 0 swpwr 
Vm 3 K
Vg 4 K
Rg 4 G 1k  
D1 G 4 dg 
R1 ctl 2 2  
C1 0 2 1u  
B1 ctl 0 V=I(Vg)*40+abs(I(Vm))>0.015 ? 1 : 0 
R2 3 1 1k  
D3 1 3 dac 
S1 A 1 2 0 swpwr 
.ends
*^^^^^^^^  End of included SPICE model from library.lib ^^^^^^^^
*
*==============  Begin SPICE netlist of main design ============
.tran 10u 0.12
.INCLUDE library.lib
X_VS a 0 g triac
R1 2 g 1k  
V1 2 0 pulse 0 1 0.021 100n 100n 0.052 0.12
V2 1 0 sin 0 311 50
Rlamp a 1 600  
.end

Похоже, что все будет работать. Правда, тут нет секции .control но из gschem ее вставить не получится. Она должна располагаться в конце файла. Пристроить ее туда можно из отдельного файла, но это потребует некоторой возни с последней строкой .end А можно поступить и гораздо проще:

*
* ltimer.cir - таймер для лампочки
*
.include ltimer.net
.control
	run
	plot . . .
.endc
.end

Тогда достаточно сделать такой файл и чуть подправить sim. В общем, вариантов много. Это куда лучше чем в коммерческих программах, где тебе дают кнопку и навязывают унылую херню, которую ты не можешь обойти.

После команды sim у вас должно все получиться. Теперь вы понимаете принцип создания иерархических схем в ngspice. Чтобы исчезли последние вопросы я еще раз покажу на конкретном примере.

Собираем схему:



Здесь надо пояснить лишь несколько моментов (остальное вам уже понятно). C2 - это только вариант символа. Для spice по барабану, полярный конденсатор или нет. Если, конечно, нам не вздумается построить модель для его симуляции. D2 - cтабилитроны надо искать в фильтре библиотеки по ключу zener. F1 - это чисто графический символ. spice его игнорирует. Но он может оказаться полезным для pcb, поэтому, чтобы ngspice не ругался, добавим элементу F1 атрибут graphical = 1. Ключ S1 имеет атрибуты: model-name = swctl и value = sw vt=1 vh=0 ron=1 roff=10meg То есть, его нет ни в какой библиотеке, он целиком находится в схеме.

В библиотеку добавим модель стабилитрона. Это такой же диод, но с параметрами, свойственными стабилитрону. Вот новая версия библиотеки:

* library.lib
*
* Библиотека моделей и подсхем
*

*===== модели используемых элементов ==============
* ключи
.model swctl sw(vt=0.9 vh=0.1 ron=1 roff=10meg)

* диоды
.model dac d(is=3e-12 cjo=5pf)
.model dg  d(is=1e-16 cjo=50pf rs=5)

* стабилитроны
.model zen12 d(is=3e-12 cjo=30pf rs=4 bv=12)
*==================================================

.subckt triac A K G
D2 4 G dg 
R4 ctl 6 2  
C2 0 6 1u  
R3 3 5 1k  
D4 3 5 dac 
S2 A 5 6 0 swpwr 
Vm 3 K
Vg 4 K
Rg 4 G 1k  
D1 G 4 dg 
R1 ctl 2 2  
C1 0 2 1u  
B1 ctl 0 V=I(Vg)*40+abs(I(Vm))>0.015 ? 1 : 0 
R2 3 1 1k  
D3 1 3 dac 
S1 A 1 2 0 swpwr
.model swpwr sw(vt=0.645 vh=0.1 ron=0.5 roff=2meg)
.ends

Модель ключа, которая управляет симистором, перенесена в его подсхему. Это логично и естественно. Туда же можно перенести и диоды, но пока можно оставить т.к. библиотека маленькая и это только пример.

Ключ swctl, вернее, его модель, записана сюда на всякий случай, если не получится подцепить модель в качестве параметра. Для этого можно провести отдельный эксперимент.

Остальные файлы, сначала sim:

#!/bin/bash
gnetlist -g spice-sdb -o ltimer.net ltimer.sch
ngspice ltimer.cir

Затем ltimer.cir:

.include ltimer.net

.control
	run
	plot v(test)
	plot vitest#branch
.endc
.end

Вся цепочка должна быть понятна: gschem создает схему в собственном формате, затем она передается из sim в программу gnetlist. gnetlist делает файл ltimer.net и затем ngspice читает файл ltimer.cir из которого ltimer.net виден благодаря директиве .include

Цель нарисованной схемы - получить питание для электроники платы. Земля теперь перенесена на минусовую шину платы. Плюсовая шина называется test и мы хотим посмотреть на ее нагрузочную способность. Для этого мы повесили в нагрузку резистор Rtest в 100 Ом. Этого маловато, но с чего-то надо начать. Обратите внимание: время симуляции теперь 7 секунд, а отсчеты мы делаем каждые 10 миллисекунд. Это оптимально на данный момент. Посмотрим на напряжение и ток на шине +12 В:



Чего-то подобного и следовало ожидать. Увеличим сопротивление rtest пропорционально, т.е. раз в 5. (Используем alter и перезапустим ngspice.) Новые результаты выглядят получше.



Пусть теперь сопротивление нагрузки 1k. Снова смотрим:



Неудачный скриншот, ток оказался закрыт другим окном, но он меньше, чем был до этого. Фактически, схема таймера будет потреблять меньше, чем 10 мА, но нам сейчас важно вообще определить нагрузочную способность источника и его коэффициент пульсаций. Допустим, нас устроил вариант с 500 омами минимального сопротивления нагрузки. Смотрим пульсации:



Чтобы увидеть размах "бороды" используем курсорное измерение, проводим мышкой по бороде и получаем 0.64 В. Мы можем в ngspice легко выбраться в оболочку и запустить калькулятор, например bc. Считаем, получаем результат: 6.25% (хотя это и так ясно, но надо показать, как это делается, что все у нас рядом). Из калькулятора в оболочку выходим с помощью клавиш Ctrl-D и затем из оболочки в ngspice еще раз теми же клавишами (управляющий символ EOF, конец файла). Еще раз отдельно:



Поскольку ток через стабилитрон протекает тот же самый, что и через Rtest, то никаких лишних амперметров нам не нужно. Следует подбирать стабилитрон с аналогичными данными, лучше с некоторым запасом. Но уточнения еще впереди, а пока проведем тест, сделав включение "лампочки". Посмотрим, как это повлияет на цепь 12 В. Очевидно, что надо увеличить параметр v2 в pulse источника Vctl до той величины, которая включит S1. Заодно не забудем изменить в схеме сопротивление Rtest на 500 омное: будем считать, что это нас пока устраивает. Для "подключения щупов" к лампочке - резистору Rlamp просто добавим к его концам имена узлов a и b.

Исправим, кстати, и ошибку в уравнении для B1 в подсхеме симистора. Там установлено два диода для работы управляющего электрода как от положительных, так и отрицательных импульсов. Тем не менее, симистор будет работать только при положительных управляющих импульсах. Исправим ошибку:

B1 ctl 0 V=abs(I(Vg))*40+abs(I(Vm))>0.015 ? 1 : 0

Теперь мы берем абсолютное значение управляющего тока. Вот так схема заработает. Также удалим атрибут value у ключа S1. Он бесполезен, я это уже выяснил, а модель ключа будет работать только из библиотечного файла.

Новая версия ltimer.cir:

.include ltimer.net

.control
	run
	let igate = vi#branch
	let ilamp = vpwr#branch
	let itest = vitest#branch
	plot v(test) itest*1000
	plot igate
	plot ilamp
.endc
.end

Это способ дать результатам понятные имена. let поможет заменить имя вектора (одномерного массива чисел) на то, которое будет удобным для пользователя. Новые имена можно использовать в командах и названия графиков получат те же имена. Сейчас мы одной командой sim получим сразу все графики. Для измерения тока в цепи управляющего электрода использован "амперметр", ну, а как это делается, вам уже известно.



Здесь мы можем сразу увидеть потребляемый ток в цепи питания управления, он показан синим, напряжение на нем, красного цвета, ток в цепи управляющего электрода, и ток в цепи нагрузки. Когда нагрузка включается, напряжение в цепи "12 В" немного падает. Главным недостатком схемы является заметный ток, пожираемый условной схемой управления, ведь он жрется круглосуточно. Давайте приблизительно прикинем мощность. Как это сделать, мы уже знаем: надо измерить размах тока, когда нагрузка отключена. А затем:



Итого почти 8 кВт*ч в месяц. Сколько это по вашему тарифу?

На самом деле, из-за неполных данных мы не можем сейчас сказать сколько съест устройство. Часть тока - реактивная, домашний счетчик за нее не платит. Активная часть тока греет стабилитрон, D3 и резистор R4. Если схема таймера будет работать при небольшом токе, резистор R4 можно увеличить, или уменьшить емкость конденсатора C3. Тут есть множество соображений по оптимизации. Например, может возникнуть дизайнерская идея подсвечивать матовую полупрозрачную кнопку выключателя красными светодиодами, чтобы ее было видно в темноте. Тогда придется потратить экономию на красоту.

В общем, пока хватит. А в следующий раз займемся схемой и моделью самого таймера 555.

Tags:

Наконец, запустим симулятор и увидим как работать с ним. Испытаем схему и проведем некоторые измерения. Мы увидим, что ngspice - это точный инструмент. По крайней мере, с точностью до параметров заданных в схемах и моделях. Мы убедимся, что работать с ngspice намного проще, чем с другими программами и развенчаем в очередной раз идиотский миф об ужасах командной строки. Из-за того, что в память не загружены GUI-плюшки и перделки, симулятор работает очень быстро. А графики он нарисует без проблем.

В прошлом посте мы дошли до файла ltimer.cir, готового к симуляции. Поэтому сейчас мы просто запустим его на обработку в симуляторе. Откроем терминал в том каталоге, где у нас находится файл ltimer.cir

Наберем командную строку: ngspice ltimer.cir и нажмем Enter.

Буквально сразу мы увидим результаты:



Если график кажется маленьким, раздвинем мышкой дочернее окно:



Мы видим, что симистор на самом деле включился от управляющего импульса и работает правильно. Если вы думаете, что это все, то ошибаетесь. Например, что делать, если вы хотите посмотреть на график напряжения между катодом и анодом в открытом состоянии? Посто выделить интересующую область рамкой при нажатой правой кнопке мыши. Появится новое окно. Если и этого мало, можно повторить масштабирование. Лишние окна можно позакрывать.



Немалый интерес представляет и текстовый вывод ngspice на терминал. Ведь сейчас мы работаем в интерактивном режиме.

$ ngspice ltimer.cir
******
** ngspice-24 : Circuit level simulation program
** The U. C. Berkeley CAD Group
** Copyright 1985-1994, Regents of the University of California.
** Please get your ngspice manual from
** http://ngspice.sourceforge.net/docs.html
** Please file your bug-reports at
**http://ngspice.sourceforge.net/bugrep.html
** Creation Date: Wed Apr 16 21:09:20 UTC 2014
******

Circuit: * ltimer.cir

Doing analysis at TEMP = 27.000000 and TNOM = 27.000000

Warning: v1: no DC value, transient time 0 value used
Warning: v2: no DC value, transient time 0 value used
Warning: v.xvs.vg: has no value, DC 0 assumed
Warning: v.xvs.vm: has no value, DC 0 assumed

Initial Transient Solution
--------------------------

Node                                   Voltage
----                                   -------
xvs.4                                        0
3                                  -6.7388e-95
xvs.ctl                                      0
xvs.6                                        0
xvs.3                                        0
xvs.5                             -2.40935e-23
a                                            0
xvs.2                                        0
xvs.1                              2.40935e-23
2                                            0
1                                            0
b.xvs.b1#branch                              0
v.xvs.vg#branch                     6.7388e-98
v.xvs.vm#branch                              0
v1#branch                          -6.7388e-98
v2#branch                                    0



No. of Data Rows : 1265
ngspice 2 -> 

Программа предупреждает о том, что кажется ей косяками (наши амперметры) и дает сводку начальных условий на всех узлах. Как видим, сюда включаются и подсхемы. ngspice - это "плоский" симулятор и вся иерархия поэтому видна, по крайней мере, хотя бы на одном уровне вложенности.

Поскольку мы находимся в интерактивном режиме, то ничто не мешает нам использовать команды. Команды, предписанные в файле уже выполнены, но мы можем добавлять и свои. Например, давайте посмотрим, каков ток в нагрузке. Для этого наберем команду: plot v2#branch и сразу все увидим:



Клик мышкой (левая кнопка) в любую точку графика приводит к выводу координат, в единицах осей, в терминал.

Сделаем еще парочку измерений. Посмотрим скорость переключения симистора в единицах В/сек. Для этого сначала выйдем из ngspice при помощи команды exit (или quit). Изменим шаг симуляции в файле ltimer.cir: .tran 10u 0.12 Теперь мы получим больше данных и графики будет точнее. Вообще, для получения корректных результатов для схем с тиристорами нужно брать величину шага времени не более 20 микросекунд.

Снова запустим ngspice. Будем увеличивать график в подходящем месте (там, где падает напряжение на аноде при включении тиристора) до разумных масштабов:



Затем установим мышку в точке, показанной на рисунке выше, нажмем левую кнопку и протянем мышь в конечную точку. Как только мы закончим операцию, ngspice рассчитает необходимые данные:




Поскольку шкала на графике выражается в миллисекундах, при выбранном масштабе, а напряжение в вольтах, то отношение dy/dx нужно разделить на тысячу. Получим значение: -1.14e+5 или, говоря более просто, 114 кВ/сек.

Определим ток удержания. Вообще-то он уже определен, в выражении для источника B1. Но интересно будет проверить.

Рисуем два графика: plot v(a) vm#branch и увеличиваем в том месте, где симистор выключается. Увеличивать придется несколько раз.



На правом графике излом тока виден чуть покрупнее, и, кликув ему "по коленке" мы получаем точку с ординатой несколько больше 15 заданных миллиампер. Эта погрешность, хочу еще раз напомнить, вызвана недостаточно мелким шагом симуляции. Если вы установите шаг, скажем, не 10 мкс (10u), а в сто раз меньше, это будет 100n, и наберетесь терпения на полминуты (у меня это заняло 35 секунд), то получите больше миллиона строк выходного массива данных и вот такую картину:



Этот пример показывает, что к настройке симулятора надо подходить разумно, без фанатизма, и тогда скорость разработки схем значительно увеличится. Если вам не нужна лишняя точность, не парьтесь. Не гоняйте зря машину. Много ли мы получили прибавки к относительной точности? Процентов 10. В данный момент такая точность не оправдывает большой расход времени.

При наладке схем, не обязательно выходить из симулятора. Допустим, нам надо увеличивать сопротивление нагрузки, до тех пор, пока ток не станет меньше тока удержания. Мы можем сделать это "не отходя от кассы":



Здесь сначала была команда listing, потому, что я забыл, как называется резистор в нагрузке, а открывать файл в редакторе мне было лень. Выяснив, я набрал команды, какие вы видите на картинке и перезапустил ngspice. Но амплитуда тока все еще недостаточно снизилась. Поэтому я еще раз увеличиваю сопротивление и снова запускаю ngspice, пока не получу нужную картину тока:



На сегодня достаточно, а в другой раз мы займемся новой темой: как развивать схему без лишних манипуляций с файлами, добавлять, убавлять участки цепей, менять параметры без явного обращения к gnetlist и лишней ручной правки файла cir. Что касается самого таймера, то мы добавим схему для получения 12 В постоянного напряжения с минимумом деталей.

p.s. Я знаю, что мой бложек мало кто читает, тем более, из числа дам, но на всякий случай, с праздником!
В этой части мы создадим еще одну схему в отдельном файле. Поскольку встроенной в SPICE модели тиристора или симистора не существует, то нам придется заменить его схемой из других имеющихся. Наша простая схема не учитывает всей динамики и особенностей поведения симисторов, мы симулируем только ток удержания. Мы не собираемся собираемся делать старинный электровоз или подводную лодку восьмидесятых годов. Нам нужен симистор для управления лампочкой, ток через которую не превысит 1А. Имея две схемы, мы получим их списки узлов и будем объединять результаты, готовя общую схему к симуляции.

Создадим новый файл, скажем, triac.sch, в том же самом каталоге, что и прежний. Поскольку эта схема у нас для печати явно не предназначена, удалим рамку оформления. Только удобнее сделать это сразу, до вставки каких-либо элементов. Рамка окажется выделенной только если взять ее в выделение целиком, кликами по ней она не выделяется. Выделенную рамку удаляем.

Найдем в библиотеке модели диода, резистора, конденсатора и источника напряжения. Нажмем клавишу I и пишем в фильтре: ca - выбираем символ capacitor-1.sym, re - выбираем символ resistor-2.sym (привычный нам европейский символ резистора), dio - выбираем диод, и vd - выбираем источник напряжения vdc-1.sym.

Теперь выберем управляемый напряжением ключ. Пишем в фильтре: spice*sw - и выбираем единственный в библиотеке spice voltage controlled switch. Звездочка - это подстановочный символ. Я не помню точного названия этого элемента, помню только, что он относится к элементам для симуляции, почему я и обратился к библиотеке spice, и что это ключ. Поэтому воспользовался регулярным выражением и сэкономил время на ручной поиск путем раскрывания и прокрутки списков библиотек.

Найдя нужные элементы, строим из них следующую схему:



Я специально постарался сделать ее как можно проще. Диоды D1 и D2 имитируют управляющий электрод. Он работает от импульсов любой полярности и создает ток, который можно регистрировать на амперметре Vg. Это такая фишка в ngspice: поскольку, как мы знаем из теоретической электротехники, идеальный источник напряжения имеет бесконечно малое сопротивление, то это будет идеальным амперметром. Алгоритм работы симулятора ngspice таков, что он рассчитывает токи для всех источников напряжения. Поэтому источником с нулевым напряжением можно смело измерять ток.

Источник B1 является зависимым источником напряжения. Электрически он никак не связан с Vg (за исключением земли, но об этом чуть позже). Однако, имеет связь с ним через математическое выражение, записанное под ним. Он управляет ключами S1 и S2 по некоторым условиям.

Главная цепь проходит через собственно ключи, диоды, которые представляют модель открытых переходов в симисторе, и еще один амперметр.

"Оборванный" провод возле R4 в действительности совсем не оборван. Он подключен к выводу 1 источника B1, поскольку данный узел имеет имя ctl. По умолчанию, все узлы нумеруются, но при желании любому из них можно присвоить любое допустимое имя.

Теперь о земле. Земля - она же точка с нулевым потенциалом - обязательно должна присутствовать в любой схеме, предназначенной для симуляции. Без нее симулятор наотрез откажется выполнять какие-либо расчеты. Выбор ее совершенно произволен, но она должна быть. Любой контур должен иметь связь с землей, прямо или через другую цепь. Земля является глобальным символом и видна отовсюду в любой иерархии подсхем. Поэтому не стоит беспокоиться о том, что мы использовали "неучтенную" землю в схеме. Этот контур - независимый, касающийся схемы только в одной общей точке. В самом ключе управляющая часть никак не связана электрически с управляемой. Это такая же поведенческая модель как и B. Она нигде и никогда не "коротнет".

Теперь займемся генерацией нетлистов. В том каталоге, где у нас находятся схемы ltimer.sch и triac.sch откроем терминал, и выполним две одинаковые команды (для каждого из файлов):



Третьей командой я просто подшил оба файла в общий, с именем ltimer.cir Этот файл мы и будем симулировать, но сначала надо привести его в порядок, убрать лишнее и добавить недостающее.

Это обычный текстовый файл. Вот его листинг:

* gnetlist -g spice-sdb -o triac.net triac.sch
*********************************************************
* Spice file generated by gnetlist                      *
* spice-sdb version 4.28.2007 by SDB --                 *
* provides advanced spice netlisting capability.        *
* Documentation at http://www.brorson.com/gEDA/SPICE/   *
*********************************************************
*==============  Begin SPICE netlist of main design ============
D2 4 G dg 
R4 ctl 6 2  
C2 0 6 1u  
R3 3 5 1k  
D4 3 5 dac 
S2 A 5 6 0 swpwr 
Vm 3 K DC 0
Vg 4 K DC 0V
Rg 4 G 1k  
D1 G 4 dg 
R1 ctl 2 2  
C1 0 2 1u  
B1 ctl 0 V=I(Vg)*40+ abs(I(Vm)) > 0.015 ? 1 : 0 
R2 3 1 1k  
D3 1 3 dac 
S1 A 1 2 0 swpwr 
.end
* gnetlist -g spice-sdb -o ltimer.net ltimer.sch
*********************************************************
* Spice file generated by gnetlist                      *
* spice-sdb version 4.28.2007 by SDB --                 *
* provides advanced spice netlisting capability.        *
* Documentation at http://www.brorson.com/gEDA/SPICE/   *
*********************************************************
*==============  Begin SPICE netlist of main design ============
VS a 0 3 triac
R1 2 3 1 k  
V1 2 0 pulse 0 1 10n 10n 100n 1u 2u
V2 1 0 sin 0 1 1meg
Rlamp a 1 1 k  
.end

Звездочка, если она стоит в начале строки, означает комментарий, до конца строки. Многострочных комментариев в SPICE нет. Так как звездочка еще может быть использована в контексте оператора умножения, то для комментариев в конце строк предусмотрены точка с запятой или знак доллара.

Правку начнем с удаления шапок. Обязательно удалим первый .end - он недвусмысленно завершает файл с кодом spice. Оставим только последний. Код из файла triac.net мы превратим в подсхему (subcircuit). Обращение к этой подсхеме уже есть в главной схеме, нам нужно только правильно оформить обращение к ней. Тут есть некоторая аналогия с вызовом функции в языках программирования. Например, мы не можем себе позволить перепутать выводы компонента. Мы должны знать, в каком порядке они идут.

Надо немного понимать, что такое нетлист вообще. Принципиальная схема - это граф. Его вершинами являются либо компоненты, начиная с одиночных выводов и заканчивая микросхемами с сотнями выводов, либо узлы - точки с одинаковым потенциалом. Ребрами графа является множество всех пар отношений "быть подключенными" между узлами. С точки зрения математики, компоненты и узловые точки соединений это все, один хер, вершины, но мы должны делать различия, и разбить все множество вершин на два класса эквивалентностей. Отделить мух от котлет. Поэтому будем называть компоненты (элементы, радиодетали ебена мать) компонентами, а узлы - узлами, и это никогда не будет одним и тем же.

Синтаксис нетлиста предполагает, что первым в строке идет обязательно компонент (в качестве невырожденного узла), а далее перечисляются все узлы по номерам исходящих (или входящих, тут нет разницы) ребер компонента. Так вот, последовательность этих номеров вовсе не произвольна! Нельзя ошибиться в этих важных атрибутах. Поскольку узлы могут обозначаться именами, то, казалось бы, проблем нет. Но чтобы связать графический символ с компонентом на все случаи жизни, имен будет маловато.

Поэтому существует атрибут refdes (reference designator) описывающий "канонический", естественный порядок следования выводов компонента. Кроме того, один и тот же компонент может выпускаться в разных корпусах с разным расположением выводов. Поэтому есть атрибут pinnumber. И наконец, для мнемоники есть атрибут pinname.

После перечисления выводов компонента в строке нетлиста может быть указание дополнительных параметров, которые зависят от контекста.

Давайте посмотрим на атрибуты refdes компонента triac из библиотек gschem. Это нетрудно сделать. Откроем схему ltimer.sch и выделим симистор. Правой кнопкой мыши вызовем контекстное меню. Выберем команду Down Symbol. Мы попадем в редактор символов. Выделим любой пин и посмотрим его свойства:



Поставим в строках refdes галочки visible. Имена показывать не нужно. Это будет выглядеть так:




Теперь можно использовать контекстную команду Up и подняться наверх, в исходную схему. Но можно и просто закрыть окно из менеджера: P,M и кликнуть "закрыть страницу":



При закрытии gschem спросит нас о сохранении изменений. Ответим: нет, Close without saving. Кстати, это и бесполезно, благодаря правам доступа только на чтение. (Если вы конечно работаете не как root, что было бы довольно неразумно.)

Поскольку ошибки с пинами совершаются нередко и ведут к производственному браку, давайте пометим и нашу главную схему. Нам не удалось отредактировать сам элемент (потом я подскажу, как прикрутить пользовательские библиотеки, сейчас не будем отвлекаться), но добавить подписи текстом прямо на схему можно всегда. Для этого есть команда A,T (Add Text). Появится окно с ясной подсказкой. Размер и цвет текстовых элементов легко можно изменять выделением и командой из контекста. Можно сделать любые таблицы и рамки, например, для печати спецификаций и документов в ЕСКД.

В общем, с подписями атрибутов refdes картина будет выглядеть так:



Как видно из последней картинки, редактор поддерживает не только темную цветовую схему, иногда хочется разнообразия. Но надо сказать, что темная схема более контрастна и разборчива.

Первый вывод будем считать анодом. Хотя у симисторов, из-за их симметрии, нет ни катода, ни анода, нам лучше считать, что катод у нас есть, так как наше управление пляшет именно от него. Ну, а там, где катод, должен быть и анод. Вообще, конфигурации тиристоров и симисторов достаточно разнообразны, но мы берем простой пример, чтобы не заморачиваться и ограничиваемся только основным поведением прибора.

Теперь у нас есть все, чтобы правильно оформить подсхему. Дальше у нас разбор файла схемы, это то, что уже подготовлено для запуска симулятора. Вот окончательный листинг:

* ltimer.cir
*
* Простая модель симистора
*

*===== модели используемых элементов ==============
* ключ
.model swpwr sw(vt=0.645 vh=0.1 ron=0.5 roff=2meg)

* диоды
.model dac d(is=3e-12 cjo=5pf)
.model dg  d(is=1e-16 cjo=50pf rs=5)
*==================================================

.subckt triac A K G
D2 4 G dg 
R4 ctl 6 2  
C2 0 6 1u  
R3 3 5 1k  
D4 3 5 dac 
S2 A 5 6 0 swpwr 
Vm 3 K
Vg 4 K
Rg 4 G 1k  
D1 G 4 dg 
R1 ctl 2 2  
C1 0 2 1u  
B1 ctl 0 V=I(Vg)*40+abs(I(Vm))>0.015 ? 1 : 0 
R2 3 1 1k  
D3 1 3 dac 
S1 A 1 2 0 swpwr 
.ends

* ============ основная схема =====================

XVS a 0 3 triac
R1 2 3 1k  
V2 1 0 sin 0 311 50
Rlamp a 1 600  

*            v1 v2 td    rt   ft   pw    per
V1 2 0 pulse 0  1  0.021 100n 100n 0.052 0.12

* директивы симулятору
.tran 100u 0.12 ;шаг времени и длительность

* управление работой симулятора
.control
	run
	plot v(a) V(2)*100
.endc
.end

В этом файле появляются модели, при помощи соответствующей директивы мы включаем параметры для работы ключей и параметры, описывающие необходимые свойства диодов. В дальнейшем мы только ссылаемся на эти строки из списка узлов.

Для обращения к подсхеме всегда следует использовать префикс X. Это правило языка SPICE. Поэтому у нас триак обозначен как XVS, а не просто VS, как в схеме. Подсхема обязательно должна заканчиваться строкой .ends - только так симулятор поймет, что подсхема кончилась, даже, если она хранится в отдельном файле.

Сопротивление R1 ограничивает ток в цепи управляющего электрода. Источник V2 представляет обычную розетку. В ней 220 вольт (амплитуда этого напряжения получается умножением на квадратный корень из двух, отсюда и 311). Частота 50 Гц. А первый нолик, после sin, обозначает величину постоянной составляющей напряжения. Сопротивление в нагрузке 600 ом, это соответствует приблизительно лампочке 75 ватт. Ток должен быть 0.35 А (это навскидку).

Источник V1 формирует импульс включения симистора. Его параметры: v1 - нижний уровень, v2 - верхний уровень, td (time delay) - время задержки от начала симуляции, rt (rise time) - время нарастания, ft (fall time) - время спада, pw (pulse width) - ширина импульса, per (period) - период. Время разумеется в секундах, остальное в соответствующих единицах.

Мы настраиваем "генератор" так, чтобы пронаблюдать один выключенный период, включить триак в начале второго периода и отключить его через пару периодов тоже где-нибудь в точке, где синусоида отлична от нуля. На этом заканчивается схема.

Еще две директивы. Одна из них, .tran (транзиентный анализ, анализ переходных процессов, анализ во временной области) определяет, что именно нужно проделать симулятору. В таком режиме симулятор работает подобно осциллографу. Временной шаг составляет 100 мкс, а общее время 0.12 секунд - ровно 6 периодов сетевого напряжения.

Директива .control выполняет команды после загрузки данных. Команда run запускет процесс вычислений, а plot - строит графики, в данном случае, напряжения на аноде и напряжения на "генераторе". Теперь все готово к запуску симулятора.

Но, поскольку пост получился не слишком маленький, то остальное будет продолжено в следующем.

gEDA - редактор схем

В этой и остальных частях мы выберем подходящую элементную базу, и постараемся, чтобы она заработала правильно, еще до того, как мы возьмемся за паяльник. Тогда, вместо монтажных соплей мы можем сразу разводить печатную плату. А смонтировав ее, возможно, лишь перепаять пару деталей. И у нас должен получиться рабочий экземпляр устройства, полезного для дома.

Кто пользователь симуляторов? Понятно, что они бесполезны для чайников, которые только учатся отличать резистор от конденсатора и не сильно нужны гуру с огромным опытом. Впрочем, если учесть, для чего они создавались, то и гуру хер с два обойдутся без них. Ведь симуляторы электроники содавались не для транзисторных схем, где можно навешать кучу щупов к приборам. Они создавались для проектирования интегральных схем, в которые никак не влезешь со щупами и крокодилами.

Теперь к схеме. Что должно заменить выключатель в цепи с лампочкой? Скорее всего, симистор или, как его еще называют, триак. Это два встречно-параллельно включенных тиристора. Они проводят в обе стороны и поэтому отлично подходят для переменного тока. К тому же, они широко распространены и недороги. Хорошо. С этим определились. Что должно включать и выключать сам симистор? Времязадающая схема, собственно таймер. Тогда останется только кнопка, и устройство готово.

У себя в барахле я нашел кучу самых поздних советских аналогов знаменитого чипа 555, КР1006ВИ1. Эти микросхемы попали ко мне из каких-то неликвидов. Это подойдет. К сожалению, у меня нет spice-моделей: ни подходящего симистора, ни знаменитой схемы 555. Я не могу найти ничего подходящего в интернете. Значит, все, что я могу - это нарисовать схему и напечатать ее на принтере. Я даже могу сделать печатную плату, но как она будет работать? И будет ли работать вообще? Хз...

Но я не отчаиваюсь. Если и вы не отчаиваетесь, то давайте в этом посте сделаем все, что можем (плату пока не надо), а в следующем займемся решением возникших проблем. Эти проблемы составляют настоящий кладезь для изучения симулятора ngspice и его великолепных возможностей.

Пока нам достаточно всего лишь научиться рисовать схемы и создавать собственные элементы, если их нет в готовых библиотеках. Частенько случается. Освоив эти простейшие вещи, мы остановимся и передохнем до нового поста. Так что, наша тема в этом посте вовсе не ngspice, а редактор принципиальных схем gschem.

Чтобы уменьшить число скриншотов, я постараюсь подсократить лишние манипуляции, предоставляя вам немного поэкспериментировать. Все можно найти в меню программы.

Запустим программу и рассмотрим ее окно:



Окно статуса подсказывает, где можно найти конфиги. Не исключено, что очень понадобится знать, где они находятся. В unix-подобных системах нет "реестра" - геморройной базы данных в стиле Windows. Сохраним файл, но не обязательно делать это в корне домашнего каталога и с именем по умолчанию. Я назвал его ltimer.sch - это можно увидеть в заголовке главного окна.

Можно начинать рисовать схему. В программах такого типа этот процесс очень упрощен тем, что в область окна вставляются уже готовые библиотечные элементы. Затем они переразмещаются подходящим образом и соединяются линиями связей. К библиотекам можно обратиться, нажав клавишу I (Insert запоминайте мнемонику клавиш):



В окне Select Component... есть две вкладки: In Use и Libraries. В использовании у нас пока только рамка оформления чертежа. Переключимся на вкладку библиотек:



Чтобы не раскрывать иерархию списков и не крутить ее вручную, мы можем просто начать писать название элемента, который нас интересует, в текстовом поле Filter. И часто мы получаем интересующий нас элемент, едва начав писать что-либо из относящегося к нему. Кликнув найденный элемент, мышью вставляем его в схему, кликая левой кнопкой. Правой кнопкой мы отменяем продолжение вставки.

Стоит обратить внимание, на то, что по умолчанию в схему вставляется ссылка на элемент. Есть и другие варианты вставки, но о них пока не будем. Дальше, очистив фильтр, ищем элементы re, vsi, vp, g - мы еще только начинаем писать, как нам попадаются необходимые элементы: резистор, источник синусоидального напряжения, источник импульсного напряжения и земля.

Земля, даже для самой простейшей симуляции совершенно необходима, по математическим соображениям. Иначе симулятор не сможет считать матрицы, составленные по уравнениям из законов Кирхгофа. Впрочем, это уже математические внутренности программы. Земля - это точка схемы с нулевым потенциалом и одновременно глобальный символ.

Немного о масштабировании схем в окне редактора. Это можно делать колесиком мыши. Но, если мы хотим сделать "прицельное" масштабирование с предпросмотром, то можно установить мышь в левый верх воображаемой рамки и нажать клавишу W (Window). Затем протянуть мышь - не нажимая ее кнопок! - в левый низ воображаемой рамки. По мере протягивания мы увидим голубенькую рамку.



Установив ее, как требуется, сделаем клик и немедленно получим отмасштабированное изображение в окне:



Передвигать отмасштабированный лист схемы можно при нажатой средней кнопке мыши, бегунками прокрутки или, колесом мыши при нажатых клавишах Shift (вверх-вниз) или Ctrl (вправо-влево).

Теперь мы видим элементы покрупнее и самое время заняться их атрибутами. Атрибутов может быть довольно много. (Но, конечно, без такого фанатизма как в OrCAD или PCAD.)

Давайте вызовем, для начала, "полный" редактор атрибутов элементов. Для этого кликом выделим один из них и нажмем клавишу E дважды (Edit Element). Появится окно:



В качестве примера отменим видимость одного из атрибутов выделенного элемента - value. Просто снимем галочку там, куда на скриншоте указывает мышь. Получим результат:



Теперь используем "одиночный" редактор свойств. Выделим надпись рядом с символом другого элемента и снова нажмем E,E:



Здесь автоматически будет выбран атрибут, который мы выбрали, и можно либо изменить его значение, либо управлять его видимостью. Сделаем его невидимым. Затем, кликая по обозначениям и надписям можно редактировать их. Знак вопроса заменяем на позиционные номера элементов. Можно использовать и имена, например, Rload будет представлять нагрузку. Добавляем в "большом" редакторе элемента (напомню, надо выделить весь элемент целиком и вызвать E,E) атрибут value и инициализируем его значениями номиналов элементов. Снимаем галочку показа имени атрибута.



Чтобы соединить элементы в схему, используем команду N (Net). Редактор перейдет в режим соединений выводов. Левой кнопкой кликаем, "паяем" выводы и тянем соединение к следующему выводу. Команды редактирования несложны. Любому узлу можно присвоить осмысленное имя. Например, выделим кликом цепь в районе Rload - вывод симистора. Команда A,A (Add Attribute). Пишем значение атрибута netname a (это пример, вы можете назвать узел схемы любым именем). Подтверждаем ОК. Все видимые атрибуты обычно показаны желтым цветом (в темной цветовой схеме). Кликая их, можно их перемещать при нажатой кнопке мыши, можно вращать командой E,R (Edit Rotate) относительно указателя мыши как центра вращения. Вращение идет по часовой стрелке на 90 градусов.



Схема готова. Напоследок поищем в библиотеках таймер 555. Этот элемент должен найтись! Вставлять его в схему пока не будем. Лучше запустите текстовый редактор и откройте файл, который мы только что правили в редакторе gschem и внимательно его рассмотрите. Если знать несложные правила, можно подправить все, что угодно, и без редактора gschem, в обычном текстовом редакторе. Файл текстовый и хорошо жмется в архивы. Этим UNIX и все ее клоны крайне выгодно отличаются от других операционных систем, где файлы с данными кодируются проприетарными двоичными форматами и хранятся буржуЯми в страшной тайне.

В следующем посте будет еще одна схема и много нового. Может быть, даже запустим симулятор. Кто знает...

Tags:

Profile

allisk
al_fuhrmann
al_fuhrmann

Latest Month

March 2017
S M T W T F S
   1234
567891011
12131415161718
19202122232425
262728293031 

Syndicate

RSS Atom
Powered by LiveJournal.com
Designed by yoksel