接続された Workspace での設計

Altium NEXUS can work with the following types of managed content server:

• Altium NEXUS Server - an on-premise local server for all your managed content.
• Altium Vault - an on-premise local server for all your managed content (now considered legacy).

A managed content server works in harmony with Altium NEXUS to provide an elegant answer to the question of handling design data with secured integrity. The Server not only provides rock-solid, secure storage of data, but also enables re-release of data as distinctly separate revisions - essentially tracking design changes over time, without overwriting any previously released data. It also caters for the lifecycle of the data to be managed, allowing people that need to use the data to see, at-a-glance, what stage the data has reached in its 'life' and therefore what it can be safely used for.

The Server is used to manage all managed data, including components, domain models, schematic sheets of circuitry and design templates. Indeed, you can even create and manage your entire design projects directly within the Server.

By furnishing a set of resuable design 'building blocks' within the Server, you can embark on fresh projects safe in the knowledge that each model, component, and higher-order design element has been ratified and approved for use, with no having to reinvent the wheel as it were. The Server becomes both the source and destination of design elements, with each new design utilizing elements realeased to, and managed through, the Server. And by designing only with elements from the Server, the integrity of those designs is inherently assured.

Server Items

Within a managed content server, each design entity that can be stored, managed, and reused, is represented as a specific type of Item. An Item is uniquely identified within the Server and can contain any number of Revisions, where a revision contains the data for that Item. Each time a change is made to the data contained within a revision - which for most Item types can be edited directly within an associated temporary editor - it is committed (or re-released) into a new revision of that Item, ensuring that no existing revision can ever be overwritten, and thereby ensuring the highest integrity.

An Item can have any number of revisions, which are essentially an evolution of that Item over time. A change is made and the new data content is committed/uploaded/released into a new revision. The data stored in each revision of an item is therefore typically different. To identify between these different revisions of an Item, a revision identifier (ID) is used, which in combination with the Item ID creates a unique identifier for each release of an Item. This gives us the Item-Revision.

Another important aspect of an Item Revision is its Lifecycle State. This is another identifier that can be used to quickly assess what stage that revision has currently reached in its life, and what designers are therefore authorized to do with it. Where the Revision reflects design changes made to the Item, the Lifecycle State reflects the state of the item from a business perspective, such as Planned, New From Design, For Production, Obsolete, and so on.

The Explorer Panel

Providing the direct interface to your managed content server is Altium NEXUS's Explorer panel. From this panel you can perform many activities, including:

• Creating and managing the organizational structure used in the Server.
• Creating any number of Items, each representative of a design object.
• Direct editing and placement of Item Revisions.
• Reviewing and managing the lifecycle of Item revisions.
• Interrogating the usage of a particular Item revision (Where-Used).
• Browsing and managing supply chain information for Component Items.
• Downloading stored data, including data generated through the managed release of board design projects.

The Explorer panel becomes your trusty right-hand, presenting a collection of features that can really enhance your productivity when working with the managed content server through Altium NEXUS.

Direct Editing

A managed content server provides a flexible and secure method of centralizing the storage and management of all types of design data used in Altium NEXUS. From the schematic model to the component, from managed sheets through to completed PCB designs, the Server delivers an ideal method of storing and managing your electronic design data.

Many design entities can be edited and released into the initial revision of a corresponding, and newly-created server Item, courtesy of the Server's support for direct editing. Direct editing frees you from the shackles of separate version-controlled source data. You can simply edit a supported Item type using a temporary editor loaded with the latest source direct from the server itself. And once editing is complete, the entity is released (or re-released) into a subsequent planned revision of its parent Item, and the temporary editor closed. There are no files on your hard drive, no questioning whether you are working with the correct or latest source, and no having to maintain separate version control software. The managed content server handles it all, with the same great integrity you've come to expect, and in a manner that greatly expedites changes to your data.

And at any stage, you can come back to any revision of a supported Item in the Server, and edit it directly. Simply right-click on the revision and choose the Edit command from the context menu. Once again, the temporary editor will open, with the entity contained in the revision opened for editing. Make changes as required, then commit the release of the document into the next revision of the item.

Controlled Access

A managed content server provides secure handling of data with high integrity, while providing both Design Team and Supply Chain access to that data as needed. This latter aspect, of whom can access a Server, and more importantly what data they are allowed to access, is facilitated by the Server's user access control and sharing capabilities. These can be broken down into the following key areas:

• User Management
• Folder-level Sharing
• Item-level Sharing
• Item Revision-level Sharing

Folders, Items, and Item Revisions in a managed content server can be shared on a number of different levels, in effect defining both the level of visibility of the entity, and the level of security for access to it. This can range from being strictly private access by specified individuals or roles, through to levels for allowing anyone in the same organization to view or change that entity respectively.

Managed Components

Altium NEXUS, with its unified design approach, has traditionally used a component model that extends across all aspects of the electronics design process. However, to seamlessly fit the process of electronics design into the encapsulating product development process as a whole, this model needs to evolve - extending to cover other aspects including other design processes (in particular MCAD and Industrial Design), as well as business processes (such as procurement and manufacturing) that intersect with the product development process.

This evolved object model is known as the Unified Component Model.

Under this modeling paradigm, the design component, as seen by the designer, is separated from the Manufacturer and/or Vendor parts. This information is not defined as part of the component. Instead, Part Choices are used to map the design component to one or more Manufacturer Parts, listed in a Part Catalog, which in turn can be mapped to one or more Vendor parts, allowing the designer to state up-front, what real parts can be used for any given design component used in a design.

These components, along with their part choices, are stored in the managed content server. A component is stored as a series of revisions of a uniquely-identifiable Component Item. Each revision is lifecycle-managed, providing collections of certified components, authorized to be re-instantiated into new design projects, manufactured into prototypes, or used for production runs. In short, a catalog of components implemented through server-based 'libraries'.