source: rtos_arduino/trunk/arduino_lib/libraries/Ciao/src/lib/SC16IS750.cpp@ 175

Last change on this file since 175 was 175, checked in by ertl-honda, 8 years ago

ライブラリを Arduino IDE 1.7.9 にupdate
File size: 10.8 KB
Line 
1/*
2Description:
3This is a example code for Sandbox Electronics' I2C/SPI to UART bridge module.
4You can get one of those products on
5http://sandboxelectronics.com
6
7Version:
8V0.1
9
10Release Date:
112014-02-16
12
13Author:
14Tiequan Shao info@sandboxelectronics.com
15
16Lisence:
17CC BY-NC-SA 3.0
18
19Please keep the above information when you use this code in your project.
20*/
21
22#if defined(__AVR_ATmega328P__)
23
24#include "SC16IS750.h"
25#include <Wire.h>
26
27#define WIRE Wire
28
29
30WifiData::WifiData(uint8_t prtcl, uint8_t addr_sspin)
31{
32 protocol = prtcl;
33 if ( protocol == SC16IS750_PROTOCOL_I2C ) {
34 device_address_sspin = (addr_sspin>>1);
35 } else {
36 device_address_sspin = addr_sspin;
37 }
38 peek_flag = 0;
39}
40
41void WifiData::begin(uint32_t baud)
42{
43 //Serial.println("1111111111111111");
44 if ( protocol == SC16IS750_PROTOCOL_I2C) {
45 //Serial.println("22222222222222");
46 WIRE.begin();
47 }
48 ResetDevice();
49 FIFOEnable(1);
50 SetBaudrate(baud);
51 SetLine(8,0,1);
52}
53
54int WifiData::available(void)
55{
56 return FIFOAvailableData();
57}
58
59int WifiData::read(void)
60{
61 if ( peek_flag == 0) {
62 return ReadByte();
63 } else {
64 peek_flag = 0;
65 return peek_buf;
66 }
67}
68
69size_t WifiData::write(uint8_t val)
70{
71 WriteByte(val);
72}
73
74void WifiData::pinMode(uint8_t pin, uint8_t i_o)
75{
76 GPIOSetPinMode(pin, i_o);
77}
78
79void WifiData::digitalWrite(uint8_t pin, uint8_t value)
80{
81 GPIOSetPinState(pin, value);
82}
83
84uint8_t WifiData::digitalRead(uint8_t pin)
85{
86 return GPIOGetPinState(pin);
87}
88
89
90uint8_t WifiData::ReadRegister(uint8_t reg_addr)
91{
92 uint8_t result;
93 if ( protocol == SC16IS750_PROTOCOL_I2C ) { // register read operation via I2C
94
95 WIRE.beginTransmission(device_address_sspin);
96 WIRE.write((reg_addr<<3));
97 WIRE.endTransmission(0);
98 WIRE.requestFrom(device_address_sspin,(uint8_t)1);
99 result = WIRE.read();
100 }
101
102 return result;
103
104}
105
106void WifiData::WriteRegister(uint8_t reg_addr, uint8_t val)
107{
108 if ( protocol == SC16IS750_PROTOCOL_I2C ) { // register read operation via I2C
109 WIRE.beginTransmission(device_address_sspin);
110 WIRE.write((reg_addr<<3));
111 WIRE.write(val);
112 WIRE.endTransmission(1);
113 }
114
115
116 return ;
117}
118
119int16_t WifiData::SetBaudrate(uint32_t baudrate) //return error of baudrate parts per thousand
120{
121 uint16_t divisor;
122 uint8_t prescaler;
123 uint32_t actual_baudrate;
124 int16_t error;
125 uint8_t temp_lcr;
126 if ( (ReadRegister(SC16IS750_REG_MCR)&0x80) == 0) { //if prescaler==1
127 prescaler = 1;
128 } else {
129 prescaler = 4;
130 }
131
132 divisor = (SC16IS750_CRYSTCAL_FREQ/prescaler)/(baudrate*16);
133
134 temp_lcr = ReadRegister(SC16IS750_REG_LCR);
135 temp_lcr |= 0x80;
136 WriteRegister(SC16IS750_REG_LCR,temp_lcr);
137 //write to DLL
138 WriteRegister(SC16IS750_REG_DLL,(uint8_t)divisor);
139 //write to DLH
140 WriteRegister(SC16IS750_REG_DLH,(uint8_t)(divisor>>8));
141 temp_lcr &= 0x7F;
142 WriteRegister(SC16IS750_REG_LCR,temp_lcr);
143
144
145 actual_baudrate = (SC16IS750_CRYSTCAL_FREQ/prescaler)/(16*divisor);
146 error = ((float)actual_baudrate-baudrate)*1000/baudrate;
147
148 return error;
149
150}
151
152void WifiData::SetLine(uint8_t data_length, uint8_t parity_select, uint8_t stop_length )
153{
154 uint8_t temp_lcr;
155 temp_lcr = ReadRegister(SC16IS750_REG_LCR);
156 temp_lcr &= 0xC0; //Clear the lower six bit of LCR (LCR[0] to LCR[5]
157
158 switch (data_length) { //data length settings
159 case 5:
160 break;
161 case 6:
162 temp_lcr |= 0x01;
163 break;
164 case 7:
165 temp_lcr |= 0x02;
166 break;
167 case 8:
168 temp_lcr |= 0x03;
169 break;
170 default:
171 temp_lcr |= 0x03;
172 break;
173 }
174
175 if ( stop_length == 2 ) {
176 temp_lcr |= 0x04;
177 }
178
179 switch (parity_select) { //parity selection length settings
180 case 0: //no parity
181 break;
182 case 1: //odd parity
183 temp_lcr |= 0x08;
184 break;
185 case 2: //even parity
186 temp_lcr |= 0x18;
187 break;
188 case 3: //force '1' parity
189 temp_lcr |= 0x03;
190 break;
191 case 4: //force '0' parity
192 break;
193 default:
194 break;
195 }
196
197 WriteRegister(SC16IS750_REG_LCR,temp_lcr);
198}
199
200void WifiData::GPIOSetPinMode(uint8_t pin_number, uint8_t i_o)
201{
202 uint8_t temp_iodir;
203
204 temp_iodir = ReadRegister(SC16IS750_REG_IODIR);
205 if ( i_o == OUTPUT ) {
206 temp_iodir |= (0x01 << pin_number);
207 } else {
208 temp_iodir &= (uint8_t)~(0x01 << pin_number);
209 }
210
211 WriteRegister(SC16IS750_REG_IODIR, temp_iodir);
212 return;
213}
214
215void WifiData::GPIOSetPinState(uint8_t pin_number, uint8_t pin_state)
216{
217 uint8_t temp_iostate;
218
219 temp_iostate = ReadRegister(SC16IS750_REG_IOSTATE);
220 if ( pin_state == 1 ) {
221 temp_iostate |= (0x01 << pin_number);
222 } else {
223 temp_iostate &= (uint8_t)~(0x01 << pin_number);
224 }
225
226 WriteRegister(SC16IS750_REG_IOSTATE, temp_iostate);
227 return;
228}
229
230
231uint8_t WifiData::GPIOGetPinState(uint8_t pin_number)
232{
233 uint8_t temp_iostate;
234
235 temp_iostate = ReadRegister(SC16IS750_REG_IOSTATE);
236 if ( temp_iostate & (0x01 << pin_number)== 0 ) {
237 return 0;
238 }
239 return 1;
240}
241
242uint8_t WifiData::GPIOGetPortState(void)
243{
244
245 return ReadRegister(SC16IS750_REG_IOSTATE);
246
247}
248
249void WifiData::GPIOSetPortMode(uint8_t port_io)
250{
251 WriteRegister(SC16IS750_REG_IODIR, port_io);
252 return;
253}
254
255void WifiData::GPIOSetPortState(uint8_t port_state)
256{
257 WriteRegister(SC16IS750_REG_IOSTATE, port_state);
258 return;
259}
260
261void WifiData::SetPinInterrupt(uint8_t io_int_ena)
262{
263 WriteRegister(SC16IS750_REG_IOINTENA, io_int_ena);
264 return;
265}
266
267void WifiData::ResetDevice(void)
268{
269 uint8_t reg;
270
271 reg = ReadRegister(SC16IS750_REG_IOCONTROL);
272 reg |= 0x08;
273 WriteRegister(SC16IS750_REG_IOCONTROL, reg);
274
275 return;
276}
277
278void WifiData::ModemPin(uint8_t gpio) //gpio == 0, gpio[7:4] are modem pins, gpio == 1 gpio[7:4] are gpios
279{
280 uint8_t temp_iocontrol;
281
282 temp_iocontrol = ReadRegister(SC16IS750_REG_IOCONTROL);
283 if ( gpio == 0 ) {
284 temp_iocontrol |= 0x02;
285 } else {
286 temp_iocontrol &= 0xFD;
287 }
288 WriteRegister(SC16IS750_REG_IOCONTROL, temp_iocontrol);
289
290 return;
291}
292
293void WifiData::GPIOLatch(uint8_t latch)
294{
295 uint8_t temp_iocontrol;
296
297 temp_iocontrol = ReadRegister(SC16IS750_REG_IOCONTROL);
298 if ( latch == 0 ) {
299 temp_iocontrol &= 0xFE;
300 } else {
301 temp_iocontrol |= 0x01;
302 }
303 WriteRegister(SC16IS750_REG_IOCONTROL, temp_iocontrol);
304
305 return;
306}
307
308void WifiData::InterruptControl(uint8_t int_ena)
309{
310 WriteRegister(SC16IS750_REG_IER, int_ena);
311}
312
313uint8_t WifiData::InterruptPendingTest(void)
314{
315 return (ReadRegister(SC16IS750_REG_IIR) & 0x01);
316}
317
318void WifiData::__isr(void)
319{
320 uint8_t irq_src;
321
322 irq_src = ReadRegister(SC16IS750_REG_IIR);
323 irq_src = (irq_src >> 1);
324 irq_src &= 0x3F;
325
326 switch (irq_src) {
327 case 0x06: //Receiver Line Status Error
328 break;
329 case 0x0c: //Receiver time-out interrupt
330 break;
331 case 0x04: //RHR interrupt
332 break;
333 case 0x02: //THR interrupt
334 break;
335 case 0x00: //modem interrupt;
336 break;
337 case 0x30: //input pin change of state
338 break;
339 case 0x10: //XOFF
340 break;
341 case 0x20: //CTS,RTS
342 break;
343 default:
344 break;
345 }
346 return;
347}
348
349void WifiData::FIFOEnable(uint8_t fifo_enable)
350{
351 uint8_t temp_fcr;
352
353 temp_fcr = ReadRegister(SC16IS750_REG_FCR);
354
355 if (fifo_enable == 0){
356 temp_fcr &= 0xFE;
357 } else {
358 temp_fcr |= 0x01;
359 }
360 WriteRegister(SC16IS750_REG_FCR,temp_fcr);
361
362 return;
363}
364
365void WifiData::FIFOReset(uint8_t rx_fifo)
366{
367 uint8_t temp_fcr;
368
369 temp_fcr = ReadRegister(SC16IS750_REG_FCR);
370
371 if (rx_fifo == 0){
372 temp_fcr |= 0x04;
373 } else {
374 temp_fcr |= 0x02;
375 }
376 WriteRegister(SC16IS750_REG_FCR,temp_fcr);
377
378 return;
379
380}
381
382void WifiData::FIFOSetTriggerLevel(uint8_t rx_fifo, uint8_t length)
383{
384 uint8_t temp_reg;
385
386 temp_reg = ReadRegister(SC16IS750_REG_MCR);
387 temp_reg |= 0x04;
388 WriteRegister(SC16IS750_REG_MCR,temp_reg); //SET MCR[2] to '1' to use TLR register or trigger level control in FCR register
389
390 temp_reg = ReadRegister(SC16IS750_REG_EFR);
391 WriteRegister(SC16IS750_REG_EFR, temp_reg|0x10); //set ERF[4] to '1' to use the enhanced features
392 if (rx_fifo == 0) {
393 WriteRegister(SC16IS750_REG_TLR, length<<4); //Tx FIFO trigger level setting
394 } else {
395 WriteRegister(SC16IS750_REG_TLR, length); //Rx FIFO Trigger level setting
396 }
397 WriteRegister(SC16IS750_REG_EFR, temp_reg); //restore EFR register
398
399 return;
400}
401
402uint8_t WifiData::FIFOAvailableData(void)
403{
404 return ReadRegister(SC16IS750_REG_RXLVL);
405
406}
407
408uint8_t WifiData::FIFOAvailableSpace(void)
409{
410 return ReadRegister(SC16IS750_REG_TXLVL);
411
412}
413
414void WifiData::WriteByte(uint8_t val)
415{
416 uint8_t tmp_lsr;
417 do {
418 tmp_lsr = ReadRegister(SC16IS750_REG_LSR);
419 } while ((tmp_lsr&0x20) ==0);
420
421 WriteRegister(SC16IS750_REG_THR,val);
422
423}
424
425int WifiData::ReadByte(void)
426{
427 volatile uint8_t val;
428 if (FIFOAvailableData() == 0) {
429
430 return -1;
431
432 } else {
433
434 val = ReadRegister(SC16IS750_REG_RHR);
435 return val;
436 }
437
438}
439
440void WifiData::EnableTransmit(uint8_t tx_enable)
441{
442 uint8_t temp_efcr;
443 temp_efcr = ReadRegister(SC16IS750_REG_EFCR);
444 if ( tx_enable == 0) {
445 temp_efcr |= 0x04;
446 } else {
447 temp_efcr &= 0xFB;
448 }
449 WriteRegister(SC16IS750_REG_EFCR,temp_efcr);
450
451 return;
452}
453
454uint8_t WifiData::ping()
455{
456 WriteRegister(SC16IS750_REG_SPR,0x55);
457 if (ReadRegister(SC16IS750_REG_SPR) !=0x55) {
458 return 0;
459 }
460
461 WriteRegister(SC16IS750_REG_SPR,0xAA);
462 if (ReadRegister(SC16IS750_REG_SPR) !=0xAA) {
463 return 0;
464 }
465
466 return 1;
467
468}
469
470void WifiData::flush()
471{
472 uint8_t tmp_lsr;
473
474 do {
475 tmp_lsr = ReadRegister(SC16IS750_REG_LSR);
476 } while ((tmp_lsr&0x20) ==0);
477
478
479}
480
481int WifiData::peek()
482{
483 if ( peek_flag == 0 ) {
484 peek_buf =ReadByte();
485 if ( peek_buf >= 0 ) {
486 peek_flag = 1;
487 }
488 }
489
490 return peek_buf;
491
492}
493
494#endif
Note: See TracBrowser for help on using the repository browser.