/*******************************************************/ /* Module de generation de la Netliste , selon Formats */ /*******************************************************/ #include "fctsys.h" #include "gr_basic.h" #include "common.h" #include "confirm.h" #include "kicad_string.h" #include "gestfich.h" #include "program.h" #include "libcmp.h" #include "general.h" #include "netlist.h" #include "protos.h" /* Routines locales */ static void Write_GENERIC_NetList( WinEDA_SchematicFrame* frame, const wxString& FullFileName ); static void WriteNetListPCBNEW( WinEDA_SchematicFrame* frame, FILE* f, bool with_pcbnew ); static void WriteNetListCADSTAR( WinEDA_SchematicFrame* frame, FILE* f ); static void WriteListOfNetsCADSTAR( FILE* f, ObjetNetListStruct* ObjNet ); static void WriteNetListPspice( WinEDA_SchematicFrame* frame, FILE* f, bool use_netnames ); static void WriteGENERICListOfNets( FILE* f, ObjetNetListStruct* ObjNet ); static void AddPinToComponentPinList( SCH_COMPONENT* Component, DrawSheetPath* sheet, LibDrawPin* PinEntry ); static void FindAllsInstancesOfComponent( SCH_COMPONENT* Component, EDA_LibComponentStruct* Entry, DrawSheetPath* Sheet_in ); static int SortPinsByNum( ObjetNetListStruct** Pin1, ObjetNetListStruct** Pin2 ); static void EraseDuplicatePins( ObjetNetListStruct** TabPin, int NbrPin ); static void ClearUsedFlags( void ); /* Local variables */ static int s_SortedPinCount; static ObjetNetListStruct** s_SortedComponentPinList; // list of references arready found for multi part per packages components // (used to avoid to used more than one time a component) static wxArrayString s_ReferencesAlreadyFound; /******************************************************************************/ void WriteNetList( WinEDA_SchematicFrame* frame, const wxString& FileNameNL, bool use_netnames ) /*******************************************************************************/ /* Create the netlist file ( Format is given by g_NetFormat ) * bool use_netnames is used only for Spice netlist */ { FILE* f = NULL; if( g_NetFormat < NET_TYPE_CUSTOM1 ) { if( ( f = wxFopen( FileNameNL, wxT( "wt" ) ) ) == NULL ) { wxString msg = _( "Failed to create file " ) + FileNameNL; DisplayError( frame, msg ); return; } } wxBusyCursor Busy; switch( g_NetFormat ) { case NET_TYPE_PCBNEW: WriteNetListPCBNEW( frame, f, TRUE ); fclose( f ); break; case NET_TYPE_ORCADPCB2: WriteNetListPCBNEW( frame, f, FALSE ); fclose( f ); break; case NET_TYPE_CADSTAR: WriteNetListCADSTAR( frame, f ); fclose( f ); break; case NET_TYPE_SPICE: WriteNetListPspice( frame, f, use_netnames ); fclose( f ); break; default: Write_GENERIC_NetList( frame, FileNameNL ); break; } } /****************************************************************************/ static SCH_COMPONENT* FindNextComponentAndCreatPinList( EDA_BaseStruct* DrawList, DrawSheetPath* sheet ) /****************************************************************************/ /* Find a "suitable" component from the DrawList * build its pin list s_SortedComponentPinList. * The list is sorted by pin num * A suitable component is a "new" real component (power symbols are not considered) * * alloc memory for s_SortedComponentPinList if s_SortedComponentPinList == NULL * Must be deallocated by the user */ { SCH_COMPONENT* Component = NULL; EDA_LibComponentStruct* Entry; LibEDA_BaseStruct* DEntry; s_SortedPinCount = 0; for( ; DrawList != NULL; DrawList = DrawList->Next() ) { if( DrawList->Type() != TYPE_SCH_COMPONENT ) continue; Component = (SCH_COMPONENT*) DrawList; /* Power symbol and other component which have the reference starting by * "#" are not included in netlist (pseudo or virtual components) */ wxString str = Component->GetRef( sheet ); if( str[0] == '#' ) // ignore it continue; //if( Component->m_FlagControlMulti == 1 ) // continue; /* yes */ // removed because with multiple instances of one schematic // (several sheets pointing to 1 screen), this will be erroneously be toggled. Entry = FindLibPart( Component->m_ChipName.GetData(), wxEmptyString, FIND_ROOT ); if( Entry == NULL ) continue; if( Entry->m_UnitCount > 1 ) // Multi parts per package: test if already visited: { bool found = false; for( unsigned jj = 0; jj < s_ReferencesAlreadyFound.GetCount(); jj++ ) { if( str == s_ReferencesAlreadyFound[jj] ) // Already visited { found = true; break; } } if( found ) continue; else { s_ReferencesAlreadyFound.Add( str ); // Mark as visited } } /* Create the pin table for this component */ int ii = sizeof(ObjetNetListStruct*) * MAXPIN; if( s_SortedComponentPinList == NULL ) s_SortedComponentPinList = (ObjetNetListStruct**) MyMalloc( ii ); memset( s_SortedComponentPinList, 0, ii ); DEntry = Entry->m_Drawings; if( Entry->m_UnitCount <= 1 ) // One part per package { for( ; DEntry != NULL; DEntry = DEntry->Next() ) { if( DEntry->Type() != COMPONENT_PIN_DRAW_TYPE ) continue; if( DEntry->m_Unit && ( DEntry->m_Unit != Component->GetUnitSelection( sheet ) ) ) continue; if( DEntry->m_Convert && (DEntry->m_Convert != Component->m_Convert) ) continue; { AddPinToComponentPinList( Component, sheet, (LibDrawPin*) DEntry ); } } } else // Multiple parts per package: Collect all parts ans pins for this reference FindAllsInstancesOfComponent( Component, Entry, sheet ); /* Sort Pins in s_SortedComponentPinList by pin number */ qsort( s_SortedComponentPinList, s_SortedPinCount, sizeof(ObjetNetListStruct*), ( int( * ) ( const void*, const void* ) )SortPinsByNum ); /* Remove duplicate Pins in s_SortedComponentPinList */ EraseDuplicatePins( s_SortedComponentPinList, s_SortedPinCount ); return Component; } return NULL; } /**************************************************************************************/ static wxString ReturnPinNetName( ObjetNetListStruct* Pin, const wxString& DefaultFormatNetname ) /**************************************************************************************/ /* Return the net name for the pin Pin. * Net name is: * "?" if pin not connected * "netname" for global net (like gnd, vcc .. * "netname_sheetnumber" for the usual nets */ { int netcode = Pin->GetNet(); wxString NetName; if( (netcode == 0 ) || ( Pin->m_FlagOfConnection != PAD_CONNECT ) ) { return NetName; } else { int jj; for( jj = 0; jj < g_NbrObjNet; jj++ ) { if( g_TabObjNet[jj].GetNet() != netcode ) continue; if( ( g_TabObjNet[jj].m_Type != NET_HIERLABEL) && ( g_TabObjNet[jj].m_Type != NET_LABEL) && ( g_TabObjNet[jj].m_Type != NET_PINLABEL) ) continue; NetName = *g_TabObjNet[jj].m_Label; break; } if( !NetName.IsEmpty() ) { if( g_TabObjNet[jj].m_Type != NET_PINLABEL ) { wxString lnet = NetName; NetName = g_TabObjNet[jj].m_SheetList.PathHumanReadable(); // If sheet path is too long, use the time stamp name insteed if ( NetName.Length() > 32 ) NetName = g_TabObjNet[jj].m_SheetList.Path(); NetName += lnet; } } else { NetName.Printf( DefaultFormatNetname.GetData(), netcode ); } } return NetName; } /***********************************************************************/ void Write_GENERIC_NetList( WinEDA_SchematicFrame* frame, const wxString& FullFileName ) /***********************************************************************/ /* Create a generic netlist, and call an external netlister * to change the netlist syntax and create the file */ { wxString Line, FootprintName; DrawSheetPath* sheet; EDA_BaseStruct* SchItem; SCH_COMPONENT* Component; wxString netname; int ii; FILE* tmpfile; wxString TmpFullFileName = FullFileName; ChangeFileNameExt( TmpFullFileName, wxT( ".tmp" ) ); if( ( tmpfile = wxFopen( TmpFullFileName, wxT( "wt" ) ) ) == NULL ) { wxString msg = _( "Failed to create file " ) + TmpFullFileName; DisplayError( frame, msg ); return; } ClearUsedFlags( ); /* Reset the flags FlagControlMulti in all schematic files*/ fprintf( tmpfile, "$BeginNetlist\n" ); /* Create netlist module section */ fprintf( tmpfile, "$BeginComponentList\n" ); EDA_SheetList SheetList; for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() ) { for( SchItem = sheet->LastDrawList(); SchItem != NULL; SchItem = SchItem->Next() ) { SchItem = Component = FindNextComponentAndCreatPinList( SchItem, sheet ); if( Component == NULL ) break; // No component left FootprintName.Empty(); if( !Component->GetField( FOOTPRINT )->IsVoid() ) { FootprintName = Component->GetField( FOOTPRINT )->m_Text; FootprintName.Replace( wxT( " " ), wxT( "_" ) ); } fprintf( tmpfile, "\n$BeginComponent\n" ); fprintf( tmpfile, "TimeStamp=%8.8lX\n", Component->m_TimeStamp ); fprintf( tmpfile, "Footprint=%s\n", CONV_TO_UTF8( FootprintName ) ); Line = wxT( "Reference=" ) + Component->GetRef( sheet ) + wxT( "\n" ); Line.Replace( wxT( " " ), wxT( "_" ) ); fprintf( tmpfile, CONV_TO_UTF8( Line ) ); Line = Component->GetField( VALUE )->m_Text; Line.Replace( wxT( " " ), wxT( "_" ) ); fprintf( tmpfile, "Value=%s\n", CONV_TO_UTF8( Line ) ); Line = Component->m_ChipName; Line.Replace( wxT( " " ), wxT( "_" ) ); fprintf( tmpfile, "Libref=%s\n", CONV_TO_UTF8( Line ) ); // Write pin list: fprintf( tmpfile, "$BeginPinList\n" ); for( ii = 0; ii < s_SortedPinCount; ii++ ) { ObjetNetListStruct* Pin = s_SortedComponentPinList[ii]; if( !Pin ) continue; netname = ReturnPinNetName( Pin, wxT( "$-%.6d" ) ); if( netname.IsEmpty() ) netname = wxT( "?" ); fprintf( tmpfile, "%.4s=%s\n", (char*) &Pin->m_PinNum, CONV_TO_UTF8( netname ) ); } fprintf( tmpfile, "$EndPinList\n" ); fprintf( tmpfile, "$EndComponent\n" ); } } MyFree( s_SortedComponentPinList ); s_SortedComponentPinList = NULL; fprintf( tmpfile, "$EndComponentList\n" ); fprintf( tmpfile, "\n$BeginNets\n" ); WriteGENERICListOfNets( tmpfile, g_TabObjNet ); fprintf( tmpfile, "$EndNets\n" ); fprintf( tmpfile, "\n$EndNetlist\n" ); fclose( tmpfile ); // Call the external module (plug in ) if( g_NetListerCommandLine.IsEmpty() ) return; wxString CommandFile; if( wxIsAbsolutePath( g_NetListerCommandLine ) ) CommandFile = g_NetListerCommandLine; else CommandFile = FindKicadFile( g_NetListerCommandLine ); CommandFile += wxT( " " ) + TmpFullFileName; CommandFile += wxT( " " ) + FullFileName; ProcessExecute( CommandFile, wxEXEC_SYNC ); } /**********************************/ static void ClearUsedFlags( void ) /*********************************/ /* Clear flag list, used in netlist generation */ { s_ReferencesAlreadyFound.Clear(); } /*************************************************************/ static void WriteNetListPspice( WinEDA_SchematicFrame* frame, FILE* f, bool use_netnames ) /*************************************************************/ /* Routine de generation du fichier netliste ( Format PSPICE ) * si use_netnames = TRUE * les nodes sont identifies par le netname * sinon les nodes sont identifies par le netnumber * * tous les textes graphiques commen�ant par [.-+]pspice ou [.-+]gnucap * sont consideres comme des commandes a placer dans la netliste * [.-]pspice ou gnucap sont en debut * +pspice et +gnucap sont en fin de netliste */ { char Line[1024]; DrawSheetPath* sheet; EDA_BaseStruct* DrawList; SCH_COMPONENT* Component; int ii, nbitems; wxString text; wxArrayString SpiceCommandAtBeginFile, SpiceCommandAtEndFile; wxString msg; #define BUFYPOS_LEN 4 wxChar bufnum[BUFYPOS_LEN + 1]; DateAndTime( Line ); fprintf( f, "* %s (Spice format) creation date: %s\n\n", NETLIST_HEAD_STRING, Line ); /* Create text list starting by [.-]pspice , or [.-]gnucap (simulator commands) */ /* and create text list starting by [+]pspice , or [+]gnucap (simulator commands) */ bufnum[BUFYPOS_LEN] = 0; EDA_SheetList SheetList; for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() ) { for( DrawList = sheet->LastDrawList(); DrawList != NULL; DrawList = DrawList->Next() ) { wxChar ident; if( DrawList->Type() != TYPE_SCH_TEXT ) continue; #define DRAWTEXT ( (SCH_TEXT*) DrawList ) text = DRAWTEXT->m_Text; if( text.IsEmpty() ) continue; ident = text.GetChar( 0 ); if( ident != '.' && ident != '-' && ident != '+' ) continue; text.Remove( 0, 1 ); //Remove the first char. text.Remove( 6 ); //text contains 6 char. text.MakeLower(); if( ( text == wxT( "pspice" ) ) || ( text == wxT( "gnucap" ) ) ) { /* Put the Y position as an ascii string, for sort by vertical position, * using usual sort string by alphabetic value */ int ypos = DRAWTEXT->m_Pos.y; for( ii = 0; ii < BUFYPOS_LEN; ii++ ) { bufnum[BUFYPOS_LEN - 1 - ii] = (ypos & 63) + ' '; ypos >>= 6; } text = DRAWTEXT->m_Text.AfterFirst( ' ' ); msg.Printf( wxT( "%s %s" ), bufnum, text.GetData() ); // First BUFYPOS_LEN char are the Y position if( ident == '+' ) SpiceCommandAtEndFile.Add( msg ); else SpiceCommandAtBeginFile.Add( msg ); } } } /* Print texts starting by [.-]pspice , ou [.-]gnucap (of course, without the Y position string)*/ nbitems = SpiceCommandAtBeginFile.GetCount(); if( nbitems ) { SpiceCommandAtBeginFile.Sort(); for( ii = 0; ii < nbitems; ii++ ) { SpiceCommandAtBeginFile[ii].Remove( 0, BUFYPOS_LEN ); SpiceCommandAtBeginFile[ii].Trim( TRUE ); SpiceCommandAtBeginFile[ii].Trim( FALSE ); fprintf( f, "%s\n", CONV_TO_UTF8( SpiceCommandAtBeginFile[ii] ) ); } } fprintf( f, "\n" ); /* Create component list */ ClearUsedFlags(); /* Reset the flags FlagControlMulti in all schematic files*/ for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() ) { for( DrawList = sheet->LastDrawList(); DrawList != NULL; DrawList = DrawList->Next() ) { DrawList = Component = FindNextComponentAndCreatPinList( DrawList, sheet ); if( Component == NULL ) break; fprintf( f, "%s ", CONV_TO_UTF8( Component->GetRef( sheet ) ) ); // Write pin list: for( ii = 0; ii < s_SortedPinCount; ii++ ) { ObjetNetListStruct* Pin = s_SortedComponentPinList[ii]; if( !Pin ) continue; wxString NetName = ReturnPinNetName( Pin, wxT( "N-%.6d" ) ); if( NetName.IsEmpty() ) NetName = wxT( "?" ); if( use_netnames ) fprintf( f, " %s", CONV_TO_UTF8( NetName ) ); else // Use number for net names (with net number = 0 for "GND" { // NetName = "0" is "GND" net for Spice if( NetName == wxT( "0" ) || NetName == wxT( "GND" ) ) fprintf( f, " 0" ); else fprintf( f, " %d", Pin->GetNet() ); } } fprintf( f, " %s\n", CONV_TO_UTF8( Component->GetField( VALUE )->m_Text ) ); } } MyFree( s_SortedComponentPinList ); s_SortedComponentPinList = NULL; /* Print texts starting by [+]pspice , ou [+]gnucap */ nbitems = SpiceCommandAtEndFile.GetCount(); if( nbitems ) { fprintf( f, "\n" ); SpiceCommandAtEndFile.Sort(); for( ii = 0; ii < nbitems; ii++ ) { SpiceCommandAtEndFile[ii].Remove( 0, +BUFYPOS_LEN ); SpiceCommandAtEndFile[ii].Trim( TRUE ); SpiceCommandAtEndFile[ii].Trim( FALSE ); fprintf( f, "%s\n", CONV_TO_UTF8( SpiceCommandAtEndFile[ii] ) ); } } fprintf( f, "\n.end\n" ); } /*****************************************************************************************/ static void WriteNetListPCBNEW( WinEDA_SchematicFrame* frame, FILE* f, bool with_pcbnew ) /*****************************************************************************************/ /* Routine de generation du fichier netliste ( Format ORCAD PCB 2 ameliore ) * si with_pcbnew = TRUE * format PCBNEW (OrcadPcb2 + commentaires et liste des nets) * si with_pcbnew = FALSE * Format ORCADPCB2 strict */ { wxString Line, FootprintName; char Buf[256]; DrawSheetPath* sheet; EDA_BaseStruct* DrawList; SCH_COMPONENT* Component; int ii; OBJ_CMP_TO_LIST* CmpList = NULL; int CmpListCount = 0, CmpListSize = 1000; DateAndTime( Buf ); if( with_pcbnew ) fprintf( f, "# %s created %s\n(\n", NETLIST_HEAD_STRING, Buf ); else fprintf( f, "( { %s created %s }\n", NETLIST_HEAD_STRING, Buf ); /* Create netlist module section */ ClearUsedFlags( ); /* Reset the flags FlagControlMulti in all schematic files*/ EDA_SheetList SheetList; for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() ) { for( DrawList = sheet->LastDrawList(); DrawList != NULL; DrawList = DrawList->Next() ) { DrawList = Component = FindNextComponentAndCreatPinList( DrawList, sheet ); if( Component == NULL ) break; /* Get the Component FootprintFilter and put the component in CmpList if filter is not void */ EDA_LibComponentStruct* Entry; if( ( Entry = FindLibPart( Component->m_ChipName.GetData(), wxEmptyString, FIND_ROOT ) ) != NULL ) { if( Entry->m_FootprintList.GetCount() != 0 ) /* Put in list */ { if( CmpList == NULL ) { CmpList = (OBJ_CMP_TO_LIST*) MyZMalloc( sizeof(OBJ_CMP_TO_LIST) * CmpListSize ); } if( CmpListCount >= CmpListSize ) { CmpListSize += 1000; CmpList = (OBJ_CMP_TO_LIST*) realloc( CmpList, sizeof(OBJ_CMP_TO_LIST) * CmpListSize ); } CmpList[CmpListCount].m_RootCmp = Component; strcpy( CmpList[CmpListCount].m_Reference, Component->GetRef( sheet ).mb_str() ); CmpListCount++; } } if( !Component->GetField( FOOTPRINT )->IsVoid() ) { FootprintName = Component->GetField( FOOTPRINT )->m_Text; FootprintName.Replace( wxT( " " ), wxT( "_" ) ); } else FootprintName = wxT( "$noname" ); Line = Component->GetRef( sheet ); fprintf( f, " ( %s %s", CONV_TO_UTF8( Component->GetPath( sheet ) ), CONV_TO_UTF8( FootprintName ) ); fprintf( f, " %s", CONV_TO_UTF8( Line ) ); Line = Component->GetField( VALUE )->m_Text; Line.Replace( wxT( " " ), wxT( "_" ) ); fprintf( f, " %s", CONV_TO_UTF8( Line ) ); if( with_pcbnew ) // Add the lib name for this component { Line = Component->m_ChipName; Line.Replace( wxT( " " ), wxT( "_" ) ); fprintf( f, " {Lib=%s}", CONV_TO_UTF8( Line ) ); } fprintf( f, "\n" ); // Write pin list: for( ii = 0; ii < s_SortedPinCount; ii++ ) { ObjetNetListStruct* Pin = s_SortedComponentPinList[ii]; if( !Pin ) continue; wxString netname = ReturnPinNetName( Pin, wxT( "N-%.6d" ) ); if( netname.IsEmpty() ) netname = wxT( "?" ); netname.Replace( wxT( " " ), wxT( "_" ) ); fprintf( f, " ( %4.4s %s )\n", (char*) &Pin->m_PinNum, CONV_TO_UTF8( netname ) ); } fprintf( f, " )\n" ); } } fprintf( f, ")\n*\n" ); MyFree( s_SortedComponentPinList ); s_SortedComponentPinList = NULL; /* Write the allowed footprint list for each component */ if( with_pcbnew && CmpList ) { fprintf( f, "{ Allowed footprints by component:\n" ); EDA_LibComponentStruct* Entry; for( ii = 0; ii < CmpListCount; ii++ ) { Component = CmpList[ii].m_RootCmp; Entry = FindLibPart( Component->m_ChipName.GetData(), wxEmptyString, FIND_ROOT ); //Line.Printf(_("%s"), CmpList[ii].m_Ref); //Line.Replace( wxT( " " ), wxT( "_" ) ); unsigned int i; for( i = 0; im_FootprintList.GetCount(); jj++ ) { fprintf( f, " %s\n", CONV_TO_UTF8( Entry->m_FootprintList[jj] ) ); } fprintf( f, "$endlist\n" ); } fprintf( f, "$endfootprintlist\n}\n" ); } if( CmpList ) free( CmpList ); if( with_pcbnew ) { fprintf( f, "{ Pin List by Nets\n" ); WriteGENERICListOfNets( f, g_TabObjNet ); fprintf( f, "}\n" ); fprintf( f, "#End\n" ); } } /*************************************************************************************/ static void AddPinToComponentPinList( SCH_COMPONENT* Component, DrawSheetPath* sheetlist, LibDrawPin* Pin ) /*************************************************************************************/ /* Add a new pin description in the pin list s_SortedComponentPinList * a pin description is a pointer to the corresponding structure * created by BuildNetList() in the table g_TabObjNet */ { int ii; /* Search the PIN description for Pin in g_TabObjNet*/ for( ii = 0; ii < g_NbrObjNet; ii++ ) { if( g_TabObjNet[ii].m_Type != NET_PIN ) continue; if( g_TabObjNet[ii].m_Link != Component ) continue; if( g_TabObjNet[ii].m_SheetList != *sheetlist ) continue; if( g_TabObjNet[ii].m_PinNum != Pin->m_PinNum ) continue; { s_SortedComponentPinList[s_SortedPinCount] = &g_TabObjNet[ii]; s_SortedPinCount++; if( s_SortedPinCount >= MAXPIN ) { /* Log message for Internal error */ DisplayError( NULL, wxT( "AddPinToComponentPinList err: MAXPIN reached" ) ); return; } } } } /**********************************************************************/ static void EraseDuplicatePins( ObjetNetListStruct** TabPin, int NbrPin ) /**********************************************************************/ /* * Function to remove duplicate Pins in the TabPin pin list * (This is a list of pins found in the whole schematic, for a given component) * These duplicate pins were put in list because some pins (powers... ) * are found more than one time when we have a multiple parts per package component * for instance, a 74ls00 has 4 parts, and therefor the VCC pin and GND pin apperas 4 times * in the list. */ { int ii, jj; for( ii = 0; ii < NbrPin - 1; ii++ ) { if( TabPin[ii] == NULL ) continue; /* Deja supprime */ if( TabPin[ii]->m_PinNum != TabPin[ii + 1]->m_PinNum ) continue; /* 2 Pins doublees */ for( jj = ii + 1; jj < NbrPin; jj++ ) { if( TabPin[ii]->m_PinNum != TabPin[jj]->m_PinNum ) break; TabPin[jj] = NULL; } } } /**********************************************************************************/ static void FindAllsInstancesOfComponent( SCH_COMPONENT* Component_in, EDA_LibComponentStruct* Entry, DrawSheetPath* Sheet_in ) /**********************************************************************************/ /** * Used for multiple parts per package components * Search all instances of Component_in, * Calls AddPinToComponentPinList() to and pins founds to the current component pin list */ { EDA_BaseStruct* SchItem; SCH_COMPONENT* Component2; LibEDA_BaseStruct* DEntry; DrawSheetPath* sheet; wxString str, Reference = Component_in->GetRef( Sheet_in ); EDA_SheetList SheetList; for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() ) { for( SchItem = sheet->LastDrawList(); SchItem; SchItem = SchItem->Next() ) { if( SchItem->Type() != TYPE_SCH_COMPONENT ) continue; Component2 = (SCH_COMPONENT*) SchItem; str = Component2->GetRef( sheet ); if( str.CmpNoCase( Reference ) != 0 ) continue; if( Entry && Entry->m_Drawings != NULL ) { DEntry = Entry->m_Drawings; for( ; DEntry != NULL; DEntry = DEntry->Next() ) { if( DEntry->Type() != COMPONENT_PIN_DRAW_TYPE ) continue; if( DEntry->m_Unit && ( DEntry->m_Unit != Component2->GetUnitSelection( sheet ) ) ) continue; if( DEntry->m_Convert && (DEntry->m_Convert != Component2->m_Convert) ) continue; // A suitable pin in found: add it to the current list AddPinToComponentPinList( Component2, sheet, (LibDrawPin*) DEntry ); } } } } } /**************************************************************************/ static int SortPinsByNum( ObjetNetListStruct** Pin1, ObjetNetListStruct** Pin2 ) /**************************************************************************/ /* Routine de comparaison pour le tri des pins par numero croissant * du tableau des pins s_SortedComponentPinList par qsort() */ { ObjetNetListStruct* Obj1, * Obj2; int Num1, Num2; char Line[5]; Obj1 = *Pin1; Obj2 = *Pin2; Num1 = Obj1->m_PinNum; Num2 = Obj2->m_PinNum; Line[4] = 0; memcpy( Line, &Num1, 4 ); Num1 = atoi( Line ); memcpy( Line, &Num2, 4 ); Num2 = atoi( Line ); return Num1 - Num2; } /*************************************************************************/ static void WriteGENERICListOfNets( FILE* f, ObjetNetListStruct* ObjNet ) /*************************************************************************/ /* Ecrit dans le fichier f la liste des nets ( classee par NetCodes ), et des * elements qui y sont connectes */ { int ii, jj; int NetCode, LastNetCode = -1; int SameNetcodeCount = 0; SCH_COMPONENT* Cmp; wxString NetName, CmpRef; wxString NetcodeName; char FirstItemInNet[1024]; for( ii = 0; ii < g_NbrObjNet; ii++ ) { if( ( NetCode = ObjNet[ii].GetNet() ) != LastNetCode ) // New net found, write net id; { SameNetcodeCount = 0; // Items count for this net NetName.Empty(); for( jj = 0; jj < g_NbrObjNet; jj++ ) // Find a label (if exists) for this net { if( ObjNet[jj].GetNet() != NetCode ) continue; if( ( ObjNet[jj].m_Type != NET_HIERLABEL) && ( ObjNet[jj].m_Type != NET_LABEL) && ( ObjNet[jj].m_Type != NET_PINLABEL) ) continue; NetName = *g_TabObjNet[jj].m_Label; break; } NetcodeName.Printf( wxT( "Net %d " ), NetCode ); NetcodeName += wxT( "\"" ); if( !NetName.IsEmpty() ) { if( g_TabObjNet[jj].m_Type != NET_PINLABEL ) { // usual net name, prefix it by the sheet path NetcodeName += g_TabObjNet[jj].m_SheetList.PathHumanReadable(); } NetcodeName += NetName; } NetcodeName += wxT( "\"" ); // Add the netname without prefix, in cases we need only the "short" netname NetcodeName += wxT( " \"" ) + NetName + wxT( "\"" ); LastNetCode = NetCode; } if( ObjNet[ii].m_Type != NET_PIN ) continue; Cmp = (SCH_COMPONENT*) ObjNet[ii].m_Link; CmpRef = Cmp->GetRef( &ObjNet[ii].m_SheetList ); //is this correct? if( CmpRef.StartsWith( wxT( "#" ) ) ) continue; // Pseudo component (Like Power symbol) // Print the pin list for this net, if 2 or more items are connected: SameNetcodeCount++; if( SameNetcodeCount == 1 ) /* first item for this net found, * Print this connection, when a second item will be found */ { sprintf( FirstItemInNet, " %s %.4s\n", CONV_TO_UTF8( CmpRef ), (const char*) &ObjNet[ii].m_PinNum ); } if( SameNetcodeCount == 2 ) // Second item for this net found, Print the Net name, and the first item { fprintf( f, "%s\n", CONV_TO_UTF8( NetcodeName ) ); fputs( FirstItemInNet, f ); } if( SameNetcodeCount >= 2 ) fprintf( f, " %s %.4s\n", CONV_TO_UTF8( CmpRef ), (const char*) &ObjNet[ii].m_PinNum ); } } /* Generation des netlistes au format CadStar */ wxString StartLine( wxT( "." ) ); /*********************************************************/ static void WriteNetListCADSTAR( WinEDA_SchematicFrame* frame, FILE* f ) /*********************************************************/ /* Routine de generation du fichier netliste ( Format CADSTAR ) * Entete: * ..HEA * ..TIM 2004 07 29 16 22 17 * ..APP "Cadstar RINF Output - Version 6.0.2.3" * ..UNI INCH 1000.0 in * ..TYP FULL * * liste des composants: * ..ADD_COM X1 "CNT D41612 (48PTS MC CONTOUR)" * ..ADD_COM U2 "74HCT245D" "74HCT245D" * * Connexions: * ..ADD_TER RR2 6 "$42" * ..TER U1 100 * CA 6 * * ..ADD_TER U2 6 "$59" * ..TER U7 39 * U6 17 * U1 122 * * ..ADD_TER P2 1 "$9" * ..TER T3 1 * U1 14 */ { wxString StartCmpDesc = StartLine + wxT( "ADD_COM" ); wxString msg; wxString FootprintName; char Line[1024]; DrawSheetPath* sheet; EDA_BaseStruct* DrawList; SCH_COMPONENT* Component; wxString Title = g_Main_Title + wxT( " " ) + GetBuildVersion(); fprintf( f, "%sHEA\n", CONV_TO_UTF8( StartLine ) ); DateAndTime( Line ); fprintf( f, "%sTIM %s\n", CONV_TO_UTF8( StartLine ), Line ); fprintf( f, "%sAPP ", CONV_TO_UTF8( StartLine ) ); fprintf( f, "\"%s\"\n", CONV_TO_UTF8( Title ) ); fprintf( f, "\n" ); /* Create netlist module section */ ClearUsedFlags( ); /* Reset the flags FlagControlMulti in all schematic files*/ EDA_SheetList SheetList; for( sheet = SheetList.GetFirst(); sheet != NULL; sheet = SheetList.GetNext() ) { for( DrawList = sheet->LastDrawList(); DrawList != NULL; DrawList = DrawList->Next() ) { DrawList = Component = FindNextComponentAndCreatPinList( DrawList, sheet ); if( Component == NULL ) break; if( !Component->GetField( FOOTPRINT )->IsVoid() ) { FootprintName = Component->GetField( FOOTPRINT )->m_Text; FootprintName.Replace( wxT( " " ), wxT( "_" ) ); } else FootprintName = wxT( "$noname" ); msg = Component->GetRef( sheet ); fprintf( f, "%s ", CONV_TO_UTF8( StartCmpDesc ) ); fprintf( f, "%s", CONV_TO_UTF8( msg ) ); msg = Component->GetField( VALUE )->m_Text; msg.Replace( wxT( " " ), wxT( "_" ) ); fprintf( f, " \"%s\"", CONV_TO_UTF8( msg ) ); fprintf( f, "\n" ); } } fprintf( f, "\n" ); MyFree( s_SortedComponentPinList ); s_SortedComponentPinList = NULL; WriteListOfNetsCADSTAR( f, g_TabObjNet ); fprintf( f, "\n%sEND\n", CONV_TO_UTF8( StartLine ) ); } /*************************************************************************/ static void WriteListOfNetsCADSTAR( FILE* f, ObjetNetListStruct* ObjNet ) /*************************************************************************/ /* Ecrit dans le fichier f la liste des nets ( classee par NetCodes ), et des * pins qui y sont connectes * format: * .ADD_TER RR2 6 "$42" * .TER U1 100 * CA 6 */ { wxString InitNetDesc = StartLine + wxT( "ADD_TER" ); wxString StartNetDesc = StartLine + wxT( "TER" ); wxString NetcodeName, InitNetDescLine; int ii, jj, print_ter = 0; int NetCode, LastNetCode = -1; SCH_COMPONENT* Cmp; wxString NetName; for( ii = 0; ii < g_NbrObjNet; ii++ ) ObjNet[ii].m_Flag = 0; for( ii = 0; ii < g_NbrObjNet; ii++ ) { // Get the NetName of the current net : if( ( NetCode = ObjNet[ii].GetNet() ) != LastNetCode ) { NetName.Empty(); for( jj = 0; jj < g_NbrObjNet; jj++ ) { if( ObjNet[jj].GetNet() != NetCode ) continue; if( ( ObjNet[jj].m_Type != NET_HIERLABEL) && ( ObjNet[jj].m_Type != NET_LABEL) && ( ObjNet[jj].m_Type != NET_PINLABEL) ) continue; NetName = *ObjNet[jj].m_Label; break; } NetcodeName = wxT( "\"" ); if( !NetName.IsEmpty() ) { NetcodeName += NetName; if( g_TabObjNet[jj].m_Type != NET_PINLABEL ) { NetcodeName = g_TabObjNet[jj].m_SheetList.PathHumanReadable() + NetcodeName; //NetcodeName << wxT("_") << // g_TabObjNet[jj].m_SheetList.PathHumanReadable(); } } else // this net has no name: create a default name $ NetcodeName << wxT( "$" ) << NetCode; NetcodeName += wxT( "\"" ); LastNetCode = NetCode; print_ter = 0; } if( ObjNet[ii].m_Type != NET_PIN ) continue; if( ObjNet[ii].m_Flag != 0 ) continue; Cmp = (SCH_COMPONENT*) ObjNet[ii].m_Link; wxString refstr = Cmp->GetRef( &(ObjNet[ii].m_SheetList) ); if( refstr[0] == '#' ) continue; // Pseudo composant (symboles d'alims) switch( print_ter ) { case 0: { char buf[5]; wxString str_pinnum; strncpy( buf, (char*) &ObjNet[ii].m_PinNum, 4 ); buf[4] = 0; str_pinnum = CONV_FROM_UTF8( buf ); InitNetDescLine.Printf( wxT( "\n%s %s %.4s %s" ), InitNetDesc.GetData(), refstr.GetData(), str_pinnum.GetData(), NetcodeName.GetData() ); } print_ter++; break; case 1: fprintf( f, "%s\n", CONV_TO_UTF8( InitNetDescLine ) ); fprintf( f, "%s %s %.4s\n", CONV_TO_UTF8( StartNetDesc ), CONV_TO_UTF8( refstr ), (char*) &ObjNet[ii].m_PinNum ); print_ter++; break; default: fprintf( f, " %s %.4s\n", CONV_TO_UTF8( refstr ), (char*) &ObjNet[ii].m_PinNum ); break; } ObjNet[ii].m_Flag = 1; // Recherche des pins redondantes et mise a 1 de m_Flag, // pour ne pas generer plusieurs fois la connexion for( jj = ii + 1; jj < g_NbrObjNet; jj++ ) { if( ObjNet[jj].GetNet() != NetCode ) break; if( ObjNet[jj].m_Type != NET_PIN ) continue; SCH_COMPONENT* tstcmp = (SCH_COMPONENT*) ObjNet[jj].m_Link; wxString p = Cmp->GetPath( &( ObjNet[ii].m_SheetList ) ); wxString tstp = tstcmp->GetPath( &( ObjNet[jj].m_SheetList ) ); if( p.Cmp( tstp ) != 0 ) continue; if( ObjNet[jj].m_PinNum == ObjNet[ii].m_PinNum ) ObjNet[jj].m_Flag = 1; } } }