Statistics
| Branch: | Revision:

ddr4s / fw / wiringPi / devLib / ds1302.c @ 32:cadb9025f1e0

History | View | Annotate | Download (5.73 KB)

1
/*
2
 * ds1302.c:
3
 *        Real Time clock
4
 *
5
 * Copyright (c) 2013 Gordon Henderson.
6
 ***********************************************************************
7
 * This file is part of wiringPi:
8
 *        https://projects.drogon.net/raspberry-pi/wiringpi/
9
 *
10
 *    wiringPi is free software: you can redistribute it and/or modify
11
 *    it under the terms of the GNU Lesser General Public License as published by
12
 *    the Free Software Foundation, either version 3 of the License, or
13
 *    (at your option) any later version.
14
 *
15
 *    wiringPi is distributed in the hope that it will be useful,
16
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
17
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18
 *    GNU Lesser General Public License for more details.
19
 *
20
 *    You should have received a copy of the GNU Lesser General Public License
21
 *    along with wiringPi.  If not, see <http://www.gnu.org/licenses/>.
22
 ***********************************************************************
23
 */
24

    
25
#include <stdio.h>
26
#include <stdlib.h>
27
#include <stdint.h>
28
#include <stdarg.h>
29

    
30
#include <wiringPi.h>
31

    
32
#include "ds1302.h"
33

    
34
// Register defines
35

    
36
#define        RTC_SECS         0
37
#define        RTC_MINS         1
38
#define        RTC_HOURS         2
39
#define        RTC_DATE         3
40
#define        RTC_MONTH         4
41
#define        RTC_DAY                 5
42
#define        RTC_YEAR         6
43
#define        RTC_WP                 7
44
#define        RTC_TC                 8
45
#define        RTC_BM                31
46

    
47

    
48
// Locals
49

    
50
static int dPin, cPin, sPin ;
51

    
52
/*
53
 * dsShiftIn:
54
 *        Shift a number in from the chip, LSB first. Note that the data is
55
 *        sampled on the trailing edge of the last clock, so it's valid immediately.
56
 *********************************************************************************
57
 */
58

    
59
static unsigned int dsShiftIn (void)
60
{
61
  uint8_t value = 0 ;
62
  int i ;
63

    
64
  pinMode (dPin, INPUT) ;        delayMicroseconds (1) ;
65

    
66
  for (i = 0 ; i < 8 ; ++i)
67
  {
68
    value |= (digitalRead (dPin) << i) ;
69
    digitalWrite (cPin, HIGH) ; delayMicroseconds (1) ;
70
    digitalWrite (cPin, LOW) ;        delayMicroseconds (1) ;
71
  }
72

    
73
  return value;
74
}
75

    
76

    
77
/*
78
 * dsShiftOut:
79
 *        A normal LSB-first shift-out, just slowed down a bit - the Pi is
80
 *        a bit faster than the chip can handle.
81
 *********************************************************************************
82
 */
83

    
84
static void dsShiftOut (unsigned int data)
85
{
86
  int i ;
87

    
88
  pinMode (dPin, OUTPUT) ;
89

    
90
  for (i = 0 ; i < 8 ; ++i)
91
  {
92
    digitalWrite (dPin, data & (1 << i)) ;        delayMicroseconds (1) ;
93
    digitalWrite (cPin, HIGH) ;                        delayMicroseconds (1) ;
94
    digitalWrite (cPin, LOW) ;                        delayMicroseconds (1) ;
95
  }
96
}
97

    
98

    
99
/*
100
 * ds1302regRead: ds1302regWrite:
101
 *        Read/Write a value to an RTC Register or RAM location on the chip
102
 *********************************************************************************
103
 */
104

    
105
static unsigned int ds1302regRead (const int reg)
106
{
107
  unsigned int data ;
108

    
109
  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
110
    dsShiftOut (reg) ;
111
    data = dsShiftIn () ;
112
  digitalWrite (sPin, LOW)  ; delayMicroseconds (1) ;
113

    
114
  return data ;
115
}
116

    
117
static void ds1302regWrite (const int reg, const unsigned int data)
118
{
119
  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
120
    dsShiftOut (reg) ;
121
    dsShiftOut (data) ;
122
  digitalWrite (sPin, LOW)  ; delayMicroseconds (1) ;
123
}
124

    
125

    
126
/*
127
 * ds1302rtcWrite: ds1302rtcRead:
128
 *        Writes/Reads the data to/from the RTC register
129
 *********************************************************************************
130
 */
131

    
132
unsigned int ds1302rtcRead (const int reg)
133
{
134
  return ds1302regRead (0x81 | ((reg & 0x1F) << 1)) ;
135
}
136

    
137
void ds1302rtcWrite (int reg, unsigned int data)
138
{
139
  ds1302regWrite (0x80 | ((reg & 0x1F) << 1), data) ;
140
}
141

    
142

    
143
/*
144
 * ds1302ramWrite: ds1302ramRead:
145
 *        Writes/Reads the data to/from the RTC register
146
 *********************************************************************************
147
 */
148

    
149
unsigned int ds1302ramRead (const int addr)
150
{
151
  return ds1302regRead (0xC1 | ((addr & 0x1F) << 1)) ;
152
}
153

    
154
void ds1302ramWrite (const int addr, const unsigned int data)
155
{
156
  ds1302regWrite ( 0xC0 | ((addr & 0x1F) << 1), data) ;
157
}
158

    
159
/*
160
 * ds1302clockRead:
161
 *        Read all 8 bytes of the clock in a single operation
162
 *********************************************************************************
163
 */
164

    
165
void ds1302clockRead (int clockData [8])
166
{
167
  int i ;
168
  unsigned int regVal = 0x81 | ((RTC_BM & 0x1F) << 1) ;
169

    
170
  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
171

    
172
  dsShiftOut (regVal) ;
173
  for (i = 0 ; i < 8 ; ++i)
174
    clockData [i] = dsShiftIn () ;
175

    
176
  digitalWrite (sPin, LOW) ;  delayMicroseconds (1) ;
177
}
178

    
179

    
180
/*
181
 * ds1302clockWrite:
182
 *        Write all 8 bytes of the clock in a single operation
183
 *********************************************************************************
184
 */
185

    
186
void ds1302clockWrite (const int clockData [8])
187
{
188
  int i ;
189
  unsigned int regVal = 0x80 | ((RTC_BM & 0x1F) << 1) ;
190

    
191
  digitalWrite (sPin, HIGH) ; delayMicroseconds (1) ;
192

    
193
  dsShiftOut (regVal) ;
194
  for (i = 0 ; i < 8 ; ++i)
195
    dsShiftOut (clockData [i]) ;
196

    
197
  digitalWrite (sPin, LOW) ;  delayMicroseconds (1) ;
198
}
199

    
200

    
201
/*
202
 * ds1302trickleCharge:
203
 *        Set the bits on the trickle charger.
204
 *        Probably best left alone...
205
 *********************************************************************************
206
 */
207

    
208
void ds1302trickleCharge (const int diodes, const int resistors)
209
{
210
  if (diodes + resistors == 0)
211
    ds1302rtcWrite (RTC_TC, 0x5C) ;        // Disabled
212
  else
213
    ds1302rtcWrite (RTC_TC, 0xA0 | ((diodes & 3) << 2) | (resistors & 3)) ;
214
}
215

    
216

    
217

    
218

    
219
/*
220
 * ds1302setup:
221
 *        Initialise the chip & remember the pins we're using
222
 *********************************************************************************
223
 */
224

    
225
void ds1302setup (const int clockPin, const int dataPin, const int csPin)
226
{
227
  dPin = dataPin ;
228
  cPin = clockPin ;
229
  sPin = csPin ;
230

    
231
  digitalWrite (dPin, LOW) ;
232
  digitalWrite (cPin, LOW) ;
233
  digitalWrite (sPin, LOW) ;
234

    
235
  pinMode (dPin, OUTPUT) ;
236
  pinMode (cPin, OUTPUT) ;
237
  pinMode (sPin, OUTPUT) ;
238

    
239
  ds1302rtcWrite (RTC_WP, 0) ;        // Remove write-protect
240
}