JP7306088B2 - program group - Google Patents

Description

The present invention relates to technology for generating data to be input to a printer.

An application that generates data in a format that can be input to a printer and inputs the data to the printer is known (see, for example, Japanese Unexamined Patent Application Publication No. 2002-200013).

JP 2008-269265 A

The format of data, such as the structure of data that can be input to the printer and the type of code, may differ for each model of printer. Patent Literature 1 does not sufficiently disclose a technique for generating data having a form corresponding to the type of model.

SUMMARY OF THE INVENTION It is an object of the present invention to provide a technique for easily generating data in a format corresponding to the type of printer.

Various disclosures are made herein. The program of the disclosed example includes a first program and a second program executed by the computer of the information processing apparatus. The first program calls a first acquisition process for acquiring original data in a first format described in character code, and an API for converting the character code of the original data into a first specific code that is a specific character code. a second acquisition process of converting the character code of the acquired original data into the first specific code and acquiring the first data, which is the original data described in the first specific code; and causing the computer to execute a first output process of causing the second program to acquire first data. The second program has a correspondence table in which various types of type information indicating the types of printers are associated with code types indicating types of character codes determined by the types of printers. The second program includes: a third acquisition process for acquiring the first data; and a specific process for specifying, as a second specific code, the character code indicated by the code type associated with the type information based on the correspondence table. a generation process of converting the first specific code of the obtained first data into the identified second specific code to generate second data described in the second specific code; and causing the computer to execute a second output process of outputting second data.

The first program acquires first data obtained by converting the character code of the acquired original data into a first specific code, and causes the second program to acquire the acquired first data. That is, the second program acquires the first data described with the first specific code instead of the original data described with various character codes. The second program then converts the first specific code of the first data into a second specific code, which is a character code corresponding to the printer type, to generate the second data. Therefore, the second program can easily generate the second data compared to obtaining the original data described in various character codes. As a result, the program group of the disclosed example can easily generate the second data of the type corresponding to the type of printer.

FIG. 1A is a functional block diagram of the information processing apparatus 10, and FIG. 1B is a configuration diagram of the application 37. As shown in FIG. 2A is a functional block diagram of the printer 11, FIG. 2B is a diagram showing a conversion correspondence table 48, FIG. 2C is a diagram showing a database, and FIG. D) is a diagram showing an example of text placement on a label. FIG. 3 is a diagram for explaining processing executed by the touch panel 22, the UI module 41, the main body module 43, the common module 44 and the library 45, and the printer 11. As shown in FIG. FIG. 4 is a diagram for explaining the specific format data generation process. FIG. 5A is a diagram for explaining the arrangement position of partial data in PD3, FIG. 5B is a diagram showing the structure of a PD3 format database, and FIG. 5C is an arrangement table. FIG. 5D is a diagram showing the configuration of a specific format database. FIG. 6 is a diagram for explaining processing executed by the touch panel 22, the UI module 41, the main module 43, the common module 44, and the printer 11. As shown in FIG.

Hereinafter, embodiments of the present invention will be described with reference to the drawings as appropriate. It goes without saying that the embodiment described below is merely an example of disclosure, and can be modified as appropriate without changing the gist of the present invention. For example, the execution order of each process to be described later can be changed as appropriate without changing the gist of the present invention. Alternatively, each process described later can be omitted or changed as appropriate without changing the gist of the present invention.

In this embodiment, an application 37 installed in the information processing apparatus 10 shown in FIG. 1 will be described. The information processing device 10 is a mobile terminal, tablet, personal computer, or the like. An example in which the information processing apparatus 10 is a mobile terminal will be described below. That is, the application 37 installed in the mobile terminal will be described.

The application 37 is a program that generates print data to be sent to the printer 11 . The printer 11 is, for example, a label printer that prints on labels. However, the printer 11 is not limited to a label printer.

The application 37 has a function of converting image data to generate print data, and a function of converting a table created by the table creation program to generate data that can be input to the printer 11 . A detailed description will be given below.

The printer 11 includes a controller 51, a print engine 52, and a communication interface 53, as shown in FIG. 2(A). The print engine 52 has a transport mechanism that transports a sheet such as a label, and a head that prints an image on the transported sheet. The head is, for example, a thermal head. However, the head may be an inkjet recording type head that ejects ink droplets. The communication interface 53 may be connected to the information processing device 10 using a USB cable, a LAN cable, or the like, or may be wirelessly connected to the information processing device 10 . The printer 11 communicates with the information processing device 10 through the communication interface 53 .

The controller 51 includes a CPU 61 as a central processing unit, a memory 62 and a bus 63 . The controller 51 is implemented by, for example, a patterned circuit board and various electronic components such as a microcomputer, various ICs, capacitors, and diodes mounted on the patterned circuit board.

The CPU 61 , memory 62 , print engine 52 and communication interface 53 are connected to a bus 63 . That is, the CPU 61 is connected to the memory 62 , the print engine 52 and the communication interface 53 via the bus 63 .

The CPU 61 pseudo-parallel executes an OS 66 and a control program 67, which will be described later. That is, the OS 66 and control program 67 are executed by so-called multitasking.

The memory 62 is, for example, a ROM, a RAM, an EEPROM, an HDD, a buffer provided in the CPU 61, or the like. The memory 62 has a program storage area 64 that stores an OS 66 and a control program 67, and a data storage area 65 that stores information and data. OS66 is an operating system.

The control program 67 has a function of inputting print data input through the communication interface 53 to the print engine 52 and causing the print engine 52 to perform printing. In addition, the control program 67 uses the input database (FIG. 2C) to create the template data for the label shown in FIG. have.

More specifically, the data storage area 65 of the memory 62 stores area data indicating the printing area of "TEXT1", area data indicating the printing area of "TEXT2", and area data indicating the printing area of "TEXT3". Stores the template data for the containing label. The template data may be stored in advance in the data storage area 65 as a default. It may be generated by an application 37 (to be described later) or another program and input to the printer 11 . A database input to the printer 11 has multiple records and multiple items. The multiple items are "number", "TEXT1", "TEXT2", and "TEXT3". The record has various characters entered in the input fields corresponding to each item. The characters "first floor", "air conditioning", and "200V" are entered in the input fields corresponding to the items of the record numbered "1".

The control program 67 reads, for example, the record identified by number "1" from the database. Then, the control program 67 converts the characters "1st floor", "air conditioning", and "200V" respectively registered in the items "TEXT1", "TEXT2", and "TEXT3" of the read record to ) are arranged in the print areas of “TEXT1”, “TEXT2”, and “TEXT3” shown in ) to generate data to be input to the print engine 52 . The control program 67 then inputs the generated data to the print engine 52 and causes the print engine 52 to print on the label. For example, the control program 67 reads records in numerical order to generate data, or accepts a user's specification and reads records of numbers designated by the user from the database to generate data.

A user of the printer 11 is, for example, a person who installs or maintains electrical equipment in a building. A user uses the printer 11 to create labels to be attached to electrical cables used in buildings, for example. The user inputs one database to the printer 11 using the application 37 of the information processing apparatus 10, which will be described later, and creates a label to be used for one building. The user then uses application 37 to input other databases into printer 11 to create labels for use on other buildings.

As shown in FIG. 1A, the information processing device 10 includes a controller 21 , a touch panel 22 and a communication interface 23 . The communication interface 23 communicates with the printer 11 using, for example, a Wi-Fi (registered trademark) or Bluetooth (registered trademark) communication standard, or a close proximity wireless communication standard such as NFC.

The touch panel 22 has a display panel 24 that displays characters, graphics, and the like, and a transparent film-like touch sensor 25 superimposed on the display panel 24 . The touch sensor 25 outputs position information indicating the position on the display panel 24 touched by the user. The positional information can be expressed as coordinates (x, y) on the xy plane, for example, with the upper left corner of the display panel 24 as the origin, the positive direction of the x-axis pointing rightward, and the positive direction of the y-axis pointing downward. . The UI module 41, which will be described later, determines that the icon or the like has been selected by the user when the position information indicating the icon or the like displayed on the display panel 24 is input from the touch sensor 25. FIG. The user inputs characters and numerical values to the UI module 41 by touching icons and the like. The information processing device 10 may have a microphone instead of the touch sensor 25 or together with the touch sensor 25 . The microphone converts the user's voice into an audio signal and inputs it to the controller 21 . If the information processing device 10 is a personal computer, a mouse or keyboard is connected to the information processing device 10 instead of the touch sensor 25 .

The controller 21 includes a CPU 31 as a central processing unit, a memory 32 and a bus 33 . CPU 31 is an example of a computer. The configuration of the controller 21 is substantially the same as the configuration of the controller 51 of the printer 11 .

The CPU 31 executes the OS 36, a UI module 41 of an application 37 (to be described later), a main module 43, a common module 44, and a library 45 in parallel in a pseudo manner. That is, the OS 36, UI module 41, body module 43, common module 44, and library 45 are executed by so-called multitasking. The body module 43 is an example of a first program. Library 45 is an example of a second program.

The configuration of the memory 32 is substantially the same as the configuration of the memory 62 of the printer 11 . The memory 32 has a program storage area 34 for storing an OS 36 and an application 37, and a data storage area 35 for storing information and data.

The OS 36 is, for example, Android (registered trademark) OS, iOS (registered trademark), Windows Phone (registered trademark), BlackBerry OS (registered trademark), or the like.

The OS 36 comprises a DLL (short for dynamic link library) having a second API (short for Application Programming Interface) 38 and a DLL having a fourth API 39 to be called by the application 37 . The second API 38 has a function of converting local character code into Unicode. A fourth API 39 has a function of transmitting data to the printer 11 through the communication interface 23 . Details will be described later. The second API 38 is an example of an API.

The application 37 includes a UI (abbreviation for User Interface) module 41 and a main program 42, as shown in FIG. 1B. Specifically, the application 37 includes a UI module 41 that accepts user input, and a main program 42 that generates print data and database data to be input to the printer 11 .

UI module 41 is designed by the developer of application 37 . A developer of the application 37 designs the UI module 41 according to the type of the OS 36, such as AndroidOS and iOS. The UI module 41 is written in the same program language as the OS 36 is written.

The main program 42 is provided to the developer of the application 37 by the vendor of the printer 11, for example. That is, the main body program 42 is a so-called SDK (abbreviation for Software Development Kit). A developer of the application 37 develops the application 37 by combining the main body program 42 provided by the vendor of the printer 11 and the designed UI module 41 .

The body program 42 includes a body module 43 , a common module 44 and a library 45 . Common module 44 is an example of a third program.

The body module 43 has a third API 46 called by the UI module 41 via the OS 36 . The third API 46 is used to acquire the database file path and database name (hereinafter referred to as database name) from the UI module 41 . Details will be described later.

The common module 44 is a module that converts image data into print data. The library 45 is a module that converts the form of database data into data in a form that can be input to the printer 11 . The common module 44 is also a module that instructs the library 45 to convert data.

The library 45 and common module 44 are written in the C++ programming language. Therefore, any program that can exchange information and data with a program written in C++ can transfer information and data to the library 45 and use the library 45 . That is, the common module 44 written in C++ can use the library 45 . Programs written in C++ that can exchange information and data with programs written in Objective-C and JNI (abbreviation of Java Native Interface) (Java is a registered trademark) and other wrappers It's a program. C++ is an example of a specific language. Objective-C and Java (registered trademark) are examples of OS languages.

The common module 44 has a fifth API 49 called by the body module 43 . The fifth API 49 is used by the common module 44 to acquire the database name, file path (hereinafter referred to as first file path), and model name from the main module 43 . Details will be described later.

The library 45 has a first API 47 called by the common module 44 and a conversion correspondence table 48 . A first API 47 is used by the library 45 to obtain the database name, first file path, and model name from the common module 44 . The conversion correspondence table 48, as shown in FIG. 2B, is a table showing the correspondence between model names, local code types, and arrangement types. The library 45 identifies the model name acquired from the main module 43 and the corresponding local code type and arrangement type in the conversion correspondence table 48, and uses the identified local code type and arrangement type to create a database that can be input to the printer 11. Generate data. Details will be described later. The conversion correspondence table 48 is an example of a correspondence table. A model name is an example of type information and format information. A local code type is an example of a code type.

Hereinafter, the process of generating a database in a form that can be input to the printer 11 by the library 45 will be described with reference to FIGS. 3, 4, and 5. FIG.

In this specification, basically, the processing of the CPU 31 according to the instructions written in the application 37 will be described. That is, the processes such as "judgment", "extraction", "selection", "calculation", "determination", "specification", "acquisition", "acceptance", "control", "setting", etc. in the following description are Processing of the CPU 31 is shown. Processing by the CPU 31 also includes hardware control via a controller such as the OS 36 . Note that "acquisition" is used as a concept that does not require a request. That is, the process of receiving data without the CPU 31 requesting it is also included in the concept of "the CPU 31 acquires data." Also, "data" in this specification is represented by a computer-readable bit string. Data having substantially the same meaning and content but different formats are treated as the same data. The same applies to "information" in this specification. Processing such as "command", "response", "request", etc. is performed by communicating information indicating "command", "response", "request", etc. Also, words such as "command", "response", "request", etc. may be described in the sense of information itself indicating "command", "response", "request", etc.

Also, the processing of the CPU 31 according to the instructions written in the program may be described with abbreviated words. For example, "performed by the CPU 31", "performed by the main module 43", "performed by the common module 44", and "performed by the library 45" may be described.

Also, the processing by the CPU 31 to determine whether or not the information A indicates that the matter B is conceptually described as "determine whether or not the information A is the matter B". There is The processing by the CPU 31 to determine whether information A indicates matter B or matter C is defined as "determining whether information A is matter B or matter C". It may be described conceptually as

Also, "data" and "information" in this specification are common in that they are bits or bit strings that can be handled by a computer. "Data" refers to anything that can be handled by a computer without considering the semantic content indicated by each bit. On the other hand, "information" indicates that the operation of the computer branches depending on the meaning indicated by each bit. Furthermore, the "instruction" is a control signal for prompting the destination device to perform the next operation, and may contain information, and itself has the property of information. There is also

The above distinction between "data" and "information" is not strict, and exceptions are allowed. For example, data may be temporarily treated as information, or information may be temporarily treated as data. Also, what is handled as data in one device may be handled as information in another device. Furthermore, information may be extracted from data, and data may be extracted from information.

In addition, "depending on" in this specification indicates that the processing described after the character string is executed when the condition described before the character string is satisfied. Note that the timing at which the process is executed may be after the condition is satisfied, and does not necessarily have to be immediately after the condition is satisfied.

The application 37 is activated by the OS 36, for example, according to an instruction from the table creation program that created the database. Alternatively, the application 37 is activated by the user's activation instruction input from the touch sensor 25 .

The body module 43 of the activated application 37 inputs, for example, a command to the OS 36 requesting a list of the names and model names of the printers 11 with which the OS 36 can communicate, and sends the list of the names and model names of the printers 11 to the OS 36 . (S11). Then, the body module 43 outputs the acquired list of names and model names of the printers 11 to the touch panel 22 via the OS 36 (S12). The touch panel 22 displays an input screen (not shown) having a list of names and model names of the printers 11 (S13). The input screen includes a list of the names and model names of the printers 11, as well as a text box for accepting input of database names. The input screen for selecting the name and model name of the printer 11 and the input screen for inputting the database name may be different.

The user selects the name and model name of one printer 11 and inputs the database name on the input screen (S14). The UI module 41 of the application 37 acquires the name, model name, and database name of the selected printer 11 (S14). Then, the UI module 41 calls the third API 46 of the body module 43 (S15), and transfers the selected model name and database name to the body module 43 (S16). The process of step S16 in which the body module 43 acquires the printer name is an example of the process of acquiring output destination information indicating the output destination of the second data. A printer name is an example of output destination information. The process of step S16 in which the main body module 43 acquires the model name of the printer is an example of the process of acquiring the type information.

The body module 43 inputs a command to the OS 36 and acquires a database file, which is a database file, or a first file path indicating the database, and a code type (S17). The code type indicates the type of character code used in the database. The character code indicated by the code type is, for example, any character code such as JIS, Shift-JIS, ASCII, EBCDIC, Unicode, and EUC. The first file path of the database or the database file and the code type may be passed from the OS 36 to the main module 43 when the application 37 is activated. An example in which the main module 43, the common module 44, and the library 45 transfer the database using a file path will be described below.

The database created by the table creating program described above is, for example, a CSV (abbreviation for Comma Separated Value) data format file. In the following description, a database generated as a CSV data format file by the table creation program will be described as a CSV database file. JIS, Shift-JIS, ASCII, EBCDIC, Unicode, and EUC are examples of character codes. A database file in CSV format is an example of original data in the first format. The process of step S17 in which the body module 43 acquires the database file or the first file path is an example of the first acquisition process.

The body module 43 is an API corresponding to the code type obtained in step S17, and calls the second API 38 provided by the OS 36, and transfers the first file path obtained in step S17 to the DLL provided by the OS 36 through the second API 38. . That is, the body module 43 instructs the DLL provided by the OS 36 to convert the character code of the CSV database indicated by the first file path into Unicode (S18). The DLL converts the character code of the database indicated by the first file path into Unicode. The DLL transfers the file path of the Unicode CSV database (hereinafter referred to as the second file path), which is a CSV database converted into Unicode, to the main module 43 . Unicode is an example of the first specific code. A Unicode CSV database is an example of the first data. Note that if the CSV database file indicated by the first file path acquired by the body module 43 in step S17 is written in Unicode, the process of step S18 is omitted.

The body module 43 acquires the second file path from the DLL provided by the OS 36 (S19). The process of step S19 in which the body module 43 acquires the second file path is an example of the second acquisition process.

The main module 43, the common module 44, and the library 45 generate database data that can be input to the printer 11 based on the model name and database name obtained in step S16 and the second file path obtained in step S19. A specific format data generation process is executed (S20). 4 and 5, the specific format data generation process will be described in detail.

As shown in FIG. 4, the body module 43 calls the fifth API 49 of the common module 44 (S31), and transfers the acquired model name, database name, and second file path to the common module 44 (S32).

The common module 44 acquires the model name, database name, and second file path as arguments of the fifth API 49 (S32). The common module 44 calls the first API 47 of the library 45 (S33), and transfers the acquired model name, database name, and second file path to the library 45 (S34). The process of steps S32 and S34 in which the body module 43 outputs the acquired second file path to the common module 44 and causes the library 45 to acquire the second file path is an example of the first output process. The process of the body module 43 outputting the acquired model name to the common module 44 and outputting the model name to the library 45 includes the process of outputting the format information to the second program, and the process of outputting the acquired type information to the second program. It is an example of the process which a said 2nd program is made to acquire.

The library 45 acquires the model name, database name, and second file path as arguments of the first API 47 (S34). The process of step S34 in which the library 45 acquires the second file path is an example of the third acquisition process.

The library 45 identifies the local code type and the arrangement type based on the obtained model name and the conversion correspondence table 48 (FIG. 2B) (S35). The local code type is a character code type that can be interpreted by a printer of a specific model, and different local code types are prepared for each model. In the following description, the character code indicated by the local code type is described as a local code.

The library 45 converts the Unicode CSV database indicated by the acquired second file path into a specific code database, which is a database described in character code indicated by the specified local code type (S36). A local code is an example of a second specific code. The process of step S35 in which the library 45 identifies the local code is an example of the identification process. The process of step S33 in which the library 45 determines the local code type is an example of the process of determining the data format indicated by the format information.

Next, the library 45 generates a database in the data format of PD3 based on the arrangement type specified in step S35 and the arrangement table (FIG. 5(C)) (S37). The data format of the PD3 is a data format that includes basic data, which is binary data corresponding to the CSV database, and a command that instructs the printer 11 to perform two-way communication in the header. Two-way communication means, for example, that the control program 67 of the printer 11 requests the information processing apparatus 10 to transmit the remaining part of the data in response to completion of receiving part of the data, and the information processing apparatus 10 is used to sequentially transmit data to the printer 11 .

The process of step S37 in which the library 45 generates the PD3 format database will be described in detail with reference to FIG. The PD3 format data includes basic data as a CSV database, local code names, database names described in local codes, index data, and the like. In the following description, basic data, local code names, database names, and index data are described as partial data.

Data in the PD3 format is generated by arranging partial data in order from the first arrangement position, as shown in FIG. 5(A). The types of partial data that are arranged at the first, second, third, and fourth arrangement positions in the drawing differ for each model name of the printer 11 . The type of partial data arranged at each arrangement position is determined by the arrangement table shown in FIG. 5(C).

The arrangement table is a table showing the correspondence between the arrangement type, each arrangement position, and the type of partial data. In the illustrated example, the arrangement type "k011", the first arrangement position "local code name", the second arrangement position "database name", the third arrangement position "basic data", and the fourth arrangement position "index data ” is associated with.

The library 45 arranges the basic data and database name contained in the local code database, the name of the specified local code, and the generated index data at the arrangement positions indicated by the arrangement table, and creates a PD3 format database. FIG. 5B shows a PD3 format database generated when the specified arrangement type is "k011".

As shown in FIG. 4, the library 45 generates a specific format database based on the PD3 format database generated in step S35 (S38). The specific format is a data format including a PD3 format database, as shown in FIG. 5(D). In addition to the PD3 format database, the specific format database has a command in its header that indicates an instruction to input data to the printer 11 by one-way communication. That is, the library 45 generates data in a specific format for inputting data to the printer 11 for one-way communication, instead of PD3 data for inputting to the printer 11 for two-way communication. One-way communication is, for example, communication in which the information processing apparatus 10 executes data to be transmitted to the printer 11 without checking the printer 11 .

The process of step S37 in which the library 45 generates a PD3 format database (binary data) or the process of step S38 in which the library 45 generates a specific format database (binary data) are examples of generation processing. A PD3 format database (binary data) or a specific format database (binary data) is an example of the second data.

The processing from steps S34 to S38 will be described more specifically. The common module 44 calls the first sub API of the library 45 and transfers the acquired model name to the library 45 . The library 45 generates the second sub API from the passed model name.

A second sub-API is an API representing a first class, a second class, and a third class. The first class is a class that converts Unicode CSV databases and database names to local code CSV databases and database names. The second class is a class that determines the placement position based on the above-mentioned placement table, places the above-mentioned partial data at the determined placement position, and generates a PD3 format database. The third class is a class that converts a PD3 format database into a specific format database. The library 45 has in advance the number of first classes, one second class, and one third class corresponding to the number of local code types. The library 45 delivers to the common module 44 the first class specified based on the delivered model name and the second sub API indicating the second and third classes.

The common module 44 inputs the acquired database name and second file path to the passed second sub API to generate an instance. The generated instance converts the Unicode CSV database and database name into a local code CSV database and database name, and arranges the partial data at the arrangement position specified by the model name to generate a PD3 format database. , shows the process of converting the generated PD3 format database into a specific format database. The common module 44 delivers the generated instance to the library 45 (S34).

The library 45 processes the instance passed from the common module 44 (S34-S38) and generates a specific format database (S38). Since the library 45 processes instances generated from classes indicated by its own second sub-API, it can reliably process instances passed from the common module 44 to generate a specific format database.

Although the above-described steps S34 to S38 are executed based on the first sub-API, the second sub-API, the first class, the second class, and the third class have been described, steps The processing from S34 to S38 may be performed.

As shown in FIG. 4, the library 45 passes the third file path, which is the file path indicating the generated specific format database, to the common module 44 as a return value of the first API 47 (S39), and generates specific format data. End the process. The common module 44 acquires the third file path from the library 45 (S39), passes the acquired third file path to the main module 43 as a return value of the fifth API 49 (S40), and ends the specific format data generation process. do. The body module 43 acquires the third file path from the common module 44 (S40), and terminates the specific format data generation process. The process of step S39 in which the library 45 outputs the data in the specific format to the common module 44 is an example of the second output process.

As shown in FIG. 3, the body module 43 calls the fourth API 39 (FIG. 1) of the DLL provided by the OS 36 (S21) after completion of the specific format data generation process (S20), and sets the third file path to the third file path. 4 API 39 and instructs the DLL provided by the OS 36 to send the specific format database indicated by the third file path to the printer 11 . The DLL transmits the specific format database indicated by the passed third file path to the printer 11 through one-way communication through the communication interface 23 (S22).

The control program 67 installed in the printer 11 receives the specific format database through the communication interface 53 (S22). The control program 67 stores and registers the received specific format database in the memory 62 of the printer 11 (S23). The control program 67 executes print processing based on the registered database (S24). For example, the control program 67 reads out "first floor", "air conditioning", and "200V" from the database in response to receiving an instruction to print number "1" in the database (FIG. 2C), The data to be input to the print engine 52 are arranged in the "TEXT1", "TEXT2", and "TEXT3" indicated by the above-mentioned print area data, respectively. Generate. The control program 67 then inputs the generated data to the print engine 52 and causes the print engine 52 to print the image on the label.

Next, a process in which the application 37 converts input image data to generate print data, inputs the generated print data to the printer 11, and causes the printer 11 to execute printing will be described with reference to FIG. do. That is, the application 37 is a program capable of inputting a database to the printer 11 , generating print data from input image data, and inputting the generated print data to the printer 11 .

The application 37 is activated by the OS 36 according to an instruction from the program that created the image data, for example. Alternatively, the application 37 is activated by a user's activation instruction. The body module 43 of the activated application 37 executes the processes from steps S11 to S15 described above, and acquires the model name of the printer 11 (S41). Also, the body module 43 acquires the file path of the image data from the OS 36 (S42).

The body module 43 calls an API (not shown) of the common module 44 (S43), and transfers the acquired model name and image data file path to the common module 44 (S44).

The common module 44 acquires the model name and file path from the body module 43 (S44). The common module 44 generates print data based on the acquired model name and the image data indicated by the acquired file path (S45). The common module 44 generates print data using, for example, well-known techniques. The common module 44 passes the file path of the generated print data to the body module 43 as a return value of the above API (S46).

The body module 43 calls the fourth API 39 of the DLL provided by the OS 36 (S47), and transfers the file path of the print data to the DLL. The DLL transmits the print data indicated by the file path to the printer 11 through the communication interface 23 (S48).

The control program 67 installed in the printer 11 receives the print data through the communication interface 53 (S48). The control program 67 inputs the received print data to the print engine 52 and causes the image indicated by the print data to be printed on the label (S49).

[Action and effect of the embodiment]
The body module 43 acquires the first file path, which is the file path of the Unicode CSV database obtained by converting the character code of the acquired CSV database into Unicode (S19), and transmits the acquired first file path via the common module 44. Hand over to the library 45 . That is, the library 45 acquires a CSV database written in Unicode, not a CSV database written in various character codes. The library 45 then converts the Unicode of the CSV database into a local code, which is a character code corresponding to the model name of the printer 11, to generate a PD3 format database or a specific format database (S37, S38). Therefore, the library 56 can easily generate a PD3 format database or a specific format database, compared to obtaining a CSV database described in various character codes. As a result, the body module 43 and the library 45 can easily generate the second data of the type corresponding to the type of printer.

Also, the library 45 is written in the C++ programming language. Therefore, any program that can exchange information and data with a program written in C++ can transfer information and data to the library 45 and use the library 45 .

Application 37 includes common module 44 in addition to library 45 . Therefore, the application 37 can generate a database in a specific format that can be input to the printer 11, and can generate print data from image data.

[Other variations]
In the above-described embodiment, an example has been described in which the body module 43 transmits the specific format database (binary data) generated by the library 45 to the printer 11 via the OS 36 . However, the body module 43 may store the specific format database (binary data) generated by the library 45 in the data storage area 35 of the memory 32 as it is or in a file format. Further, the body module 43 may transmit the specific format database (binary data) generated by the library 45 to a device other than the printer 11 as it is or in a file format.

In the above embodiment, an example was explained in which the DLL provided by the OS 36 converts the character code of the CSV database created by the table creation program into a Unicode CSV database. However, the application 37 may further include a module for converting the character code of the CSV database created by the table creating program into a Unicode CSV database.

In the above-described embodiment, an example has been described in which the library 45 generates a specific format database and transfers the generated specific format database to the common module 44 . However, the library 45 may generate a PD3 format database (S37) and transfer the generated PD3 format database to the common module 44. FIG.

In the above-described embodiment, an example in which the database input to the application 37 is a CSV database has been described. However, the database input to application 37 is not limited to the CSV database.

In the above-described embodiment, "local code name", "database name", "basic data", and "index data" have been described as examples of partial data. However, the partial data may be data other than the exemplified data.

In the above-described embodiment, the common module 44 that generates print data instructs the library 45 to convert the data format of the database. However, the body module 43 may directly instruct the library 45 to convert the data format of the database, or may instruct the library 45 to convert the data format of the database via a module other than the common module 44 .

In the above-described embodiment, an example has been described in which the first file path indicating the CSV database file before conversion and the second file path indicating the Unicode CSV database after conversion are different. Similarly, an example in which the second file path and the third file path are different has been described. However, the first file path and the second file path may be the same file path, and the second file path and the third file path may be the same file path. That is, the file path indicating the data before conversion and the file path indicating the data after conversion may be the same.

10... Information processing apparatus 11... Printer 23... Communication interface 37... Application 38... Second API
41 UI module 42 main program 43 main module 44 common module 45 library 46 third API
47 First API
48 ... conversion correspondence table

Claims (7)

It comprises a first program and a second program executed by the computer of the information processing device,
The first program is
a first acquisition process for acquiring original data in a first format described in character code;
calling an API for converting the character code of the original data into a first specific code that is a specific character code, converting the character code of the acquired original data into the first specific code, and converting the character code of the original data into the first specific code; a second acquisition process for acquiring first data that is the described original data;
causing the computer to execute a first output process for causing the second program to acquire the acquired first data;
The second program is
a correspondence table in which various type information indicating the type of printer is associated with a code type indicating the type of character code determined by the type of the printer;
The second program is
a third acquisition process for acquiring the first data;
a specifying process of specifying a character code indicated by the code type associated with the type information based on the correspondence table as a second specific code;
a generation process of converting the first specific code of the obtained first data into the identified second specific code to generate second data described with the second specific code;
and a second output process for outputting the generated second data. The first program is a program written in the language of the OS of the information processing device,
the second program is a program written in a specific language unrelated to the language of the OS;
2. The program group according to claim 1, wherein said API is an API provided by said OS. The first acquisition process includes a process of acquiring format information indicating a data format of the second data,
The first output process includes a process of causing the second program to acquire the format information,
3. The program group according to claim 1, wherein the generation process includes a process of determining a data format of the second data to be generated to a data format indicated by the format information. The first acquisition process includes a process of acquiring output destination information indicating an output destination of the second data,
4. The program group according to any one of claims 1 to 3, wherein the first program causes the computer to execute a process of outputting the second data to an output destination indicated by the output destination information. 5. The program group according to any one of claims 1 to 4, further comprising a third program that receives the second data output in the second output process and outputs the data to the printer via the first program. The first program is
a process of acquiring the type information;
causing the computer to execute a process of causing the second program to acquire the acquired type information;
The second program is
6. The program group according to any one of claims 1 to 5, which causes the computer to execute a process of acquiring the type information. 7. The program group according to any one of claims 1 to 6, wherein the information processing device is a mobile terminal having a communication interface capable of communicating with the printer.

Images