【3D打印】xyzprinter Da Vinci 1.0打印机刷材料盒线材长度复位程序

yuanzhihang1

XYZPrinting达芬奇是一个非常有趣的打印机。它提供了一个只有300g材料盒，打完就要换原厂的材料盒（有一个芯片保存了材料盒中材料的存量）。

这篇教程教怎么在使用外部材料的情况下刷新原厂的芯片中的材料存量。

  背景知识

打开墨盒后，可以在其底部找到一个小PCB。它有三个连接器用于与打印机本身进行通信。仔细检查该微小PCB显示了Microchip 11LC010 1K EEPROM的核心。该EEPROM具有128字节的存储容量，其存储关于长丝盒的信息。

SCIO引脚运行UNI / O协议，芯片通过8位指令寄存器进行控制。

  步骤

0. 将打印机的墨盒拿出来，找到底部的芯片

1. 创建一个的Arduino程序（程序已经写好见附件），程序可以写入EEPROM的内容，把计数器重置为999m剩余可用材料。

这里是EEPROM的内容。

您可以在字节偏移53处看到一个小字节格式的4字节长HEX值，这反映了传送给打印机的剩余长丝长度。这不是一个字面值，而是以某种方式“被破坏”。但是，将此值设置为0x3f420f00将灯丝计数器恢复为剩余999m。（想要复写计数器就保持默认）

00：5A41570000343141C0D40100C0D40100 ZAW..41A ...... ..
10：D2005A00544847423031313500000000 ..Z.THGB0115 ...。
20：000000003400000001010101AA55AA55 ... .4 ...... ..UU
30：883355AA 3F420f00 D04407202FAE0A00 .3U ...... D。/ ...
40：5A41570000343141C0D40100C0D40100 ZAW..41A ...... ..
50：D2005A00544847423031313500000000 ..Z.THGB0115 ...。
60：000000003400000001010101AA55AA55 ... .4 ...... ..UU
70：883355AAC0D40100AA55AA5507830A00 .3U ...... UU ...。

2. 写入Arduino该程序
写入没有开始时，Arduino上的LED会闪烁。
3. 以一下方式分别连接Arduino上的引脚和材料盒子上的触点

三个连接器如下（从上图的左到右）：

1. 线材盒接头=Arduino接头

复制代码

4. 按照上述方法进行上述连接后，LED将保持点亮约2秒，然后闪烁一下，表示EEPROM已成功写入。5. 实际测试是否可以打印，如果显示Unidentified Cartridge的错误，重新从0步骤开始刷芯片

参考https://www.voltivo.com/da-vinci ... t-using-an-arduino/

程序：

1. 
   
2. #ifndef _NANODEUNIO_LIB_H
   
3. #define _NANODEUNIO_LIB_H
   
4. 
   
5. #if ARDUINO >= 100
   
6.   #include <Arduino.h> // Arduino 1.0
   
7. #else
   
8.   #include <WProgram.h> // Arduino 0022
   
9. #endif
   
10. 
    
11. #define NANODE_MAC_DEVICE 0xa0
    
12. #define NANODE_MAC_ADDRESS 0xfa
    
13. 
    
14. #define CODE 0x00 //1 Byte
    
15. #define MATERIAL 0x01 //1 Byte
    
16. #define COLOR 0x02  //2 Bytes
    
17. #define DATE 0x05        //4 Bytes
    
18. #define TOTALLEN 0x08 //4 Bytes
    
19. #define NEWLEN 0x0C //4 Bytes
    
20. #define HEADTEMP 0x10        //2 Bytes
    
21. #define BEDTEMP 0x12        //2Bytes
    
22. #define MLOC 0x14        //2 Bytes
    
23. #define DLOC 0x16        //2 Bytes
    
24. #define SN 0x18                //12 Bytes
    
25. #define CRC 0x24        //2 Bytes
    
26. #define LEN2 0x34        //4 Bytes
    
27. #define EOFM 0x38        //4 Bytes
    
28. #define SCODE 0x3c        //4 Bytes
    
29. 
    
30. void IncrementSerial(unsigned char * cArray, long lAddress, long lSize)
    
31. {
    
32.         unsigned char szTempBuffer[20] = {0};
    
33.         memcpy(szTempBuffer,&cArray[lAddress],lSize);
    
34.         long lSerial = atol((char *)szTempBuffer);
    
35.         lSerial++;
    
36.         sprintf((char *)szTempBuffer,"%04d",lSerial);
    
37.         memcpy(&cArray[lAddress],szTempBuffer,lSize);
    
38. }
    
39. 
    
40. class NanodeUNIO {
    
41. private:
    
42.   byte addr;
    
43. public:
    
44.   NanodeUNIO(byte address);
    
45. 
    
46.   boolean read(byte *buffer,word address,word length);
    
47.   boolean start_write(const byte *buffer,word address,word length);
    
48.   boolean enable_write(void);
    
49.   boolean disable_write(void);
    
50.   boolean read_status(byte *status);
    
51.   boolean write_status(byte status);
    
52.   boolean await_write_complete(void);
    
53.   boolean simple_write(const byte *buffer,word address,word length);
    
54. };
    
55. 
    
56. #endif /* _NANODEUNIO_LIB_H */
    
57. 
    
58. #define UNIO_STARTHEADER 0x55
    
59. #define UNIO_READ        0x03
    
60. #define UNIO_CRRD        0x06
    
61. #define UNIO_WRITE       0x6c
    
62. #define UNIO_WREN        0x96
    
63. #define UNIO_WRDI        0x91
    
64. #define UNIO_RDSR        0x05
    
65. #define UNIO_WRSR        0x6e
    
66. #define UNIO_ERAL        0x6d
    
67. #define UNIO_SETAL       0x67
    
68. 
    
69. #define UNIO_TSTBY 600
    
70. #define UNIO_TSS    10
    
71. #define UNIO_THDR    5
    
72. #define UNIO_QUARTER_BIT 10
    
73. #define UNIO_FUDGE_FACTOR 5
    
74. #define UNIO_OUTPUT() do { DDRD |= 0x80; } while (0)
    
75. #define UNIO_INPUT() do { DDRD &= 0x7f; } while (0)
    
76. 
    
77. static void set_bus(boolean state) {
    
78.   PORTD=(PORTD&0x7f)|(!!state)<<7;
    
79. }
    
80. 
    
81. static boolean read_bus(void) {
    
82.   return !!(PIND&0x80);
    
83. }
    
84. static void unio_inter_command_gap(void) {
    
85.   set_bus(1);
    
86.   delayMicroseconds(UNIO_TSS+UNIO_FUDGE_FACTOR);
    
87. }
    
88. 
    
89. static void unio_standby_pulse(void) {
    
90.   set_bus(0);
    
91.   UNIO_OUTPUT();
    
92.   delayMicroseconds(UNIO_TSS+UNIO_FUDGE_FACTOR);
    
93.   set_bus(1);
    
94.   delayMicroseconds(UNIO_TSTBY+UNIO_FUDGE_FACTOR);
    
95. }
    
96. 
    
97. static volatile boolean rwbit(boolean w) {
    
98.   boolean a,b;
    
99.   set_bus(!w);
    
100.   delayMicroseconds(UNIO_QUARTER_BIT);
     
101.   a=read_bus();
     
102.   delayMicroseconds(UNIO_QUARTER_BIT);
     
103.   set_bus(w);
     
104.   delayMicroseconds(UNIO_QUARTER_BIT);
     
105.   b=read_bus();
     
106.   delayMicroseconds(UNIO_QUARTER_BIT);
     
107.   return b&&!a;
     
108. }
     
109. 
     
110. static boolean read_bit(void) {
     
111.   boolean b;
     
112.   UNIO_INPUT();
     
113.   b=rwbit(1);
     
114.   UNIO_OUTPUT();
     
115.   return b;
     
116. }
     
117. 
     
118. static boolean send_byte(byte b, boolean mak) {
     
119.   for (int i=0; i<8; i++) {
     
120.     rwbit(b&0x80);
     
121.     b<<=1;
     
122.   }
     
123.   rwbit(mak);
     
124.   return read_bit();
     
125. }
     
126. 
     
127. static boolean read_byte(byte *b, boolean mak) {
     
128.   byte data=0;
     
129.   UNIO_INPUT();
     
130.   for (int i=0; i<8; i++) {
     
131.     data = (data << 1) | rwbit(1);
     
132.   }
     
133.   UNIO_OUTPUT();
     
134.   *b=data;
     
135.   rwbit(mak);
     
136.   return read_bit();
     
137. }
     
138. 
     
139. static boolean unio_send(const byte *data,word length,boolean end) {
     
140.   for (word i=0; i<length; i++) {
     
141.     if (!send_byte(data[i],!(((i+1)==length) && end))) return false;
     
142.   }
     
143.   return true;
     
144. }
     
145. 
     
146. static boolean unio_read(byte *data,word length)  {
     
147.   for (word i=0; i<length; i++) {
     
148.     if (!read_byte(data+i,!((i+1)==length))) return false;
     
149.   }
     
150.   return true;
     
151. }
     
152. 
     
153. static void unio_start_header(void) {
     
154.   set_bus(0);
     
155.   delayMicroseconds(UNIO_THDR+UNIO_FUDGE_FACTOR);
     
156.   send_byte(UNIO_STARTHEADER,true);
     
157. }
     
158. 
     
159. NanodeUNIO::NanodeUNIO(byte address) {
     
160.   addr=address;
     
161. }
     
162. 
     
163. #define fail() do { sei(); return false; } while (0)
     
164. 
     
165. boolean NanodeUNIO::read(byte *buffer,word address,word length) {
     
166.   byte cmd[4];
     
167.   cmd[0]=addr;
     
168.   cmd[1]=UNIO_READ;
     
169.   cmd[2]=(byte)(address>>8);
     
170.   cmd[3]=(byte)(address&0xff);
     
171.   unio_standby_pulse();
     
172.   cli();
     
173.   unio_start_header();
     
174.   if (!unio_send(cmd,4,false)) fail();
     
175.   if (!unio_read(buffer,length)) fail();
     
176.   sei();
     
177.   return true;
     
178. }
     
179. 
     
180. boolean NanodeUNIO::start_write(const byte *buffer,word address,word length) {
     
181.   byte cmd[4];
     
182.   if (((address&0x0f)+length)>16) return false; // would cross page boundary
     
183.   cmd[0]=addr;
     
184.   cmd[1]=UNIO_WRITE;
     
185.   cmd[2]=(byte)(address>>8);
     
186.   cmd[3]=(byte)(address&0xff);
     
187.   unio_standby_pulse();
     
188.   cli();
     
189.   unio_start_header();
     
190.   if (!unio_send(cmd,4,false)) fail();
     
191.   if (!unio_send(buffer,length,true)) fail();
     
192.   sei();
     
193.   return true;
     
194. }
     
195. 
     
196. boolean NanodeUNIO::enable_write(void) {
     
197.   byte cmd[2];
     
198.   cmd[0]=addr;
     
199.   cmd[1]=UNIO_WREN;
     
200.   unio_standby_pulse();
     
201.   cli();
     
202.   unio_start_header();
     
203.   if (!unio_send(cmd,2,true)) fail();
     
204.   sei();
     
205.   return true;
     
206. }
     
207. 
     
208. boolean NanodeUNIO::disable_write(void) {
     
209.   byte cmd[2];
     
210.   cmd[0]=addr;
     
211.   cmd[1]=UNIO_WRDI;
     
212.   unio_standby_pulse();
     
213.   cli();
     
214.   unio_start_header();
     
215.   if (!unio_send(cmd,2,true)) fail();
     
216.   sei();
     
217.   return true;
     
218. }
     
219. 
     
220. boolean NanodeUNIO::read_status(byte *status) {
     
221.   byte cmd[2];
     
222.   cmd[0]=addr;
     
223.   cmd[1]=UNIO_RDSR;
     
224.   unio_standby_pulse();
     
225.   cli();
     
226.   unio_start_header();
     
227.   if (!unio_send(cmd,2,false)) fail();
     
228.   if (!unio_read(status,1)) fail();
     
229.   sei();
     
230.   return true;
     
231. }
     
232. 
     
233. boolean NanodeUNIO::write_status(byte status) {
     
234.   byte cmd[3];
     
235.   cmd[0]=addr;
     
236.   cmd[1]=UNIO_WRSR;
     
237.   cmd[2]=status;
     
238.   unio_standby_pulse();
     
239.   cli();
     
240.   unio_start_header();
     
241.   if (!unio_send(cmd,3,true)) fail();
     
242.   sei();
     
243.   return true;
     
244. }
     
245. 
     
246. boolean NanodeUNIO::await_write_complete(void) {
     
247.   byte cmd[2];
     
248.   byte status;
     
249.   cmd[0]=addr;
     
250.   cmd[1]=UNIO_RDSR;
     
251.   unio_standby_pulse();
     
252.   do {
     
253.     unio_inter_command_gap();
     
254.     cli();
     
255.     unio_start_header();
     
256.     if (!unio_send(cmd,2,false)) fail();
     
257.     if (!unio_read(&status,1)) fail();
     
258.     sei();
     
259.   } while (status&0x01);
     
260.   return true;
     
261. }
     
262. 
     
263. boolean NanodeUNIO::simple_write(const byte *buffer,word address,word length) {
     
264.   word wlen;
     
265.   while (length>0) {
     
266.     wlen=length;
     
267.     if (((address&0x0f)+wlen)>16) {
     
268.       wlen=16-(address&0x0f);
     
269.     }
     
270.     if (!enable_write()) return false;
     
271.     if (!start_write(buffer,address,wlen)) return false;
     
272.     if (!await_write_complete()) return false;
     
273.     buffer+=wlen;
     
274.     address+=wlen;
     
275.     length-=wlen;
     
276.   }
     
277.   return true;
     
278. }
     
279. 
     
280. static void status(boolean r)
     
281. {
     
282.   if (r) Serial.println("(success)");
     
283.   else Serial.println("(failure)");
     
284. }
     
285. 
     
286. static void dump_eeprom(word address,word length)
     
287. {
     
288.   byte buf[128];
     
289.   char lbuf[80];
     
290.   char *x;
     
291.   int i,j;
     
292. 
     
293.   NanodeUNIO unio(NANODE_MAC_DEVICE);
     
294.   
     
295.   memset(buf,0,128);
     
296.   status(unio.read(buf,address,length));
     
297.   
     
298.   for (i=0; i<128; i+=16) {
     
299.     x=lbuf;
     
300.     sprintf(x,"%02X: ",i);
     
301.     x+=4;
     
302.     for (j=0; j<16; j++) {
     
303.       if (!(j & 0x03)) {
     
304.         sprintf(x, " ");
     
305.         x+=1;
     
306.       }
     
307.       sprintf(x,"%02X",buf[i+j]);
     
308.       x+=2;
     
309.     }
     
310.     *x=32;
     
311.     x+=1;
     
312.     for (j=0; j<16; j++) {
     
313.       if (buf[i+j]>=32 && buf[i+j]<127) *x=buf[i+j];
     
314.       else *x=46;
     
315.       x++;
     
316.     }
     
317.     *x=0;
     
318.     Serial.println(lbuf);
     
319.   }
     
320. }
     
321. 
     
322. int led = 13;
     
323. 
     
324. /*
     
325. These are the values to be written to the EEPROM
     
326. Make sure only one is uncommented.
     
327. By default its set for the starter ABS cartdridge with 120m of filament
     
328. 
     
329. Verified with firmware 1.1.I
     
330. */
     
331. 
     
332. // Value to write to the EEPROM for remaining filament lenght
     
333. // Default Starter Cartdridge is 120m
     
334. 
     
335. //char x[] = {0xc0,0xd4,0x01,0x00}; //120m
     
336. char x[] = {0x80,0xa9,0x03,0x00}; //240m
     
337. //char x[] = {0x80,0x1a,0x06,0x00}; //400m
     
338. 
     
339. // extruder temp, default is 210 C for ABS
     
340. // 180 C for PLA
     
341. //char et[] = {0xb4,0x00}; // 180 C
     
342. //char et[] = {0xb9,0x00}; // 185 C
     
343. //char et[] = {0xbe,0x00}; // 190 C
     
344. //char et[] = {0xc8,0x00}; // 200 C
     
345. //char et[] = {0xd2,0x00}; // 210 C
     
346. char et[] = {0xe6,0x00}; // 230 C
     
347. //char et[] = {0xf5,0x00}; // 245 C
     
348. //char et[] = {0xfa,0x00}; // 250 C
     
349. 
     
350. // bed temp 90 degrees, default ABS
     
351. // 30 degrees foe PLA
     
352. char bt[] = {0x5a,0x00}; // 90 C
     
353. //char bt[] = {0x1e,0x00}; // 30 C
     
354. 
     
355. char cc[] = {0xa7,0x06,0x0b,0x00}; //seems to be relavent to the first 5 characters of Serial number. In this case RF10X
     
356. //char cc[] = {0x07,0x83,0x0a,0x00}; // for serial number beginning with 3DP01
     
357. 
     
358. char ef[] = {0xaa,0x55,0xaa,0x55};
     
359. 
     
360. char mt[] = {0x41}; // Material - "A" for ABS
     
361. //char mt[] = {0x50}; // Material - "P" for PLA
     
362. 
     
363. char cr[] = {0x5a,0x00}; // COLOUR - Default-0x5a,0x00  [White-0x57,0x00 Blue-0x42,0x00 Green-0x47,0x00 Black-0x4B,0x00 Red-0x52,0x00 Yellow-0x59,0x00 VirginViolet-0x43,0x00]
     
364. 
     
365. byte sr;
     
366. NanodeUNIO unio(NANODE_MAC_DEVICE);
     
367.   
     
368. void setup() {
     
369.   pinMode(13, OUTPUT);
     
370.   Serial.begin(115200);
     
371. }
     
372. 
     
373. void loop() {
     
374.   
     
375.   do {
     
376.     digitalWrite(led, LOW);
     
377.     Serial.println("Testing connection to Da Vinci EEPROM CHIP\n");   
     
378.     delay(100);
     
379.     digitalWrite(led, HIGH);
     
380.   } while(!unio.read_status(&sr));
     
381.   
     
382.   Serial.println("Da Vinci EEPROM found...");
     
383.   Serial.println("Reading the Davinci EEPROM Contents...");
     
384.   dump_eeprom(0,128);
     
385.   //dump_eeprom(116,4);
     
386. 
     
387.   //*
     
388.   //Read the serial number - added by Matt
     
389.   byte buf[20];
     
390.   memset(buf,0,20);
     
391.   status(unio.read(buf,SN,12));
     
392.   //Increment the serial number
     
393.   IncrementSerial(&buf[0], 0, 12);       
     
394. 
     
395.   Serial.println("Updating EEPROM...");
     
396.   status(unio.simple_write((const byte *)mt,MATERIAL,1));
     
397.   status(unio.simple_write((const byte *)cr,COLOR,2));
     
398.   status(unio.simple_write((const byte *)x,TOTALLEN,4));
     
399.   status(unio.simple_write((const byte *)x,NEWLEN,4));
     
400.   status(unio.simple_write((const byte *)et,HEADTEMP,2)); // extruder temp
     
401.   status(unio.simple_write((const byte *)bt,BEDTEMP,2)); // bed temp
     
402.   //Write the serial number
     
403.   status(unio.simple_write((const byte *)buf,SN,12)); //Serial Number
     
404.   status(unio.simple_write((const byte *)x,LEN2,4));
     
405.   status(unio.simple_write((const byte *)ef,EOFM,4));
     
406.   status(unio.simple_write((const byte *)cc,SCODE,4));
     
407.   // same block from offset 0 is offset 64 bytes
     
408.   status(unio.simple_write((const byte *)mt,64 + MATERIAL,1));
     
409.   status(unio.simple_write((const byte *)cr,64 + COLOR,2));
     
410.   status(unio.simple_write((const byte *)x,64 + TOTALLEN,4));
     
411.   status(unio.simple_write((const byte *)x,64 + NEWLEN,4));
     
412.   status(unio.simple_write((const byte *)et,64 + HEADTEMP,2)); // extruder temp
     
413.   status(unio.simple_write((const byte *)bt,64 + BEDTEMP,2)); // bed temp
     
414.    //Write the serial number
     
415.   status(unio.simple_write((const byte *)buf,64 + SN,12)); //Serial Number
     
416.   status(unio.simple_write((const byte *)x,64 + LEN2,4));
     
417.   status(unio.simple_write((const byte *)ef,64 + EOFM,4));
     
418.   status(unio.simple_write((const byte *)cc,64 + SCODE,4));
     
419. 
     
420.   Serial.println("Dumping Content after modification...");
     
421.   dump_eeprom(0,128);
     
422.   // */
     
423.   
     
424.   digitalWrite(led, HIGH);   // turn the LED on
     
425.   delay(10000);               // wait for two seconds
     
426. }
     

复制代码