Hot stamping of metallic foils has been widely used for decorating, with graphics and text, such items as book covers, wallets, attache cases, handbags, and suitcases. These articles are made of leathers, vinyls or textiles, which have surfaces with deep grains or fibers having valleys, for example, 0.001 inches or even 0.003 inches in depth. For decorating purposes, the metallic foil, transferred by heat and high pressure, typically has a mirror-like surface for shiny appearance.

Furthermore, the transferred material includes a tinted or clear lacquer top layer covering the metal surface to provide protection and a rich gold or other appearance.

Traditionally, to transfer the metallic material, one has to first fabricate a custom-made metal die with raised and recessed areas corresponding to the particular design. The raised areas press the foil against the receiving substrate to transfer the material having the desired pattern while heat is applied. The stamping press applies pressures of hundreds of pounds or more to the die. While this type of transfer has been widely used, it also has drawbacks. For example, it takes a relatively long time to fabricate the die and the fabrication process is relatively expensive.

There are other widely used techniques for decorative printing, but they also require fabrication of special tools for different designs. For example, silk screen printing requires fabrication of a print screen and pad printing requires fabrication of a pad.

Computer controlled thermal printing is a different thermal process. It uses a thermal printhead controlled by a computer to print an image, typically, on paper. The thermal printhead generates heat localized over dots of a computer generated pattern to be printed.

A thermal printing ribbon, disposed between the printhead and the paper or other web, releases ink that is thermally transferred in tiny amounts to the paper. The ink layer consists of a particulate or liquid-like material. The thermal printing ribbon also includes constituents that facilitate good adherence of the ink dots to the paper surface. The entire process is relatively fast and economical. However, this process has not been equated with hot stamping because of limitations of the process and the materials on which a precise image can be formed.

Thermal printing has been used for decorative printing on papers of varying surface qualities. To improve the quality of the transferred image, printheads have been used to transfer several layers of ink on the same dot or puffing particles have been included in the transfer composition to fill irregularities on the printed surface. In either case, the thermal printing process and its effects have differed significantly from the hot stamping process that transfers relatively larger chunks of metallic material to the surface to achieve a specular effect.

Summary of the Invention The invention provides low-cost decorating techniques that can achieve advantages of both thermal printing and hot stamping and can transfer high quality decorative images to rough surfaces. The techniques do not require special tools made individually for different images in order to thermally transfer a continuous

metallic foil and create an image with a smooth specular surface of the transferred metal on different types of substrates.

The novel digital decorating techniques generate high quality decorative images by computer-control. The decorating techniques produce images on rough or very rough surfaces while still achieving transfer of fine lines and edges and uniform fill of large areas. The thermal transfer system is constructed to deliver varying amounts of energy to pixels of the image depending upon important different parameters of the transfer system, the deposition surface and the image. While aspects of the invention can use only relatively few different energy states and take into account only few process variables and still transfer good quality images in many instances, other aspects of the invention provide the flexibility to employ a large number of variables and many different energy states for each pixel to further improve the transferred image. By employing different novel algorithms, different pixels are heated to different temperatures to generate high quality images.

According to one important embodiment, a digital decorating system for transferring a selected image to a surface of an article includes a thermal printhead, an advancing mechanism for producing relative movement between the printhead and the surface of the article, and a force member for exerting a selected amount of pressure between the thermal line of pixels and the surface of the article. The thermal printhead includes a plurality of energizable heater elements constructed to deliver heat to a thermal line of pixels on a surface of the printhead. The digital decorating system also includes a microcontroller operatively connected to the printhead, the force member and the advancing mechanism to provide control signals selectively delivering heat to pixels of

the thermal line and selectively causing the movement thereby thermally transferring, over a two dimensional array of pixels, a two dimensional image to the article surface. The microcontroller can classify the pixels corresponding to the image into perimeter pixels and interior pixels and control energy levels delivered to produce heat at the perimeter pixels and the interior pixels. The energy levels delivered to each pixel cooperatively depend on a level of energy previously delivered to the pixel, on levels of energy delivered to neighboring pixels and on a level of energy required at the pixel to thermally transfer the image to the surface.

The thermal line of pixels may press directly onto the surface of the article to transfer the image by thermally altering the surface of the article.

Alternatively, the digital decorating system may further include a thermal foil with a metallic layer located between the thermal line and the surface of the article.

The pixel may be a perimeter pixel relative to the image and the microcontroller may be arranged to provide to the perimeter pixel an energy level substantially above a threshold level of energy required for thermal transfer of material from the thermal foil thereby creating a substantial gradient of temperature between the perimeter pixel and a neighboring pixel outside of the image. The substantial gradient enhances the thermal transfer of the metallic layer to the surface.

The pixel may be a perimeter pixel of the image that, together with neighboring perimeter pixels, form a line of the image at a selected angle relative to the thermal line. Then the microcontroller provides to the perimeter pixel an energy level above a threshold level of energy required for thermal transfer of material from the thermal foil. The microcontroller also provides to a pixel outside of the image and in a corner neighboring

two the perimeter pixels an energy level below the threshold level. The selected angle may be from about 30 degrees to about 60 degrees.

The perimeter pixel may immediately precede several pixels that received energy substantially below the threshold level. Then the microcontroller provides to the perimeter pixel an energy level substantially above the threshold level thereby creating a substantial gradient of temperature between the perimeter pixel and a neighboring pixel. The substantial gradient causes thermal transfer of the metallic layer to the surface.

If the perimeter pixel immediately follows several interior pixels, the microcontroller provides to the perimeter pixel an energy level about equal to the threshold level to cause thermal transfer of the metallic layer to the surface.

The pixel may be an interior pixel and the microcontroller may provide to the interior pixel an energy level below the energy level delivered to the perimeter pixel.

The printhead may include a heat sink and a thermal exchange unit thermally connected to the thermal line and constructed to actively deliver or remove heat from the heat sink. The thermal exchange unit is constructed to actively cool the printhead.

The digital decorating system may further include a surface heater located near the thermal line. The surface heater may be constructed to preheat the surface of the article immediately before the surface reaches the thermal line.

According to another important embodiment, a computer controlled thermal decorator for transferring images from a thermal foil includes a printhead, including a set of heater elements, constructed to thermally transfer a line of pixels from the foil to a

rough substrate, and an advancing mechanism constructed to produce relative movement between the printhead and the substrate. This movement enables thermal transfer of an x-y matrix of pixels. The decorator also includes a controller constructed and arranged to examine, for each pixel, the relationship of neighboring of pixels of the matrix to the pixel for forming a selected image, and based upon the relationship of the print status of the pixel and its neighboring pixels, dependently select the level of energy to be applied to the heater element in respect of the pixel from a group of possible energies.

According to another important embodiment of such a system, the examination of neighboring pixels in according to an algorithm that determines whether the pixel lies at an edge of the image and the selection of the energy to be applied depends on that determination.

In preferred embodiments of this feature, pixels at an edge are heated to a higher temperature than pixels filling the body of the image, to produce enhanced separation of the foil from the carrier.

According to another important embodiment of such a system, the examination of neighboring pixels determines whether the pixel is in the region of a line lying at an acute angle to the printhead line and the state of energization of the pixel is determined according to a line smoothing algorithm that partially heats unprinted pixels neighboring the feature.

According to one embodiment, the algorithm determines if a pixel is outside the image but in a corner defined by pixels printed or to be printed, in which event the energy selected for the pixel in question heats the pixel below normal pixel printing temperature but sufficiently, in combination with the heating effect of the adjacent pixels, to cause partial transfer of the foil in the

corner region of the pixel in question to contribute to line smoothing.

According to another important embodiment, the examination of neighboring pixels according to an algorithm determines whether the pixel is a"fill"pixel, lying in the interior of the image, beyond the edge of the image, and if so, an energy level is selected that is sufficiently low to prevent any discoloration or tarnishing effect on the foil is applied to the pixel.

In another aspect, a computer controlled thermal decorator, for transferring images from a thermal foil, includes a printhead, an advancing mechanism and a controller. The controller examines an image to be printed and increases the energy delivered to heater elements, relative to an average energy, and the energy applied to the leading edge of the image. The controller may be further programmed to increase the energy delivered to heater elements transferring the trailing edge of the image.

In another aspect, a computer controlled thermal decorator, for transferring images from a thermal foil, includes a printhead, an advancing mechanism and a controller. The controller examines an image to be printed and applies power to pixels not to be printed, if the pixels lie in a corner defined by pixels that are to be printed.

In another aspect, a computer controlled thermal decorator for transferring images from a thermal foil, includes a printhead including a line of heater elements that are selectively energized during relative movement to a substrate. The decorator further includes a heater that preheats the substrate to enhance the transfer of the foil. The heater may heat the substrate generally, immediately prior to passing under the printhead. The heater may be in a form of a second printhead that heats

the substrate in a pattern related to the pattern to be thermally transferred. The second printhead may have substantially the same number of heater elements as the first mentioned printhead.

In another aspect, a computer controlled thermal decorator, for transferring images to a substrate, includes a printhead including a line of heater elements that are selectively energized during relative movement to a substrate. The heating elements are exposed for direct contact with the substrate to thermally alter the substrate and thereby transfer the image. The decorator may further include a controller constructed and arranged to control power levels suitable for different types of substrates. The substrate may be leather.

In another aspect, a computer controlled thermal decorator for transferring images from a thermal foil includes a printhead, including a set of heater elements, constructed to thermally transfer a line of pixels from the foil to a rough substrate, an advancing mechanism constructed to produce relative movement between the printhead and the substrate. This movement enables thermal transfer of an x-y matrix of pixels. The decorator also includes a controller constructed and arranged to control the energy delivered to the pixels dynamically in relationship to energies delivered to the neighboring pixels that form the image. The printhead includes a heat transfer member constructed to maintain a selected temperature of the printhead. The heat transfer member may be constructed for active heating or cooling.

For certain applications, the controller is advantageously constructed and arranged to transfer the negative of a desired image thereby leaving a well defined decal on the substrate that is subsequently transferred as by use of a heated roll.

Also, in certain circumstances, it is advantageous that the decorator include a second printhead and the controller is constructed and arranged to transfer the negative of a desired image to the foil by employing one printhead thereby leaving a decal and the controller is constructed and arranged to transfer the decal to the substrate by employing the second printhead.

The invention also includes novel methods employed by the above-described systems.

Brief Description of the Drawing Fig. 1 is a perspective view of a digital decorating system.

Fig. 2 is a diagrammatic side view of a thermal transfer system.

Fig. 3 is a perspective view of a printhead of the thermal transfer system.

Fig. 4 is a view of the bottom of the printhead taken on line 4-4 of Fig. 3.

Fig. 4A is a magnified view of a portion of Fig.

4.

Fig. 5 is a simplified perspective view of a printhead with a heat pipe for maintaining a desired temperature.

Figs. 5A and 5B are simplified perspective views of printheads cooled by air.

Fig. 6 is a diagrammatic side view of the thermal transfer system including a bulk heater for heating the substrate or the thermal foil.

Figs. 6A and 6B are diagrammatic side views of the thermal transfer system, including a second printhead for preheating the substrate, and the thermal foil, respectively.

Figs. 7 and 7A are simplified perspective views of the thermal transfer system designed for preheating the substrate.

Fig. 8 is a magnified view of irregularities of an edge produced by a standard thermal transfer, while Fig.

8A is a magnified view of a smoother edge produced by an "edge enhancement"algorithm according to the present invention.

Fig. 9 is a diagrammatic view of a circular image to be thermally transferred to a substrate.

Fig. 9A is a diagrammatic plan view of a uniform energy distribution for the thermal image transfer of the image of Fig. 9, and Fig. 9B is a highly magnified view of a portion of Fig. 9A.

Figs. 9C and 9D are highly magnified views of the transferred image employing the uniform energy distribution of Fig. 9A and a"line enhancement" algorithm according to the present invention, respectively.

Fig. 10 is a diagrammatic view of pixels considered in an enhancement algorithm and a chart with different thermal transfer combinations considered by the algorithm.

Fig. 11 is a block diagram of the thermal transfer algorithm.

Fig. 12 is a block diagram of the overall organization of the digital decorating system.

Description of Preferred Embodiments Referring to Fig. 1, a digital decorating system 10 includes a personal computer 12 interfaced with a thermal transfer system 14. Computer 12 performs overall control over the digital decorating process and generates a selected image. Thermal transfer system 14 is a compact, table top system for transferring the provided image to a selected surface of an article (for example, vinyl, leather, plastic, textile or paper).

Referring to Fig. 2, thermal transfer system 14 includes a microcontroller 16, a drive assembly 22, a thermal foil assembly 30, and a thermal printhead assembly 40. Drive assembly 22 (i. e., advancing mechanism) includes a stage 24 constructed to move an article 26 before and during the image transfer process.

Drive assembly 22 receives signals 38 from microcontroller 16. Thermal foil assembly 30 includes thermal foil 32 spooled on a supply roll 34 and a set of rollers 36 constructed to advance foil 32 (together with article 26 being advanced by stage 24) at a selected rate determined by control signals 38.

Thermal printhead assembly 40 includes at least one printhead 42 pressed against article 26 by a force member 41 and responsive to control signals 44 from microcontroller 16. Force member 41 is constructed to vary the pressure exerted by the printhead. The pressure is in the range of about 1 to 8 pounds per inch, and preferably about 5 pounds per inch of print line.

Referring to Fig. 3, printhead 42 is an edge type printhead that includes a set of electrical connectors 46, a heat sink 48, and a ceramic member 50. While the thermal printhead assembly is stationary during the thermal transfer process, it can be repositioned to a different location prior to the transfer process. The repositioning achieves easy access to different locations of the decorated items. Electrical connectors 46 are connected to a plurality of energizable heater elements constructed and arranged to selectively heat each of a line of pixels on the surface of ceramic member 50.

Referring to Fig. 4, in one preferred embodiment, the heater elements 52 are made of strip 53 of a resistive material deposited on the bottom surface of ceramic member 50, and connected to a plurality of leads 54 and a common ground terminal 56. Individual leads 54

are connected to electrical connectors 46, which are in turn operatively connected to a power supply and microcontroller 16. As shown in Fig. 4A, a magnified portion of Fig. 4, the spacing between leads 54A and 54B is approximately the same as width W (for example, W = 0.003") of strip 53. Microcontroller 16 provides control signals 44 to a current source (not shown) that applies energizing current, for instance to lead 54A. The current flows from 54A to ground terminal 56 through a portion of resistive strip 53, which forms one heating element 52A. Ceramic member 50 also includes a relatively thin but hard layer of glass that covers strip 53 and the leads. The heating elements heat the corresponding pixels (i. e., dots) on the surface of the glass layer, and the surface is in contact with thermal foil 32. The temperature of a pixel depends on the amount of energy delivered to the corresponding heater element and the thermal history and instant printing condition of the printhead. Thermal printhead assembly 40 may use different printheads having resolution of 200, 300, or 400 dots per inch.

Microcontroller 16 receives a selected image from computer 12 and generates a data matrix corresponding to the image area. Importantly, the data matrix includes an enhancement of the image by electronic means to improve its visual appearance and physical character after the thermal transfer to surface 25 of article 26. The enhancement algorithm generates selected levels of energy delivered to each pixel at each position of stage 24, as opposed to application of the same energy condition to all pixels, as is frequently done, for example ; in direct thermal printing. Thus, the data matrix can be visualized as a three-dimensional matrix with two- dimensional spatial information, and the energy level data, generated by the enhancement algorithm, represented

as the third dimension. The enhancement algorithm is interactive, that is, capable of adjusting the individual levels of energy relative to the local shape of the image, the thermal history of the pixel, levels of energy applied to the neighboring pixels, the overall temperature of ceramic member 50 and heat sink 48, the morphology of surface 25, and the type of material to be thermally transferred. Furthermore, in certain embodiments, the enhancement algorithm uses a set of sensors distributed on printhead 42 that provide further input data for a dynamic analysis of the energy conditions for determining energy levels to be applied to the pixels.

The enhancement capabilities of the system enable high quality images to be printed that can be compared to those produced by various hot stamping techniques that use pressure dies.

Digital decorating system 10 can operate in different modes to produce different types of images on surface 25. The first mode is achieved by direct application of heat and pressure from the surface of ceramic member 50 to surface 25 of article 26. As article 26 advances, printhead 42 applies to surface 25 pressure induced by force member 41 and heat selectively generated by the heater elements to thermally alter the material surface and thereby transfer the image. This mode does not use thermal foil assembly 30. The second mode of image transfer employs thermal foil assembly 30, as is described below. Other modes employ multiple printheads without foil, or with one or multiple foils or ribbons.

The enhancement algorithm employed in a particular system is selected in accordance with the mode of transfer, the desired image and the general operating

parameters such as type of foil and type of substrate involved.

The second image transfer mode employs thermal foil assembly 30 to thermally transfer material to surface 25 and thereby create the image. Thermal foil 32 includes a thermally resistive carrier film, a light- transmissive lacquer layer that may include a coloring agent or pigment, a thin metal layer, and a thermally activated adhesive layer that includes resins and fillers that preferably includes a puffing agent. The carrier film is preferably back-coated with a heat-resistive lubricant. Between the carrier film and the lacquer layer there is a release coating, such as thermally responsive synthetic wax, which under heat releases the lacquer, metal and adhesive laminate from the carrier.

The preferred thermal foil is described in detail in a co-pending U. S. Patent Application, Serial No.

, filed January 28,1997, entitled"Thermal Foils for Digital Decorating,"attorney docket no.

06456/005001, incorporated by reference.

In the second thermal transfer mode, stationary printhead 42 applies heat and pressure to foil 32 and surface 25, both of which move underneath printhead 42.

As mentioned above, the enhancement algorithm controls the energy sequence delivered to each pixel of the image (and the pressure delivered by force member 41). Each pixel receives the energy from a current source or a voltage source. In a preferred embodiment, each pixel receives constant current over three time intervals while thermal foil 32 and substrate 25 move continuously at a low speed (2 mm/sec. to 25 mm/sec.) Alternatively, foil 32 and substrate 25 can remain stationary during the three time intervals. Each interval lasts about one millisecond and the current is either on or off during the interval. Thus, this arrangement enables current

profiling over each pixel. The image develops as the pixels transfer the material from thermal foil 32 to substrate 25. The energy sequence is chosen to account for the unique properties of different thermal foils 32.

Specifically, foils 32 may include different thicknesses of the continuous metal layer that is thermally transferred to substrate 25 together with the lacquer and adhesive layers of the laminate. The metal laminate tends to separate from (or peel off of) the thermally resistive carrier film in flakes or small sheets of material, whereas continuity of the deposited material is desired to achieve a specular effect. This significantly differs from the thermal transfer of particulate or liquid like material, such as thermal ink.

The digital decorating system monitors and controls the overall temperature of printhead 42, which may include one or more temperature sensors. During the thermal transfer process, a current source delivers current pulses to the tiny heater elements 52, which in turn convey heat to thermal foil 32 and ceramic member 50. In general, approximately 20% of the generated heat is consumed by the thermal transfer process and about 80% is conducted away to ceramic member 50 and heat sink 48.

Ceramic member 50 and heat sink 48 have a relatively large thermal mass for managing the heat transfer and providing stable thermal conditions. However, the large thermal mass sometimes also limits the operation of printhead 42, for example, in certain circumstances it may limit the available speed of the thermal transfer process. For images where heater elements need to deliver large amounts of heat in one area and small amounts in another area, the overall thermal management may be difficult. Furthermore, ceramic member 50 has only a limited ability to deal with localized hot spots or thermal overload. One preferred embodiment of

printhead 42 includes a heat exchange unit constructed to actively cool or heat printhead 42 to achieve stable conditions. Active heating keeps the contact surface of printhead 42 preheated so that the print elements advantageously require less energy for the transition from non-printing to printing state, thus enabling fast operation. In other embodiments, active cooling is employed to increase the protection of the heater elements. The system for energizing the pixels over a range of energy transfer states is adapted to the particular heat management system employed.

In certain embodiments, referring to Figs. 5A and 5B, printhead 42 employs heat exchange units 66 or 70, which use air convection for cooling. In another embodiment, the heat exchange unit uses a set of thermoelectric elements placed in thermal contact with heat sink 48. The thermoelectric elements may be implemented to operate in a cooling mode or in a heating mode depending on the polarity of the current delivered to them by a power supply operatively connected to microcontroller 14. In certain preferred embodiments, the system algorithm interactively adjusts the printhead temperature as one parameter of the thermal transfer process.

In another embodiment, referring to Fig. 5, heat exchange unit 60 controls the overall temperature of printhead 42. As illustrated, heat exchange unit 60 includes a heat exchanger 61, a heat pipe 62, and a condenser with a set of cooling fins 64. Heat exchanger 61 includes a set of conduits extending relatively close to heater elements 52. The conduits are designed to carry a liquid with a high thermal capacity. Heat exchange unit 60 may be a closed system using a boiling liquid, wherein the liquid boils as it circulates near

heater elements 52 and condenses in the condenser cooled by cooling fins 64. This boiling and condensing transfers a large quantity of heat for a given printhead size, and is capable of operating heater elements at a very small safety margin. Furthermore, the boiling liquid equilibrates local temperatures near heater elements 52; thus there is no need to employ a routine in this algorithm to adjust the energy levels to the individual heater elements to compensate for the overall temperature. The boiling liquid also provides a thermal ceiling for the heater temperature and can significantly raise the power ceiling of the heater elements, especially if the materials of the printhead are selected to have good thermal conductivity.

Referring to Fig. 6, in another embodiment, thermal transfer system 10 employs a bulk heater 80 for preheating substrate surface 25 or thermal foil 32. Both surface 25 and thermal foil 32 have a relatively low heat capacity and thus, to preheat effectively, bulk heater 80 is located relatively close to the heater elements of printhead 42.

Microcontroller 16 sends control signals (84) to bulk heater 80 and, in preferred embodiments, receives back temperature signals from thermal sensors located on the heating surfaces. In a substrate preheating mode, bulk heater 80 heats its surface 81, which provides heat to surface 25. One or more temperature sensors, embedded on surface 81, detect the temperature of surface 25 and provide a signal to microcontroller 16. Microcontroller 16 receives the temperature signal and adjusts the power provided to bulk heater 80 in a feedback arrangement.

Depending on the material, the temperature of surface 25 is selected to soften material 26 and make it more receptive to printing (for example, in the case of vinyl), or it is selected to preheat material 26 to

reduce the time needed for thermal transfer at each dot.

The softening of heat-sensitive materials (i. e., vinyl) enables moderate pressures of the printhead to momentarily flatten the material in the thermal transfer region and improves thermal contact between the foil and the substrate. Similarly, in a foil preheating mode, bulk heater 80 heats its surface 82, which provides heat to thermal foil 32. Bulk heater 80 maintains the temperature of foil 32 at an elevated level, though sufficiently low so that no material migrates from the foil; subsequently, printhead 42 delivers a limited amount of power during the thermal transfer process to raise the temperature from the preheated, non-printing condition to a further elevated, printing condition.

Referring to Fig. 6A, in another embodiment, thermal transfer system 10 employs a second printhead 43, located in close proximity to printhead 42, for selectively preheating surface 25. By computer control, second printhead 43 preheats surface 25 only at the locations where printhead 42 subsequently transfers the metal foil to surface 25. The preheating improves adhesion of thermal foil 32. The preheating also enables "differential"heating of thermal foil 32 by delivering additional heat from preheated surface 25 to the bottom layer of the foil. The preheating temperature, in certain preferred instances, is selected to be higher than the softening temperature and can even be selected to be so high as to alter the surface composition of surface 25 since any potential discoloration will be covered by the transferred foil. For example, heating the surface of vinyl above about 200°F renders the selectively heated areas more receptive to the thermal deposition. These areas do not appear different to the naked eye, but common foil adhesives are found to selectively adhere to such a latent heat image relative

to areas untouched by the heat. At these temperatures, components within the vinyl, such as monomers or plasticizers, migrate to the surface in heated areas and the foil adhesives adhere in an improved way to these compounds. Furthermore, for some materials, the high heat makes it possible to print more deeply into a textured surface. To maintain the registration, the printheads are preferably located close together. The control software communicates with both printheads. The control software advantageously provides adjustment to the timing and relative location of the two images on the print lines, enabling fine adjustment of registration by observing the thermal pattern and the transfer effect.

The preheating area can thus be brought into precise registration with the following thermal transfer area.

Alternatively, referring to Fig. 6B, thermal transfer system 10 employs a second printhead 43A for selectively preheating thermal foil 32. Printhead 43A can not only preheat thermal foil 32 but also thermally transfer an initial layer of material to surface 25. The initial layer pretreats surface 25 and can include a puffing material that fills valleys in the surface.

Subsequently, printhead 42 thermally transfers the metal and lacquer layers with an additional adhesive layer to surface 25. In another embodiment, printheads 42 and 43A are arranged to transfer material from two separate thermal foils. The transferred images of the foils do not need to be identical, but, in certain advantageous arrangements, can be arranged and controlled to complement each other.

Referring to Fig. 7, a substrate heater 74 includes a heat lamp 75 (for example, an infrared lamp) coupled to a planar light guide 76, e. g., of quartz, constructed to deliver a line of the generated heat to surface 25. Microcontroller 16 sends control signals 77A

to a controller 77, which regulates power delivered to heat lamp 75. A temperature sensor 78, or an array of them, located in thermal communication with substrate 25, measures the temperature of the substrate just before the substrate reaches the line of pixels at printhead 42.

Temperature sensor 78 also provide feedback data to controller 77. This embodiment can use different temperature sensors, including a infrared sensor. In another embodiment, referring to Fig. 7A, a substrate heater 80 uniformly heats substrate 25 with hot air of a selected temperature. Substrate heater 80 includes an air pump or fan 82 and a heater 84 connected to a nozzle device 86, which delivers jets of hot air to substrate 25.

Referring now to the control aspects of the preferred system, in general, the enhancement algorithm includes specific advantageous thermal transfer techniques, referred to as"line enhancement,""edge enhancement,""lacquer protection"and"trailing edge." The"edge enhancement"technique enables the generation of clearly defined edges in the thermally transferred pattern, while enabling the fill area to provide a uniform, desirable appearance. In the edge enhancement technique, microcontroller 16"looks"for initial transfer pixels and generates higher energy levels for pixels that form an edge, especially the leading edge of the image. Thus, the leading, peripheral pixels (i. e., edge pixels) are controlled to have a higher temperature than interior pixels; this creates an advantageous temperature gradient at the edge between heated and unheated regions. The temperature gradient enables the transferred material to separate from the material remaining on the foil in a well-defined manner relative to the heated pattern. This is particularly applicable

to leading edges and side edges in a patterned area being progressively transferred.

To create an optimal temperature gradient, microcontroller 16 also takes into account the temperature of ceramic member 50 and heat sink 48 and the temperature of surface 25. These temperatures may also be adjusted to create the optimal temperature gradient.

The temperature gradient, in turn, enables a clean break and transfer of the lacquer, metal and adhesive layers.

Figs. 8 and 8A sketch the difference in the transferred image of line L, wherein the shaded areas 90 represent the layers laid down to form the image while the white areas 92 represent surface 25. As shown in Fig. 8, without the edge enhancement algorithm, the edge L tends to be irregular. On the other hand, as shown in Fig. 8A, the same edge produced by the edge enhancement algorithm is more regular in appearance. The energy considerations will be discussed specifically in connection with Fig.

10. In the filled area beyond the leading and side edges, microcontroller 16 directs a much lower energy to the pixels (i. e., interior"fill"pixels), where the image is also transferred. The lower energy heats the pixel to a temperature wherein the thermal transfer still occurs due to the selected properties of the metal foil, because a lower energy level is sufficient to continue the peeling and transfer process. The lower energy level decreases the generated heat, which prevents damage to the lacquer layer that can produce a tarnished appearance to the reflective decoration. This is the"lacquer protection"technique. There are no similar concerns in thermal printing, i. e., thermal transfer of ink. This enhancement algorithm is specific to thermal foils transferring metal.

The"line smoothing"routine in a novel way eliminates a stair-step appearance of lines or edges that

lie diagonally to the direction of the thermal transfer motion. For example, if the image is a circular pattern, as shown in Fig. 9 (or any pattern with a line that lies at an acute angle to the direction of motion), a uniform distribution of energy over the matrix at the transfer points of the edge will generate a stair-step pattern of thermally transferred material (see Fig. 9A). This uniform application of energy and the thermally transferred material are shown in Figs. 9B and 9C, respectively. According to the novel"line smoothing" routine, a low level of energy is applied to a pixel lying outwardly of the edge pixel (i. e., a pixel not assigned as part of the computer generated image) The result is that a decreased thermal gradient is produced at the edge in this instance, which produces less precisely defined lines that effectively smooth the line that would otherwise have a crisp stair step appearance.

It is further realized that, in particular reduced heating of a"nonprinting"pixel that lies in the corner between two"printing"pixels that form the stair step produces the most heat concentration in the crotch or corner portion of the pixel next to the heated pixel.

This causes transfer of the foil in this limited region to produce a desired smoothing effect. a partial material transfer occurs in a corner region of that pixel and a smoother appearance, as suggested in Fig. 9D, is achieved. In cases where pixels are of equal dimensions in both directions, the most effective angles for this algorithm lie at about 45 degrees to the thermal transfer axis, while a beneficial range is generally between about 30 degrees and 60 degrees for fine art work.

Fig. 10 illustrates in a simple way a matrix employed for implementing the enhancement techniques with respect to assigning different energy levels to the

individual pixels of an image. (As mentioned above, the algorithm also takes into account the substrate and foil temperatures, the overall temperature of the printhead, the pressure, and the type of the substrate, but theses will be discussed separately.) On the top, Fig. 10 shows the rows and columns of pixels being printed by printhead 42 in print direction 94. The row"n"indicates the line of dots about to be transferred (or not transferred depending on the image), while the row"n-1"is a line that has been transferred in the preceding print stripe and"n-2"is a line that has been transferred in the stripe preceding"n-1."The algorithm has to assign an energy level to a pixel E. The algorithm"looks"at the pattern around pixel E of the image to be transferred.

The chart in Fig. 10 indicates possible combinations of the transfer states for pixels A, B, C, and D, wherein "0"denotes no transfer, according to the computer- generated image, and"1"denotes material transfer.

Overall, in this implementation there are 16 different combinations, but only 12 different energy possibilities, E1 through E12, because some of the patterns are essentially identical for thermal transfer purposes. For example, the material transfer at pixels B and C is identical to the material transfer at pixels B and D, assuming that the thermal conditions at pixel C and pixel D (due to the heating of their additional neighboring pixels, not shown) are identical. If there was no material transfer at the immediately preceding row"n-1," microcontroller 16 raises the energy of pixel E, and executes the edge enhancement algorithm. If there was material transfer in rows"n-2"and"n-1," microcontroller 16 directs lower energy to pixel E. This lower energy is either zero energy, if no transfer should occur at pixel E, or to an intermediate value, if material transfer should occur at pixel E. In the latter

case, microcontroller 16 executes the"lacquer protection"routine, which prevents thermal damage to the lacquer layer. Additionally, if there was material transfer at pixel B, but not at its neighboring pixels in rows"n-1," (or there was material transfer at pixels A and B, but not at their neighboring pixels in rows"n-2" and"n-1") the algorithm"looks"for lines at an angle to the transfer direction. For example, if there is material transfer at pixels B and C, pixel E receives energy Eg, which is about three-quarters of the energy of pixels B and C. Furthermore, microcontroller 16 executes the"line smoothing"routine. The"Line smoothing" routine directs a small amount of energy to the corner pixel next to heated pixels B and C for partial transfer of material that removes the stairstep pattern, as described above. Similarly, if there is material transfer at pixels F and D, then microcontroller 16 directs a small amount of energy to pixel E for partial transfer. The algorithm can also"look at"the next succeeding stripe. If there is material transfer at pixels E, but no transfer at pixel F (or pixels of the "n+1"stripe), microcontroller 16 executes a"trailing edge"routine and pixel F receives no energy. In general, the"trailing edge"routine does not assign increased values of energy to the last transferred stripe, that is, there is no increased heating of the leading edge as executed by the"edge enhancement" routine. However, to break off the material to be transferred at the trailing edge, the thermal gradient may be needed for some types of thermal foils. This is again due to the unique properties of the metal layer that tends to break off clean at the trailing edge. A simplified version of the enhancement algorithm, in general, achieves very good results by only"looking at"

a partial image and considering just a few transfer stripes.

Fig. 11 shows diagrammatically the thermal transfer algorithm. The computer provides image data (100) to a stripe generator 102, which analyzes each thermal line to be transferred and provides this to a sub-stripe generator 104. As is described below, sub- stripe generator 104 generates sub-stripe data (112) and the corresponding power (energy) control signals for a power controller 110. Power controller 110 also receives print speed data 108 and foil & substrate data and delivers current signals for each sub-stripe to the heater elements of the printhead. The printhead includes a temperature sensor that sends temperature data (116) to power controller 110.

Appendix A includes a listing of a source code that can be described as follows: Data kept for each dot (pixel) of the printhead (1 = on) previous dot line: this dot line: p L X R wherein X = current state of dot X P = previous state of dot X L = current state, dot to left of X R = current state, dot to right of X Arrays kept for each line of data: * normal stripe [] = X for each dot of head not current stripe [] = X not previous stripe [] = P not left stripe [] = L

not right stripe [] = R * edge stripe [] = X * (P + L + R) Time during which one row of data is printed is broken into 3"substripe"intervals of equal duration.

"Normal stripe []"data is printed during the first two substripes,"edge stripe []"data is printed during the third substripe. The nominal power for each sub-stripe can be adjusted independently and is corrected for head temperature.

Initialization: (Function"Stepup Printing ()") * Cells"Compute Strobe Energy ()"to build a look-up table"rollofftable [] []" which contains power settings for each possible head temperature data reading for each of the 3"substripe"interval power levels.

* Initializes image buffer data from a file, points to its start * Initializes data arrays Normal Stripe [], not Current Stripe [], not Prev Stripe [] * Initialize Sub Stripe number to 0 * Initialize and start Sub Stripe rate timer & IRQ Interrupt Service routine"SendStripe ()", called from sub-stripe timer IRO, does following : * sets strobe energy based on recent-average head- thermstor data and on current substripe number.

* quits if done printing all data.

* updates sub-stripe number, module 3. if substripe = 0 get NextStripe [] from image Buffer ptr, (updates normal Stripe [] not Current Stripe [], not Prev Stripe []

shifts normal Stripe [] to head for printing @ substripe &num 1 energy level) else if substripe = 1 leaves head data unchanged (normal Stripe [] data continues printing @ substripe &num 1 energy level) calls"build Edge Stripe ()"to compete not Left Stripe [], not Right Stripe [], and finally Edge Stripe [] else if substripe = 2 shifts Edge Stripe [] data to head for printing at substripe #2 energy level Fig. 12 shows a block diagram of the overall organization of digital decorating system 10.

Microcontroller 16 runs the enhancement algorithms (126) and the system control algorithms (128). Microcontroller 16 receives image data 100, user parameters 120, system parameters 122 and thermal foil parameters 124. User parameters 120 include information about the object and surface being decorated. System parameters 122 includes manufacturer information, the printhead rating, the heater ratings and other. Thermal foil parameters 124 are parameters unique to the foil currently used.

Microcontroller 16 controls print speed 130, printhead force 134, printhead power 138, substrate heat 142 and foil heat 146 and can receive their actual values, measured by sensors 132,136,140,144, and 148 in a feedback loop 150.

// ========================= //FILE : PHEAD. H PROJECT : DDS REVISION : 1.10 DATE : 12/05/96 //______ DESCRIPTION : //Header file for PHEAD. C-Print head control functions REV DATE BY DESCRIPTION // ----- ------- --- ========================================================== // B1. 00 04/18/96 JRC Beta pre-release 1.00 // B1 01 04/24/96 JRC Beta pre-release 1.01 //B1. 02 05/09/96 JRC Beta pre-release 1.02 // B1. 03 06/05/96 JRC Beta pre-release 1.03 // B1. 04 07/02/96 JRC Beta pre-release 1.04 // B1. 05 08/07/96 JRC Beta pre-release 1.05 // B1. 06 08/07/96 JRC Beta pre-release 1.06 // B1. 07 09/05/96 JRC Beta pre-release 1.07 /l (documention of changes from B1. 06 incomplete) //-B1. 08 09/27/96 JRC Beta pre-release 1.08 //-B1. 09 11/01/96 JRC Beta pre-release 1. 09 //Added function prototypes ComputeStrobeEnergy().

//GetMaxWatts (). SetCompensation (), SetDutyCycle (), & //SetForce (). Deleted prototypes GetEnergyl().

// GetEnergy100(). GeForcel(). & GetForce100 ().

//Added conditional prototypes SetConstantRolloff() & // GetConstantRolloff() //1. 10 12/05/96 JRC Beta pre-release 1.10 //Moved def MAX_WORDS_PER_LINE here from PHEAD. C // #ifndef PHEA_H #defnde PHEA_H #ifndefDATADEFS_H #include "datadefs.h" #endif // ======================= //LOCAL DATA DEFINITIONS // ================== //max head width supported, in 16-pixel words #define MAX_WORDS_PER_LINE 78 // //FUNCTION PROTOTYPES // ==================== BYTE AnalogFromHeadResistance (double r) : BYTE AnalogFromHeadTemp (int temp) : void ClearPrintHead (BOOL latch): void ComputeStrobeEnergy (void) : int GetHeadHeatMax (void) : int GetHeadHomeX (void): BYTE GetHeadNumber (void) : int GetHeadOverTemp (void) : double GetMaxWatts (void): int GetNPixels (void) : int GetResolution (void) : int GetWordsPerLine (void) : double HeadResistanceFromAnalog (BYTE data) : int HeadTempFromAnalog (BYTE data) : BYTE InitHeadInfo (void): BOOL IsPrintDone (void): void KillPrint (void) : void SendStripe (void): void SetCompensation (int comp) : void SetDutyCycle (int n) : double SetForce (int n) : BOOL SetupPrinting (int * pBM. int * pLen. int xLoc, int yLoc) : void StartPrinting (void) : &num ifdefTWO ROLLOFF MODES void SetConstantRolloff (BOOL flag) : BOOL GetConstantRolloff (void) : &num endif #endif //#ifndef PHEAD_H // FILE : PHEAD. C PROJECT : DDS //REVISION : 1.10 DATE : 12/05/96 //DESCRIPTION : //Print head control functions // REV DATE BY DESCRIPTION // ----- ------- ---------------------------------------------------------- //B1. 00 04/18/96 JRC Beta pre-release 1.00 //B1. 01 04/24/96 JRC Beta pre-release 1.01 //B1. 02 05/09/96 JRC Beta pre-release 1.02 BI. 03 06/05/96 JRC Beta pre-release 1.03 //B1. 04 07/02/96 JRC Beta pre-release 1.04 //07/08/96 JPR start adding dot control //B1. 05 08/07/96 JRC Beta pre-release 1.05.

// Used "PHEAD.C" identical to B1. 04 (no dot history).

//B1. 06 08/07/96 JRC Beta pre-release 1.06 Incorporates JPR's new dot history control functions.

// B1. 07 09/05/96 JRC Beta pre-release 1.07 // (documention of changes from B1. 06 incomplete) //B1. 08 09/27/96 JRC Beta pre-release 1.08 //B1. 09 11/01/96 JRC Beta pre-release 1.09 //Added variable"Edge Enhancement"effect (formerly //known as dot history) : //-Added function SetCompensation () //Added energy (microstrobe duty-cycle) rolloff feature //to compensate for changes in head temperature.

//-Conditional based on DDS. H switch "TWO_ROLLOFF_MODES": //functions SetConstantRolloff (), GetConstantRolloff () //variable constantRolloff allow setting constant //rolloff regardless of energy setting.

//-Normally uses percentage rolloff, based on new member //'rolloff added to headinfo structure.

//-Added rolloffTable [], microstrobe duty-cycle counter //values for each temperature & substripe. Added //functions ComputeStrobeEnergy () to init this table & //replaced startStrobes () with setStrobeEnergy () which //which reads the thermistor & does lookup.

//Optimized code to provide higher data rates, supporting //print speeds up 2 IPS even with 4"heads : //-Reduced number of sub-stripes from 4 to 3.

//-Rewrote SendStripe (), moved dot-history functions from //getNextStripe () to new function buildEdgeStripe () //Consolidated shift functions into shiftStripe ().

//which writes to both left & right shift regs for 4" //head.

//Simplified interaction with JOBCMDS. C: //-Replaced functions GetEnergyl (), GetEnergylOO ().

//GetForcel (). & GetForceloO () with SetForce ().

SetDutyCycle () : deleted elements microDutyl.

//microDutylOO from headlnfo structure.

//-Added function GetMaxWatts () & added member maxWatts //to headlnfo structure //Conditional based on DDS. H switch COUNT_DOTS. added dot //counting per line. Array linedots [], printf of average // dot power.

// Increased headHeatMax from 120 to 150 F in headlnfo struct //1. 10 12/05/96 JRC Beta pre-release 1.10 //Simplified pointer setup in shiftStripe () //Removed def MAX_WORDS_PER_LINE to PHEAD. H //Modified SetupPrinting () & getNextStripeo to handle flipped //bitmap files : using new local variable"flipped".

// ----- --------- --- ---------------------------------------------------------- &num include <alloc. h> #include <math. h> #include <string. h> &num include"dds. h" LOCAL DATA DEFINITIONS //&num define FORCE 4_INCH TRUE//debug 4"head code using 2"head number of printhead types supported #define N_HEADTYPES 2 //microstrobe counter modes #defineSTB_MODE_1 LSB_MSB COUNTER_MODE_1 COUNT_BINARY #defineSTB_MODE_2 LSB_MSB COUNTER_MODE_2 COUNT_BINARY //microstrobe rate (40 kHz) #define MICRO PERIOD 0.000025 #define PERIOD_COUNT (DOS_TMR_FAST_CLK * MICRO_PERIOD) // =============== //LOCAL VARIABLES // =============== //Data structure: information unique to each supported head type // typedef struct ( //its name char name[25]; //data width in 16-pixel words : total, left section, right section int rasterWords. leftWords, rightWords : //polarity of data: word which turns OFF printed dots WORD ClrData; //resolution (DPI). width (pix), distance home sensor to left dot (pix) int dpi, nPixels, homeX : //nominal dot element resistance, tolerance (. 2 = 20%) double RDot. RDotTolerance: //thermistor characteristics : //pullup resistor, value @ 25 C, exponent Beta factor double thRPullup, thR25. thBeta : //absolute max temperature, max head heater setting (degrees F) int overTemp, headHeatMax : //min, max head force double forcel, force100 : //max print energy, watts double maxWatts : //energy rolloff factor per degree F double rolloff : } head_info_t; static const head_info_t near headlnfo [N_HEADTYPES+1] = { - ZNO PRINTHEAD INSTALLED", @0, 0. 0.

Ox0000, 0, 0, 0, <BR> <BR> 1.. 1..<BR> <BR> <BR> <P> 30000.. 30000.. 3950..

1.1, 0.. 0., 0., . 0070 }.

{ "KYOCERA KBE-57-12MGL2-GS", 42. 0.42.

Ox0000.

300. 672.672.

1710.. 0. 2.

30000., 30000., 3950..

160. 150.

3.. 15..

0. 100.

. 0070 ).

{ KYOCERA KBE-106-12MGL1-GS", 78. 36, 42, Ox0000.

300, 1248, 1248.

1710..0.2.

3000., 30000.. 3950..

160. 150.

5.6.27.9.

0.100.

. 0070 ) ): //Printhead variables, initialized from the"headlnfo"-structure // static BYTE near headNumber = Oxff ://head type ID&num , read from hardware static int near wordsPerLine ://data width: total, left, right static int near leftWords : static int near rightWords : static int near pairsToShift ://larger of leftWords, rightWords static int near resolution ://resolution in DPI static WORD near clearData ://"dots off data word static double near maxWatts ://max print energy static double near maxDutyCycle://corresponding max duty cycle // Lookup table: temperature in deg F for each thermistor A/D value // static BYTE near headTempTable [256] : //Variables for printing raster files // static int near activeBM : of file being printed static int near stripesToSend : stripes to print static BOOL near printing : //flag : printing active static BYTE near ssNum ://current substripe number (0.. 3) //Pointer to PrintBuffer data being printed / static WORD huge * imagePtr : //Arrays of graphic stripe data for printing // ------------------------------------ //previous, inverted static WORD near notPrevStripe [MAX_WORDS_PER_LINE]; //current, inverted static WORD near notCurrentStripe [MAX_WORDS_PER_LINE]; //cur, inv, shifted right 1 pix static WORD near notLeftStripe [MAX_WORDS_PER_LINE]; //cur, inv, shifted left 1 pix static WORD near notRightStripe [MAX_WORDS_PER_LINE]; : //"normal", for printhead static WORD near normalStripe [MAX_WORDS_PER_LINE] : // "edge" fot printhead static WORD near edgeStripe [MAX_WRDS_PER_LINE]; //print settings variables // ----------------------- static double near jobDutyCycle://duty cycle (from Print Energy) static double near ssMicroWeight [3] ://substripe weightings (from edge enh.) energy rolloff lookup table : //microstrobe duty cycle count & mode values for each substripe //entries for each possible themistor A/D reading // ------------------------------------------------------------ - static struct near { WORD count : BYTE mode: ) rolloffTable [256] [3] : //last 16 thermistor readings, index for storing next--one // ------------------------------------------------------- static BYTE near tHeadSample [16] : static int near tHeadIndex = 0 : #ifdefTWO_ROLLOFF_MODES static BOOL constantRolloff = FALSE : //flag : use constant rolloff factor <BR> <BR> &num endif<BR> <BR> <BR> <BR> <BR> <BR> &num i~fdef COUNT_DOTS static int near lineDots [3300] : of dots On for each line of raster file &num endif //bitmap flipped flag // ------------------- static BOOL near flipped: // ======== //LOCAL FUNCTION PROTOTYPES stat. ic void near buildEdgeStripe (void): static void near getNextStripe (void) : static void near setStrobeEnergy (int ss) : static void near shiftStripe (WORD near *pStripe) : static void near startPCycleTimer (double speed) : // //GLOBAL FUNCTION DEFINITIONS <BR> <BR> <BR> <BR> <BR> <BR> <BR> //------------------- //FUNCTION : AnalogFromHeadResistance // //PURPOSE : Converts a printhead resistance value from ohms to A/D //converter counts // //USAGE : BYTE AnalogFromHeadResistance (double r) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : r is a printhead resistance value in ohms // //RETURN VALUE: Corresponding value in A/D converter counts // //CALLS : PHEAD: GetHeadNumber () // // AFFECTS : none // ============================================================ ======================= BYTE AnalogFromHeadResistance (double r) { int data = 0 ; double rmin, rmax : //get min and max head resistance for this head type data = GetHeadNumber () rmin = headInfo [data]. RDot * (1.-headInfoUdata]. RDotTolerance) : rmax = nfo [data]. RDot * (1. + headlnfoCdata]. RDotTolerance) : if (rmax-rmin) return 0 : //compute A/D converter counts data = (int) (255. * (r-rmin)/ (rmax-rmin)) : if (data < 0) data = 0 : else if (data > 255) data = 255 : return data ; ============================================================ ================ //FUNCTION : AnalogFromHeadTemp // //PURPOSE : Converts a printhead temperature value from degrees F to A/D //converter counts // USAGE : BYTE AnalogFromHeadTemp (int temp) // //PROTOTYPE IN : PHEAD. H // //ARGUMENTS : temp is a printhead temperature value in degrees F // //RETURN VALUE: Corresponding value in A/D converter counts // //CALLS : PHEAD: GetHeadNumber () // // AFFECTS: none // ============================================================ ======================= BYTE AnalogFromHeadTemp (int temp) { int i. isave: i = GetHeadNumber () ://insure that head temp lookup table is initialized //save index into table of first temperature entry which is >= desired temp for (isave = 0, i = 0 : i<256 : i++) ( if (headTempTable [i] >= temp) isave-i : else break : } //return index (A/D counts) return isave: // ============================================================ ======================= //FUNCTION : ClearPrintHead // //PURPOSE : Shifts (and optionally latches) a line of'dots off data into //the printhead // //USAGE : void ClearPrintHead (BOOL latch) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : latch: TRUE= shift and latch data. FALSE= shift data only // //RETURN VALUE : none // //CALLS : (macros) <DOS. H>: inportb () //<DOS. H>: outportb () DATADEFS. H: DISABLE () //DATADEFS. H: ENABLEO // //AFFECTS : none // ============================================================ ======================= void ClearPrintHead (BOOL latch) { DISABLE () : //trig logic analyzer: start shifting outportb (LPT1, inportb (LPT1) I OxOl) : asm mov bx, clearData//BX ="dots off data asm mov cx, pairsToShift//CX = loop counter, pairs of words to shift clearTwoWords : asm mov ax, bx//load left shift register with"dots off"data asm mov dx. LEFTHEADSR asm out dx, ax asm mov dx. RIGHT_HEAD_SR //load right shift register (starts shifting) asm out dx, ax asm mov dx, DIGITAL_IN//set port addr for reading'shift done" waitClearDone ://loop here till"shift done'bit is set asm in ax, dx asm and ax. HEAD_SHIFT_DONE asm jz waitClearDone asm loop clearTwoWords//loop till CX = 0 //trig logic analyzer: end shifting outportb (LPT1, inportb (LPT1) &-Ox01) : if (latch)//optional latch data into head outportb (HEAD_LATCH, 0) : ENABLE () : } ============================================================ ===================== //FUNCTION : ComputeStrobeEnergy // //PURPOSE : Builds print energy rolloff table"rolloffTable"for upcoming //print cycle.

// //For each possible A/D reading of the printhead thermistor, //look-up values are generated for the timer and mode words //necessary to produce the desired micr-ostrobe duty cycle for //each sub-stripe.

// //Calculations are based on the energy-vs-temoerature factor rolloff* in the headInfo table for the current printhead.

// //Calculations are take into account the Head Temperature print //setting and values of module-level variables"jobDutyCycle" and"ssMicroWeight []". which are controlled by the Print Energy and Edge Enhancement print settings, respectively.

II //USAGE : void ComputeStrobeEnergy (void) // PROTOTYPE IN: PHEAD. H // ARGUMENTS : none // //RETURN VALUE: none // //CALLS : (macros) //DATADEFS. H: MAX() //DATADEFS. H: MIN() II (functions) //JOBCMDS : GetJobHeadTemp () // /l AFFECTS : none ============================================================ ======================= void ComputeStrobeEnergy (void) { double tempSetting ://Head Temperature print setting int i;//temperature index (head thermistor A/D counts) int j ://substripe index double temp ://temperature @ temperatur index double energyRolloff ;//energy rolloff factor @ temperature double ssMicroDuty ://rolled-off microstrobe duty cycle WORD pulseCount ://microstrobe counter value BYTE mode ://microstrobe mode word #ifdefTWO_ROLLOFF_MODES double kRoll = maxDutyCycle/250. : &num endif //get Head Temperature print setting, value at which there is no rolloff // (use no less than 70 degrees F) tempSetting = MAX (70., GetJobHeadTemp ()) : //Loop thru for each possible thermistor A/D reading: for (i=0 : i<256 : i++) ( //loop up the corresponding temperature (not less than 70 F) temp = (double) headTempTable [i] : temp MAX (70., temp) : #ifdefTWO_ROLLOFF_MODES if (constantRolloff) ( if (temp >= headInfoCheadNumber]. overTemp) energyRolloff = maxDutyCycle : else energyRolloff = kRoll * (temp-tempsetting) : ) else ( if (temp >= headInfo [headNumber]. overTemp) energyRolloff = 0; else energyRolloff = 1. - (headInfo[headNumber].rolloff * (temp-tempSetting)); ) #else //set energyRolloff multiplier : //if temp > max allowed for head. multiplier = 0 : if (temp >= headInfo [headNumber]. overTemp) energyRolloff = 0: else ( //else multiplier = 1 - (rolloff * delta temperature) energyRolloff = 1.- (headinfo [headNumber]. rolloff * (temp-tempSetting)) : //multiplier must be >= 0 if (energyRolloff < 0.) energyRolloff = 0. : ) &num endif //produce desired duty cycle for each substripe at current temperature for (j = 0; j < 3 : j++) (.

#ifdefTWOROLLOFFMODES if (constantRolloff) ( ssMicroDuty = (jobDutyCycle-energyRolloff) * ssMicroWeight [j] ; if (ssMicroDuty < 0.) ssMicroDuty = 0. ; } else ssMicroDuty = jobDutyCycle * ssMicroWeight [j] * energyRolloff : #else //duty cycle (DC) = nominal DC * substripe weighting * energyRollof ssMicroDuty = jobDutyCycle * ssMicroWeight [j] * energyRolloff: &num endif //observe max DC limits for each substripe if (j < 2) ssMicroDuty = MIN (ssMicroDuty maxDutyCycle * 1. 125): else ssMicroDuty = MIN (ssMicroDuty, maxDutyCycle) ; //setup micro strobe timers... if (ssMicroDuty < 0.5) ( //alternate strobes 1 and 2 pulseCount = (WORD) (PERIOD-COUNT * ssMicroDuty * 2) : mode = 0 ; } else ( //strobe strobes 1 and 2 together pulseCount = (WORD) (PERIOD_COUNT ssMicroDuty) : mode-4 : } //minimum timer value = 2, maximum = pulse period-2 if (pulseCount < 2) pulseCount = 2: else if (pulseCount > (WORD)PERIOD_COUNT - 2)) pulseCount = (WORD) PERIOD COUNT-2 : //place timer words in the lookup table rolloffTable [i] [j]. count = pulseCount : rolloffTable [i] [j]. mode = mode : ) ) // ============================================================ ======================= //FUNCTION : GetHeadHeatMax // //PURPOSE : Get maximum Head Temperature setting allowed by printhead // //USAGE : int GetHeadHeatMax (void) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : none // //RETURN VALUE: maximum Head Temperature setting, in degrees F // //CALLS : PHEAD: GetHeadNumber () // //AFFECTS: none ============================================================ ======================= int GetHeadHeatMax (void) ( return (headInfo [GetHeadNumber ()]. headHeatMax) : ) //FUNCTION : GetHeadHomeX // //PURPOSE : Get X-axis distance from home sensor to left-most dot on head // //USAGE : int GetHeadHomeX (void) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : none // //RETURN VALUE: home to left-dot distance, in pixels II //CALLS : PHEAD: GetHeadNumber () <BR> <BR> //<BR> //AFFECTS: none<BR> <BR> <BR> // AFFECTS: none // ============================================================ ======================= ( return (headInfo [GetHeadNumber ()]. homeX) ; } // ============================================================ ======================= // FUNCTION: GetHeadNumber // //PURPOSE : Reports ID number of current printhead // //USAGE : BYTE GetHeadNumber (void) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none // //RETURN VALUE: current printhead ID number 0 if none installed // //CALLS : PHEAD: InitHeadInfo () // //AFFECTS: none ============================================================ ======================= BYTE GetHeadNumber (void) ( if (headNumber > NHEADTYPES) headNumber = InitHeadlnfo ();//re-read from hardware if unknown return headNumber : } // ============================================================ ======================= //FUNCTION : GetHeadOverTemp // //PURPOSE : Get absolute max operating temperature of current peinthead // //USAGE : int GetHeadOverTemp (void) // //PROTOTYPE IN : PHEAD. H // ARGUMENTS : none // //RETURN VALUE: Absolute max temperature, in degrees F // //CALLS : PHEAD: GetHeadNumber () // // AFFECTS : none ============================================================ ======================= int GetHeadOverTemp (void) <BR> <BR> (<BR> <BR> <BR> <BR> <BR> return (headInfo [GetHeadNumber ()]. overTemp) :<BR> <BR> <BR> <BR> ) // ============================================================ ======================== // FUNCTION: GetMaxWatts //PURPOSE : Get maximum power for current printhead // //USAGE : double GetMaxWatts (void) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : none // //RETURN VALUE: maximum power for current printhead, in watts per dot // CALLS : none // //AFFECTS : none ============================================================ ====== double GetMaxWatts (void) { return maxWatts ; <BR> <BR> )<BR> <BR> <BR> <BR> <BR> <BR> ) //FUNCTION : GetNPixels // //PURPOSE : Get width of current printhead, in pixels // //USAGE : int GetNPixels (void) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : none // //RETURN VALUE: width of current printhead, in pixels // //CALLS : PHEAD: GetHeadNumber () // //AFFECTS: none ============================================================ ======================= int GetNPixels (void) ( return (headinfo [GetHeadNumber ()]. nPixels) ; <BR> <BR> I<BR> <BR> <BR> <BR> <BR> <BR> ) //FUNCTION : GetResolution // //PURPOSE : Get resolution of current print head // //USAGE : int GetResolution (void) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : none // //RETURN VALUE: print head resolution in dots per inch // //CALLS : PHEAD: GetHeadNumber () // //AFFECTS : updates variable"resolution" // ============================================================ ======================== int GetResolution (void) f return (resolution = headInfo [GetHeadNumber ()]. dpi) : y_ // ============================================================ ======================= //FUNCTION : GetWordsPerLine /1 //PURPOSE : Get printhead data width in 16-bit words // //USAGE : int GetWordsPerLine (void) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none //.

//RETURN VALUE: head width in 16-bit words // //CALLS : PHEAD: GetHeadNumber () // //AFFECTS : updates variable"wordsPerLine" // ============================================================ ======================== int GetWordsPerLine (void) ( return (wordsPerLine = headinfo [GetHeadNumber ()]. rasterWords) ; ! //FUNCTION : HeadResistanceFromAnalog // //PURPOSE : Converts raw A/D data from head resistance pot to ohms // //USAGE : double HeadResistanceFromAnalog (BYTE data) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : data: raw A/D data from head resistance pot // //RETURN VALUE: Head resistance in ohms // //CALLS : PHEAD: GetHeadNumber () // // AFFECTS : none ============================================================ ======================= double HeadResistanceFromAnalog (BYTE data) { double r, rnom, rtol ; rnom = headInfo [GetHeadNumber ()]. RDot: rtol = rnom * headInfo [GetHeadNumber ()]. RDotTolerance : r = rnom + ( (double) data-128.)/128. * rtol ; if (r < 0.) r = 0. : if (r > rnom+rtol) r = rnom + rtol : return r: //head resistance in ohms } // ============================================================ ======================== FUNCTION : HeadTempFromAnalog // //PURPOSE : Converts head temperature from raw A/D data from head //thermistor to degrees F // //USAGE : int HeadTempFromAnalog (BYTE data) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none // /1 RETURN VALUE: Head temperature in degrees F //.

//ALLS : PHEAD: GetHeadNumber () // //AFFECTS: none ============================================================ ======================= int HeadTempFromAnalog (BYTE data) ( GetHeadNumber () ://get head number, init if necessary return (int) headTempTableEdata] ;//head temp in deg. C l ============================================================ ======================= //FUNCTION : InitHeadInfo // //PURPOSE : Reads hardware for printhead ID jumpers.

Initializes printhead variables accordingly 1/ //USAGE : BYTE InitHeadInfo (void) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none // //RETURN VALUE: Printhead ID number : 0 if error // //CALLS : (macros) //<DOS. H>: inport () //DATADEFS. H: MAX () // // (functions) //<MATH. H> : exp () //<MATH. H> : logo // //AFFECTS : Initialized head temperature lookup table and other variables //based on hardware prinhead ID jumpers ============================================================ ======================= BYTE InitHeadInfo (void) { BYTE id : int i : double k. tempdata: //initialize microstrobe duty cycle energy weightings for each substripe //Normalized for using 3 substripes per line instead of 4 ssMicroWeight [0] = 1.125: ssMicroWeight [1] = 1.125: ssMicroWeight [2] =. 75: //read head id&num from hardware id- (BYTE) ((inport (DIGITAL_IN) && HEAD_TYPE_INPUTS)/Ox100) : if (id < N_HEADTYPES) ( id++ ;//add 1 to hardware reading (valid = 1 to n) #ifdef FORCE_4-INCH id = 2; &num endif //initialize thermistor A/D data-to-head temperature lookup table k = headInfo[id]. thR25/exp (headInfo[id]. thBeta/298.); headTempTable [0]-212 : headTempTable [255] = 0 : for (i = 1; i < 255: i++) l tempdata = headlnfo [id]. thBeta/ log (i * headInfo [id]. thRPullup/k/ (255-i))-273. : tempdata = (tempdata * 1. 8) + 32://convert to degrees f if (tempdata > 212.) headTempTabel[i] = 212 : else if (tempdata < 0.) headTempTable[i] = 0 : else headTempTable (i] = (BYTE) tempdata: ) //initialize other variables based on printhead ID resolution = headInfo [id]. dpi : clearData = headinfo [id]. ClrData : wordsPerLine = headlnfo [id]. rasterWords : leftWords = headInfo [id]. leftWords : rightWords = headInfo [id]. rightWords : pairsToShift = MAX (leftWords, rightWords) ; ) else id-0: //(invalid = 0) return id: ) ============================================================ ======================= FUNCTION : IsPrintDone // PURPOSE : Tests whether printing is done // //USAGE : BOOL IsPrintDone (void) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none // //RETURN VALUE: FALSE if printing in procress. else TRUE // //CALLS : none It //AFFECTS : none // ============================================================ ======================== <BR> <BR> <BR> <BR> <BR> BOOL IsPrintDone (void)<BR> <BR> <BR> { return ( ! printing) ? TRUE : FALSE : } ============================================================ ==================== //FUNCTION : KillPrint /1 : //PURPOSE : Stops printing // //USAGE : void KillPrint (void) It PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none // //RETURN VALUE: none // //CALLS : (macros) <DOS. H>: outportb () DATADEFS. H: DISABLE () //DATADEFS. H: ENABLE () // // (functions) //PHEAD : ClearPrintHead () // //AFFECTS : Shuts off microstrobes, kill stripe interrupts //Resets"printing"flag, latches"dots off data into head // ============================================================ ======================= void KillPrint (void) l DISABLEO : outportb (HEAD_STROBE_CTRL, 0); // disable strobes outportb (DDSICR. (DDSIcr &=-ENABLESTRIPEIRQ)) ://disable stripe irq printing-FALSE ://reset"printing"flag ClearPrintHead (TRUE) ://shift & latch"dots off"data into printhead ENABLEO : } FUNCTION : SendStripe // //PURPOSE : Latches previous data into head //Sets up proper microstrobe energy for printing it // //Does other processing depending on current substripe // //ssNum= 0 : Loads next stripe data from print buffer //Shifts"normal"stripe data to head // //ssNum= 1 : Computes"edge enhancement"stripe data //Continues printing"normal"stripe data // //ssNum= 2: Shifts'edge enhancement"stripe data to head // //USAGE : void SendStripe (void) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none // //RETURN VALUE: none // //CALLS : (macros) //<DOS. H>: inportb () //<DOS. H>: outportb() //DATADEFS. H: DISABLE () //DATADEFS. H: ENABLEO // (functions) //PHEAD : ClearPrintHead () //PHEAD : buildEdgeStripe () //PHEAD : getNextStripe () //PHEAD : setStrobeEnergy() //PHEAD : shiftStripe () <BR> <BR> //<BR> <BR> <BR> // AFFECTS : none<BR> <BR> <BR> // AFFECTS: none<BR> // ============================================================ ======================= void SendStripe(void) ( outportb (HEAD_LATCH. 0) : setStrobeEnergy (ssNum) ; if (stripesToSend == 0)//normal exit after last stripe sent { DISABLE () ://disable interrupts, save flag outportb (HEAD_STROBE_CTRL. 0): // disable strobes DDSIcr &-~ENABLE_STRIPE_IRO ://reset stripe irq enable bit outportb (DDS ICR. DDSIcr) ://reset enable bit in port printing = FALSE: ClearPrintHead (TRUE) ://redundant clear head. latch OFF bits ENABLE () ://restore interrupts ) else//count off stripe { ssNum++; if (ssNum--3) ( ssNum = 0 : stripesToSend-- :<BR> <BR> <BR> ) //set logic analyzer bits corresponding to ssNum outportb (LPT1. (inportb (LPT1) & 0x0C) (ssNum # 2) ); if (stripesToSend == 0) // no more data ClearPrintHead (FALSE) : // clear printhead else//more data { switch (ssNum) 1 case 0: getNextStripe () : shiftStripe (normalStripe) : break : case 1: buildEdgeStripe () break : case 2: shiftStripe (edgeStripe) : break: ) ) } <BR> <BR> <BR> <BR> <BR> <BR> <BR> ) //FUNCTION : SetCompensation // //PURPOSE : Sets"edge enhancement"effect.

//Adjusts duty-cycle weighting of"edge enhanced"substripe //relative to"normal"substripe.

// //USAGE : void SetCompensation (int comp) // //PROTOTYPE IN : PHEAD. H // //ARGUMENTS : comp: Edge Enhancement setting (0 to 100) // //RETURN VALUE: none // //CALLS : none // //AFFECTS : Substripe energy weightings"ssMicroWeight []" // ============================================================ ======================== void SetCompensation (int comp) { ssMicroWeight [0] = 1.125 : ssMicroWeight [1] = 1. 125: ssMicroWeight [2] = (double) (comp) / 44.; ) //FUNCTION : SetDutyCycle // //PURPOSE : Sets nominal microstrobe duty cycle // //USAGE : void SetDutyCycle (int n) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : n: Print Energy setting (0-100) // RETURN VALUE: none // //CALLS : PHEAD: GetHeadNumber () //PHEAD : HeadResistanceFromAnalog() //DDSHW : Analog () // //AFFECTS : variables maxWatts. maxDutyCycle, jobDutyCycle ============================================================ ======================= void SetDutyCycle (int n) ( double headResistance : headResistance = HeadResistanceFromAnalog (Analog (HEAD_OHMS_AD) ); maxWatts = headInfo (GetHeadNumber ()]. maxWatts : maxDutyCycle = maxWatts * headResistance/ (24.0 * 24. 0): jobDutyCycle = (double) n * maxDutyCycle/100.: } // ============================================================ ======================== FUNCTION : SetForce // //PURPOSE : Sets up head force to be used for printing // //USAGE : double SetForce (int n) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : n: Print Force setting (0-100) // //RETURN VALUE: Actual print head applied force in pounds // //CALLS : PHEAD: GetHeadNumber () il //AFFECTS : none ============================================================ ======================= double SetForce (int n) { double fl, flOO : if ( (n < 1) (n) 100)) return 0.0 : fl-headlnfo [GetHeadNumber ()]. forcel: f100 = headInfo[GetHeadNumber()]. force100; return (fl + ( (double) (n-1)/99.) * (f100 - f1) ); ) // ============================================================ ======================== //FUNCTION : SetupPrinting // //PURPOSE : Sets up a raster data file for printing // //USAGE : BOOL SetupPrinting (int * pBM. int * pLen. int xLoc, int yloc) // //PROTOTYPE IN: PHEAD. H // ARGUMENTS : pBM: pointer to bitmap file to be printed //pLen : pointer to number of raster lines to be printed //xLoc : starting X location //yLoc : starting Y location // //RETURN VALUE: Error status: TRUE if error, else FALSE // //CALLS : (macros) //DATADEFS. H: MIN() // (functions) //<STDIO. H>: printf() /l PHEAD : GetNPixels () // PHEAD: GetMaxWatts() //PHEAD : getNextStripe () //PHEAD : setStrobeEnergy () //PHEAD : shiftStripe () //PHEAD : startPCycleTimer () //DDSHW : Analog () //JOBCMDS : GetJobFlipY () //JOBCMDS : GetJobPrintEnergyNum () //JOBCMDS : GetJobPrintSpeed() //MOTOR : GetMaxMove() //MOTOR : GetMaxYMove () //RASTER : CloseRasterFile () // RASTER : DeleteRasterFile() // RASTER : GetPrintData() //RASTER : GetRasterHeight () //RASTER : GetRasterTempFlag () //RASTER : OpenPrintDataFile () <BR> <BR> //RASTER : ShiftedRasterFile ()<BR> <BR> <BR> // //AFFECTS : none ============================================================ ======================== BOOL SetupPrinting (int * pBM, int * pLen, int xLoc, int yLoc) { BOOL errStat = FALSE ://error flag: none yet int oldBM = * pBM; // raster file numbers: original, shifted int newBM : int maxXmove = GetMaxXMove (); //max X position of left-most dot int i ://counters : general-purpose. word, stripe int word : int stripe: WORD huge *bufPtr ://pointer to page buffer #ifdefCOUNT_DOTS long dotTotal = 0 ; &num endif flipped = GetJobFlipY(); //test for flipped bitmap //&num stripes: lesser of raster file height, distance to bottom of bed stripesToSend = MIN (GetRasterHeight (oldBM). GetMaxYMove ()-yLoc) : if (stripesToSend <= 0)//flag error if nothing to print errStat = TRUE : if ( ! errStat)//if no errors yet - { *pLen = stripesToSend ://tell caller how many stripes if (xLoc >= (maxXmove + GetNPixels () ) ) //if starting X is beyond width of bed, flag error errStat = TRUE : else if (xLoc > maxXmove) ( //else if starting x is beyond point where we can place the first dot //we have to build a new, temporary raster file, shifting data to right newBM = ShifteRasterFile ( oldBM, maxXmove, xLoc, wordsPerLine. yLoc, stripesToSend. TRUE) : //if succesful creating shifted file. tell the caller we're using the //new shifted raster file, else flag error if (newBM > oldBM) *pBM = activeBM = newBM : else errStat = TRUE : ) else //else no shift needed, tell caller we're printing the original file *pBM = activeBM = oldBM; } if ( ! errStat)//if no errors yet ( errStat = OpenPrintDataFile (activeBM) ://open raster file, flag errors if ( ! errStat) l imagePtr = PrintBuffer ://point to start of print buffer //LOOP TO COPY RASTER DATA LINE-BY-LINE TO PRINT BUFFER //-.-- for (stripe-0 : stripe < stripesToSend: stripe++) ( //flag error if not enough room for another line if (imagePtr + wordsPerLine >= PrintBufferEnd) ( errStat = TRUE : break: ) //else (enough room) zero out next line of print buffer bufPtr = imagePtr for (word = 0 : word < wordsPerLine : word++) *bufPtr++-0 ; #ifdefCOUNT_DOTS //copy stripe of file data from file to buffer (dot-counting version) lineDots [stripe] = GetPrintData (imagePtr) ; dotTotal += lineDots[stripe]; #else //copy stripe of data from file to buffer (non-dot-counting version) GetPrintData (imagePtr) ; &num endif //point to next line of print buffer imagePtr += wordsPerLine : } //LOOP DONE: if (flipped) //point to last line of print buffer for flipped bitmap imagePtr = PrintBuffer + (long) wordsPerLine * (long) (stripesToSend-1) : else //point to first line of print buffer for normal bitmap imagePtr = PrintBuffer: CloseRasterFile (activeBM) ://close raster file if (GetRasterTempFlag (activeBM))//if raster file was temporary (shifted) DeleteRasterFile (activeBM) ://delete it } } if ( ! errStat) ( //print nominal dot power #ifdefCOUNT_DOTS printf ("Average power : ~. 2f\r\n", dotTotal/stripesToSend * GetMaxWatts() * GetJobPrintEnergyNum() / 100.); &num endif //set speed of stripe IRO timer startPCycleTimer (GetJobPrintSpeed ()); ) if ( ! errStat)//if no errors yet { //fill inverted current stripe data for upcoming edge enhancement for (word = 0: word < wordsPerLine : word++) notCurrentStripe[word] = Oxffff : getNextStripe() ://fetch first stripe from array ssNum = 0 ://init substripe counter to 0 shiftStripe (normalStripe) ://shift first stripe to head } if (errStat)//if errors, tell caller: { *pBM = 0 ://printing no bitmap *pLen = 0; //length is zero ) //Initialize array tHeadSample [] to current thermistor data for (i = 0; i < 16 : i++) tHeadSample [il = Analog (HEADTEMPAD) ; tHeadIndex = 0 : setStrobeEnergy (0) ;//set duty cycle for first substripe return errStat ://return error status flag ============================================================ ======================== FUNCTION : StartPrinting // //PURPOSE : Starts interrupt-driven printing via stripe timer IRQ // //USAGE : void StartPrinting (void) // //PROTOTYPE IN: PHEAD. H // //ARGUMENTS : none // //RETURN VALUE: none // //CALLS : (macros) //<DOS. H>: outportb () //DATADEFS. H: DISABLE () //DATADEFS. H: ENABLE () // // (functions) //PHEAD : setStrobeEnergy () // // AFFECTS: none // ============================================================ ======================== void StartPrinting (void) { setStrobeEnergy (0) ://set duty cycle for first substripe printing = TRUE ://printing begins now DISABLEO : DDSIcr l= ENABLE_STRIPE_IRQ; //Enable stripe timer IRO :"or"in irq enable bit outportb (DDS_ICR. DDSIcr) ://set enable bit in port ENABLE () : } // =========================== //LOCAL FUNCTION DEFINITIONS // ========================== // ============================================================ ======================== //FUNCTION : buildEdgeStripe // //PURPOSE : Builds "edgeStripe[]". line of edge enhancement data for head // //Each dot in this stripe is 1 (ON) if: // //current dot is 1 and (current dot was previously 0 // {OR dot to its left is 0 // {OR dot to its right is 0 // //USAGE : void near buildEdgeStripe (void) // //PROTOTYPE IN: local // //ARGUMENTS : none // RETURN VALUE : none // //CALLS : (macros) //<DOS. H>: inportb () //<DOS. H>: outportb () //<DOS. H>: FPOFF () // //AFFECTS : Updates array edgestripe (l. intermediate arrays /l notLeftStripe [] and notRightStripet] // ============================================================ ======================== void near buildEdgeStripe (void) = //trig logic analyzer: start computing edge stripe data outportb (LPT1, inportb (LPT1) 0x02); asm push es//save ES asm mov ax, ds asm mov es, ax//set ES to data segment DS //Form a 1 pixel left shifted version of the inverted current stripe to //represent dots without right neighbors.

// //This assumes a pixel organization as follows: // // word: 0 1 2 ... n //pixel : 15 0 15 0 15 0 // // * asm std//set direction flag for auto decrement SI-FP OFF (notCurrentStripe) ://DS: SI = source = notCurrentStripe _DI = FP_OFF (notRightStripe) ://ES: DI = dest = notRightStripe asm mov cx. wordsPerLine//CX = wordsPerLine asm mov bx. cx//BX = 2 * (CX-1) asm dec bx-offset in bytes to last word in each asm add bx. bx stripe buffer asm add si, bx//Add BX offset to SI and to DI asm add di. bx asm stc//set carry before starting shift // (data is inverted) next-lshift : asm lodsw//get a word from notCurrentStripe asm rcl ax, 1//shift 1 bit left asm stosw//store shifted version in notRightStripe asm loop next_lshift//loop till done //Form a 1 pixel right shifted version for dots without left neighbors // (See above comment for data organization) // ------------------------------------------------------------ ---------- asm cld //clear direction flag for auto increment _SI = FP_OFF (notCurrentStripe); //DS:SI = source = notCurrentStripe _DI = FP_OFF(notLeffStripe): //ES : DI = dest = notLeftStripe asm mov cx. wordsPerLine//CX = wordsPerLine asm stc//set carry before starting shift // (data is inverted) nextrshift : asm lodsw//get a word from notCurrentStripe asm rcr ax, 1//shift 1 bit right asm stosw//store shifted version in notLeftStripe asm loop next_rshift//loop till done //Merge data from notCurrentStripe, notPrevStripe, notLeftStripe and //notRightStripe to form edge-enhancement data edgeStripe.

// //Each bit in edgestripe is set to 1 if corresponding merged bits are: //notCurrent = 0 AND (notLeft=1 OR notRight=1 notLeft=1) / /A-This result bit is XORed with'dots off" bit in clearData to set correct //polarity for printing when shifted to the head // //leave direction flag set for auto increment SI = FP_OFF(notCurrentStripe) ://DS: SI = source = notCurrentStripe DIDI-FP OFF (edgeStripe) ://ES: DI = dest = edgeStripe asm mov cx, wordsPerLine //CX = wordsPerLine asm mov bx. 0//BX = offset to notPrev, notLeft, & notRight next-edge : asm mov dx, word ptr notPrevStripe tbx]//dx = notPrev OR notLeft OR notRight asm or dx, word ptr notLeftStripe tbx] asm or dx, word ptr notRightStripe tbx] asm lodsw//get word from notCurrentStripe asm not ax//flip it to normal polarity asm and ax, dx//AND it with mask bits in DX asm xor ax, clearData //XOR it with"dots off"bits in clearData asm stosw//store it in edgeStripe asm add bx, 2//increment offset to next mask asm loop next_edge//loop till done asm pop es//restore original contents of ES //trig logic analyzer: done computing edge stripe data outportb (LPT1, inportb (LPT1) &-Ox02) : J FUNCTION : getNextStripe // //PURPOSE : Fetches a stripe of raster data from the print buffer //Builds array normalStripe ] for shifting to head //Builds arrays notPrevStripe [] and notCurrentStripe [] for //later use in computing edge enhancement stripe // //USAGE : void near getNextStripe (void) // //PROTOTYPE IN: local // //ARGUMENTS : none // RETURN VALUE : none // //CALLS : (macros) //<DOS. H>: inportb() /1 <DOS. H>: outportb() //<DOS. H>: FPOFF () //<DOS. H>: FPSEG () // //AFFECTS : updates print buffer pointer bufPtr updates arrays normalStriope[]. notPrevStripe[] and // notCurrentStripe[] // ============================================================ ======================== void near getNextStripe (void) { //trig logic analyzer: start computing normal stripe data outportb (LPT1. inportb (LPT1) # Ox02) : asm push es//save contents of DS and ES asm push ds asm cld//clear direction flag for auto increment //throughout this routine //Copy former contents of notCurrentStripe ) into notPrevStripe [] // asm mov ax, ds//set ES to data segment DS asm mov es, ax _SI = FP_OFF (notCurrentStripe) ://DS: SI = source = notCurrentStripe _DI-FP_OFF (notPrevStripe) ://ES: DI = dest = notPrevStripe asm mov cx, wordsPerLine//CX = wordsPerLine asm mov bx, cx//BX = wordsPerLine (save a copy) asm rep movsw//copy data _DS = FP_SEG (imagePtr) : //DS : SI = source = imagePtr (current SI-FPOFF (imagePtr) : // (line of print buffer) DI-FP_OFF (notCurrentStripe) ;//ES : DI = dest = notCurrentStripe asm mov cx. bx//CX = copy of wordsPerLine next from buffer : asm lodsw//get word from bitmap buffer asm not ax//complement data asm stosw//store in notCurrentStripe asm loop next_from_buffer//loop till done asm pop ds//restore DS (current data segment) //Copy/invert from notCurrentStripe [] (XORed with"dots off data) //to normalStripe [] for upcoming shift to head.

//..------------- SI = FP_OFF (notCurrentStripe)://DS: SI = source =--notCurrentStripe _DI-FP_OFF (normalStripe) ://ES: DI = dest = normalStripe asm mov dx, clearData//DX ="dots off* data = clearData asm mov cx. bx//CX = copy of wordsPerLine next normal : asm lodsw//get word from notCurrentStripe asm not ax//complement it back to normal asm xor ax, dx//XOR it with"dots off'value @asm stosw//store it to normalStripe asm loop next_normal//loop till done asm pop es//restore ES if (flipped) imagePtr -= wordsPerLine ://back up one line for flipped bitmap else imagePtr += wordsPerLine ://advance one line for normal bitmap //trig logic analyzer: done computing normal stripe data outportb (LPT1, inportb (LPT1) &-0x02) ; <BR> <BR> <BR> <BR> <BR> <BR> <BR> ).

//FUNCTION : setStrobeEnergy // //PURPOSE : Sets timer value and mode to produce the correct duty cycle //value for the selected sub-stripe // //USAGE : void near setStrobeEnergy (int ss) // //PROTOTYPE IN: local // ARGUMENTS : ss: sub-stripe number for which to set duty cycle // //RETURN VALUE: none // //CALLS : (macro) // <DOS. H>: outportb() // // (function) // DOSHW : Analog () // // AFFECTS: none // ============================================================ ======================== void near setStrobeEnergy (int ss) ( WORD pulseCount ://timer counter value for microstrobe on-time BYTE mode ://timer mode for microstrobe on-time WORD tHeadAverage ://average of recent head thermistor A/D readings int i ;//general-purpose counter //grab new thermistor reading, stuff it via pointer to array //bump pointer for next time tHeadSamplettHeadindex++] = Analog (HEAD_TEMP_AD) if (tHeadIndex >-16) tHeadlndex = 0 : //compute average of thermistor values for (tHeadAverage = 0. i = 0 ; i < 16 : i++) tHeadAverage +-tHeadSample [i]: tHeadAverage #= 4; //divide by 16 //use rolloffTable for lookup of microstrobe timer count and mode //corresponding to thermistor average and sub-stripe pulseCount = rolloffTable [tHeadAverage] [ss]. count: -mode = rolloffTable [tHeadAverage] [ss].mode: //update duty cycle period timer to constant rate outportb (DDS_TMR_345-CTRL. COUNTER_1 STB_MODE_20; outportb (DDS_TMR_4. (WORD)PERIOD_COUNT): outportb (DDS_TMR_4. ((WORD)PERIOD_COUNT) # 8): //updated duty-cycle on-time timer to looked-up on-time outportb (DDS_TMR_345_CTRL. COUNTER_2 STB_MODE_1) : outportb (DDSTMR5. pulseCount) : outportb (DDS TMR_5, pulseCount » 8) : //setup strobe control lines per looked-up mode word ou. tportb (HEADSTROBECTRL. mode) 3)://set us mode, strobes enabled // ============================================================ ======================== FUNCTION : shiftStripe // //PURPOSE : Shifts a stripe of raster data to the printhead // USAGE : void near shiftStripe (WORD near *Stripe) // PROTOTYPE IN: local // ARGUMENTS : pStripe : pointer to a stripe of data for the printhead // //RETURN VALUE: none // //CALLS : (macros) // <DOS. H>: inportb () //<DOS. H>: outportb () //<DOS. H>: FPOFF () // //AFFECTS : none // ============================================================ ======================== void near shiftStripe (WORD near *pStripe) ( //trig logic analyzer: start shifting stripe data outportb (LPT1. inportb (LPT1) # Ox01) ; asm push ds//save contents of DS asm mov bx, leftWords//BX = offset in words to data for right part of head asm mov cx, pairsToShift//CX = number of word pairs to shift out to head _AX = FP_OFF (pStripe) ://AX = (near) ptr to first (left) word of stripe asm add ax, bx//DI = AX + (2 * BX) asm add ax, bx 1/= ptr to of data for right part of head asm mov di, ax asm sub ax, cx//SI = DI- (2 * CX) asm sub ax, cx-ptr to data for left part of head asm mov si, ax// (may contain leading garbage) asm mov bx. 0//BX = 0 = running offset to add to SI and to DI //LOOP TO SHIFT 2 WORDS OF DATA TO HEAD (LEFT & RIGHT SIMULTANEOUSLY) //-...-..-. shiftTwoWords: asm mov dx. LEFTHEADSR//port number for left head shift reg asm mov ax. [bx+si]//fetch a word asm out dx. ax//load left shift reg (no shift yet) asm mov dx. RIGHTHEADSR//port number for right head shift reg asm mov ax, [bx+di]//fetch a word asm out dx. ax//load right shift reg (starts shifting) asm add bx. 2//bump offset to next words of data #ifdefAMPRO_CM4861I <BR> <BR> // WAIT FOR SHIFT COMPLETE: SOFTWARE DELAY LOOP.

It //MACHINE DEPENDENT. BUT FASTER THAN HARDWARE METHOD // (REQUIRED FOR RELIABLE 2-INCH-PER-SECOND PRINTING WITH 4"WIDE HEAD) // //Delay just long enough so that I/O write to LEFTHEADSR always occurs //just after the HEADSHIFTDONE signal from the XILINX gate array goes //high. This must be determined emperically using a scope or analyzer.

// ------------------------------------------------------------ ---------- asm mov ax, 28//loop counter (determined emperically) waitShiftDone : asm dec ax//dec counter asm jnz waitShiftDone//loop till we've waited long enough asm loop shiftTwoWords//END OF LOOP. SHIFT 2 MORE WORDS #else // ------------------------------------------------------------ ---------- //WAIT FOR SHIFT COMPLETE: READ BACK THE LEFTHEADSR SIGNAL IN HARDWARE // MACHINE INDEPENDENT. BUT SLOWER (TOO SLOW FOR RELIABLE 2-INCH-PER-SECOND PRINTING WITH 4"WIDE HEAD) // ------------------------------------------------------------ --------- asm mov dx. DIGITALIN//Set port address for reading waitShiftDone: asm in ax. dx://read (slow. since it waits for ISA bus) asm and ax, HEAD_SHIFT_DONE//is shift done signal hi yet asm jz waitShiftDone//loop if it ain't #endif //DONE // ---- asm pop ds//restore DS //trig logic analyzer : done shifting stripe data outportb (LPT1, inportb (LPT1) & #0x01): } // ============================================================ ======================== //FUNCTION: startPCycleTimer // //PURPOSE : Sets up and starts print stripe timer for correct print speed // //USAGE : void near startPCycleTimer (double speed) // //PROTOTYPE IN: local // //ARGUMENTS : speed: desired print speed in inches per second // /7 RETURN VALUE: none // //CALLS : (macro) //<DOS. H>: outportb () // //AFFECTS : Stripe timer (does not enable stripe IRONS) // ============================================================ ======================== void near startPCycleTimer (double speed) ( WORD Timer count : //compute counter value desired substripe rate Timer_count = (WORD) (DDS_TMR_SLOW_CLK/ (speed * resolution * 3)): //program the timer to run outportb (DDSTMR012CTRL.

COUNTER0 # LSB_MSB | COUNTER_MODE_2 t COUNT_BINARY) : outportb (DDSTMR0. Timercount) : outportb (ODS_TMR_0, Timer_count » B) : } #ifdef TWO_ROLLOFF_MODES // ============================================================ ========================= //FUNCTION : SetConstantRolloff //GetConstantRolloff // //PURPOSE : SetConstantRolloff: Sets/clears constantRolloff flag.

//GetConstantRolloff : Returns value of the constantRolloff flag // //If the flag is set, duty cycle is rolled off by a constant //amount per degree F, unaffected by the Print Energy setting // //If the flag is clear. duty cycle is rolled off by a //percentage amount per degree F, based on the Print Energy setting.

// //USAGE : void SetConstantRolloff (BOOL flag) // BOOL GetConstantRolloff (void) // //PROTOTYPE IN: local // ARGUMENTS : For SetConstantRolloff : new value for constantRolloff flag //For GetConstantRolloff: none // /t RETURN VALUE : For SetConstantRolloff : none For GetConstantRolloff : current value of constantRolloff flag // //CALLS : none // //AFFECTS : Energy vs temperature rolloff via value constantRolloff flag // ======= void SetConstantRolloff (BOOL flag) { constantRolloff = flag: ) BOOL GetConstantRolloff (void) f return constantRolloff : ) &num endif