View Javadoc
1   /*
2    * Copyright 2009, openv4j.sf.net, and individual contributors as indicated
3    * by the @authors tag. See the copyright.txt in the distribution for a
4    * full listing of individual contributors.
5    *
6    * This is free software; you can redistribute it and/or modify it
7    * under the terms of the GNU General Public License as
8    * published by the Free Software Foundation; either version 3 of
9    * the License, or (at your option) any later version.
10   *
11   * This software is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14   * Lesser General Public License for more details.
15   *
16   * You should have received a copy of the GNU Lesser General Public
17   * License along with this software; if not, write to the Free
18   * Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
19   * 02110-1301 USA, or see the FSF site: http://www.fsf.org.
20   *
21   * $Id: $
22   *
23   * @author arnep
24   */
25  package net.sf.openv4j.protocolhandlers;
26  
27  import java.util.Calendar;
28  import java.util.Date;
29  
30  import net.sf.openv4j.CycleTimeEntry;
31  import net.sf.openv4j.CycleTimes;
32  import net.sf.openv4j.ErrorListEntry;
33  import net.sf.openv4j.Holiday;
34  
35  /**
36   * DOCUMENT ME!
37   *
38   * @author aploese
39   */
40  public abstract class MemoryImage {
41      /**
42       * DOCUMENT ME!
43       *
44       * @param address DOCUMENT ME!
45       *
46       * @return DOCUMENT ME!
47       */
48      public abstract int getRawByte(int address);
49  
50      /**
51       * DOCUMENT ME!
52       *
53       * @param addr DOCUMENT ME!
54       * @param theData DOCUMENT ME!
55       */
56      public abstract void setRawByte(int addr, byte theData);
57  
58      /**
59       * DOCUMENT ME!
60       *
61       * @param addr DOCUMENT ME!
62       * @param d DOCUMENT ME!
63       */
64      public void addTime(int addr, Date d) {
65          Calendar c = Calendar.getInstance();
66          c.setTime(d);
67          c.set(Calendar.HOUR_OF_DAY, decodeBCD(getRawByte(addr)));
68          c.set(Calendar.MINUTE, decodeBCD(getRawByte(addr + 1)));
69          c.set(Calendar.SECOND, decodeBCD(getRawByte(addr + 2)));
70          d.setTime(c.getTimeInMillis());
71      }
72  
73      /**
74       * DOCUMENT ME!
75       *
76       * @param addr DOCUMENT ME!
77       *
78       * @return DOCUMENT ME!
79       */
80      public Boolean getBool(int addr) {
81          final int value = getRawByte(addr);
82  
83          return (value == 0x00ff) ? null : (value != 0);
84      }
85  
86      /**
87       * DOCUMENT ME!
88       *
89       * @param addr DOCUMENT ME!
90       *
91       * @return DOCUMENT ME!
92       */
93      public Byte getByte(int addr) {
94          int result = getRawByte(addr);
95  
96          if (result == 0xff) {
97              return null;
98          }
99  
100         return (byte) result;
101     }
102 
103     /**
104      * DOCUMENT ME!
105      *
106      * @param addr DOCUMENT ME!
107      * @param numberOfCycleTimes DOCUMENT ME!
108      *
109      * @return DOCUMENT ME!
110      */
111     public CycleTimes getCycleTimes(int addr, int numberOfCycleTimes) {
112         CycleTimes result = new CycleTimes(numberOfCycleTimes / 2);
113 
114         for (int i = 0; i < (numberOfCycleTimes / 2); i++) {
115             int dataByte = getRawByte(addr + (i * 2));
116 
117             if (dataByte == 0xff) {
118                 result.setEntry(i, null);
119             } else {
120                 result.setEntry(i, new CycleTimeEntry());
121                 result.getEntry(i).setStart((dataByte & 0xF8) >> 3, (dataByte & 7) * 10);
122                 dataByte = getRawByte(addr + (i * 2) + 1);
123                 result.getEntry(i).setEnd((dataByte & 0xF8) >> 3, (dataByte & 7) * 10);
124             }
125         }
126 
127         return result;
128     }
129 
130     /**
131      * DOCUMENT ME!
132      *
133      * @param addr DOCUMENT ME!
134      *
135      * @return DOCUMENT ME!
136      */
137     public ErrorListEntry getErrorListEntry(int addr) {
138         return new ErrorListEntry(getRawByte(addr), getTimeStamp_8(addr + 1));
139     }
140 
141     /**
142      * DOCUMENT ME!
143      *
144      * @param addr DOCUMENT ME!
145      *
146      * @return DOCUMENT ME!
147      */
148     public Holiday getHoliday(int addr) {
149         Holiday result = new Holiday();
150         result.setStart(getTimeStamp_Date(addr));
151         result.setStartFlag((byte) getRawByte(addr + 4));
152         addTime(addr + 5, result.getStart());
153         result.setEnd(getTimeStamp_Date(addr + 8));
154         result.setEndFlag((byte) getRawByte(addr + 12));
155         addTime(addr + 13, result.getEnd());
156 
157         return result;
158     }
159 
160     /**
161      * DOCUMENT ME!
162      *
163      * @param addr DOCUMENT ME!
164      *
165      * @return DOCUMENT ME!
166      */
167 
168     // swap bytes
169     public Integer getInteger(int addr) {
170         int result = getRawByte(addr);
171         result |= (getRawByte(addr + 1) << 8);
172         result |= (getRawByte(addr + 2) << 16);
173         result |= (getRawByte(addr + 3) << 24);
174 
175         if (result == 0xffffffff) {
176             return null;
177         }
178 
179         return result;
180     }
181 
182     /**
183      * DOCUMENT ME!
184      *
185      * @param addr DOCUMENT ME!
186      *
187      * @return DOCUMENT ME!
188      */
189 
190     // swap bytes
191     public Short getShort(int addr) {
192         int result = getRawByte(addr);
193         result |= (getRawByte(addr + 1) << 8);
194 
195         if (result == 0xffff) {
196             return null;
197         }
198 
199         return (short) result;
200     }
201 
202     /**
203      * DOCUMENT ME!
204      *
205      * @param addr DOCUMENT ME!
206      *
207      * @return DOCUMENT ME!
208      */
209 
210     // Byte order as is
211     public Short getShortHex(int addr) {
212         int result = getRawByte(addr) << 8;
213         result |= getRawByte(addr + 1);
214 
215         return (result == 0xffff) ? null : (short) result;
216     }
217 
218     /**
219      * DOCUMENT ME!
220      *
221      * @param addr DOCUMENT ME!
222      *
223      * @return DOCUMENT ME!
224      */
225     public Date getTimeStamp_8(int addr) {
226         Calendar c = Calendar.getInstance();
227         int year = (decodeBCD(getRawByte(addr)) * 100) + decodeBCD(getRawByte(addr + 1));
228         int month = decodeBCD(getRawByte(addr + 2) - 1);
229         int day = decodeBCD(getRawByte(addr + 3));
230 
231         //day of week getByte(addr + 4);
232         int h = decodeBCD(getRawByte(addr + 5));
233         int min = decodeBCD(getRawByte(addr + 6));
234         int s = decodeBCD(getRawByte(addr + 7));
235         c.set(year, month, day, h, min, s);
236 
237         return c.getTime();
238     }
239 
240     /**
241      * DOCUMENT ME!
242      *
243      * @param addr DOCUMENT ME!
244      *
245      * @return DOCUMENT ME!
246      */
247     public Date getTimeStamp_Date(int addr) {
248         Calendar c = Calendar.getInstance();
249         int year = (decodeBCD(getRawByte(addr)) * 100) + decodeBCD(getRawByte(addr + 1));
250         int month = decodeBCD(getRawByte(addr + 2) - 1);
251         int day = decodeBCD(getRawByte(addr + 3));
252 
253         c.set(year, month, day);
254 
255         return c.getTime();
256     }
257 
258     /**
259      * DOCUMENT ME!
260      *
261      * @param addr DOCUMENT ME!
262      *
263      * @return DOCUMENT ME!
264      */
265     public Short getUByte(int addr) {
266         int result = getRawByte(addr);
267 
268         if (result == 0xff) {
269             return null;
270         }
271 
272         return (short) result;
273     }
274 
275     /**
276      * DOCUMENT ME!
277      *
278      * @param addr DOCUMENT ME!
279      *
280      * @return DOCUMENT ME!
281      */
282     public Integer getUShort(int addr) {
283         int result = getRawByte(addr);
284         result |= (getRawByte(addr + 1) << 8);
285 
286         if (result == 0xffff) {
287             return null;
288         }
289 
290         return (int) result;
291     }
292 
293     /**
294      * DOCUMENT ME!
295      *
296      * @param addr DOCUMENT ME!
297      * @param value DOCUMENT ME!
298      */
299     public void setBool(int addr, boolean value) {
300         setRawByte(addr, (byte) (value ? 1 : 0));
301     }
302 
303     /**
304      * DOCUMENT ME!
305      *
306      * @param addr DOCUMENT ME!
307      * @param value DOCUMENT ME!
308      */
309     public void setByte(int addr, byte value) {
310         setRawByte(addr, value);
311     }
312 
313     /**
314      * DOCUMENT ME!
315      *
316      * @param addr DOCUMENT ME!
317      * @param theData DOCUMENT ME!
318      */
319     public void setBytes(int addr, byte[] theData) {
320         for (int i = 0; i < theData.length; i++) {
321             setRawByte(addr + i, theData[i]);
322         }
323     }
324 
325     /**
326      * DOCUMENT ME!
327      *
328      * @param addr DOCUMENT ME!
329      * @param value DOCUMENT ME!
330      */
331     public void setInteger(int addr, int value) {
332         setRawByte(addr, (byte) value);
333         setRawByte(addr + 1, (byte) ((value >> 8) & 0x00FF));
334         setRawByte(addr + 2, (byte) ((value >> 16) & 0x00FF));
335         setRawByte(addr + 3, (byte) ((value >> 24) & 0x00FF));
336     }
337 
338     /**
339      * DOCUMENT ME!
340      *
341      * @param addr DOCUMENT ME!
342      * @param value DOCUMENT ME!
343      */
344     public void setShort(int addr, short value) {
345         setRawByte(addr, (byte) value);
346         setRawByte(addr + 1, (byte) ((value >> 8) & 0x00FF));
347     }
348 
349     /**
350      * DOCUMENT ME!
351      *
352      * @param addr DOCUMENT ME!
353      * @param value DOCUMENT ME!
354      */
355     public void setShortHex(int addr, short value) {
356         setRawByte(addr, (byte) ((value >> 8) & 0x00FF));
357         setRawByte(addr + 1, (byte) (value & 0x00FF));
358     }
359 
360     private int decodeBCD(int bcdByte) {
361         return (bcdByte & 0x0F) + (((bcdByte & 0x00F0) >> 4) * 10);
362     }
363 }