src/modules/utils/panel/panels/smoothiepanel/I2CBang.h

   1 /*
   2       This file is part of Smoothie (http://smoothieware.org/). The motion control part is heavily based on Grbl (https://github.com/simen/grbl).
   3       Smoothie is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
   4       Smoothie is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
   5       You should have received a copy of the GNU General Public License along with Smoothie. If not, see <http://www.gnu.org/licenses/>.
   6 */
   7 #ifndef I2CBANG_H
   8 #define I2CBANG_H
   9 #include "mbed.h" // mbed.h lib
  10
  11 void i2cbang_init(I2C i2c){
  12     const int addr = 0x40;
  13     char cmd[2];
  14     cmd[0] = 0x1B;
  15     cmd[1] = 0x3F;
  16     i2c.write(addr, cmd, 2);
  17     cmd[0] = 0x0B;
  18     cmd[1] = 0xC0;
  19     i2c.write(addr, cmd, 2);
  20     wait_ms(1);
  21 }
  22
  23 void i2cbang_start(I2C i2c){
  24     const int addr = 0x40;
  25     char cmd[2];
  26     cmd[0] = 0x0B;
  27     cmd[1] = 0xBF;
  28     i2c.write(addr, cmd, 2);
  29     wait_ms(1);
  30     cmd[1] = 0x3F;
  31     i2c.write(addr, cmd, 2);
  32     wait_ms(1);
  33 }
  34
  35 void i2cbang_stop(I2C i2c){
  36     const int addr = 0x40;
  37     char cmd[2];
  38     cmd[0] = 0x0B;
  39     cmd[1] = 0xBF;
  40     i2c.write(addr, cmd, 2);
  41     wait_ms(1);
  42     cmd[1] = 0xFF;
  43     i2c.write(addr, cmd, 2);
  44     wait_ms(1);
  45 }
  46
  47 void i2cbang_writebit(I2C i2c, bool bit){
  48     const int addr = 0x40;
  49     char cmd[2];
  50     cmd[0] = 0x0B;
  51     if(bit){
  52         cmd[1] = 0x7F;
  53     }else{
  54         cmd[1] = 0x3F;
  55     }
  56     i2c.write(addr, cmd, 2);
  57     wait_ms(1);
  58
  59     if(bit){
  60         cmd[1] = 0xFF;
  61     }else{
  62         cmd[1] = 0xBF;
  63     }
  64     i2c.write(addr, cmd, 2);
  65     wait_ms(1);
  66
  67     if(bit){
  68         cmd[1] = 0x7F;
  69     }else{
  70         cmd[1] = 0x3F;
  71     }
  72     i2c.write(addr, cmd, 2);
  73     wait_ms(1);
  74
  75     if(bit){
  76         cmd[1] = 0x3F;
  77         i2c.write(addr, cmd, 2);
  78     }
  79     wait_ms(1);
  80 }
  81
  82 char i2cbang_readbit(I2C i2c){
  83     const int addr = 0x40;
  84     char cmd[2];
  85     char res;
  86     cmd[0] = 0x0B;
  87     cmd[1] = 0x7F;
  88     i2c.write(addr, cmd, 2);
  89     wait_ms(1);
  90
  91     cmd[1] = 0xFF;
  92     i2c.write(addr, cmd, 2);
  93     wait_ms(1);
  94
  95     cmd[0] = 0x03;
  96     i2c.write(addr, cmd, 1, false);
  97     i2c.read(addr, cmd, 1);
  98     res = cmd[0];
  99     wait_ms(1);
 100
 101     cmd[0] = 0x0B;
 102     cmd[1] = 0x7F;
 103     i2c.write(addr, cmd, 2);
 104     wait_ms(1);
 105
 106 //    cmd[1] = 0x3F;
 107 //    i2c.write(addr, cmd, 2);
 108 //    wait_ms(1);
 109
 110     //res = (~res) & 0x40;
 111     return res;
 112 }
 113
 114 int i2cbang_write(I2C i2c, char c){
 115     for (int i=0;i<8;i++){
 116         i2cbang_writebit(i2c, (c&0x80) > 0);
 117         c<<=1;
 118     }
 119
 120     return i2cbang_readbit(i2c);
 121 /*
 122     const int addr = 0x40;
 123     char cmd[2];
 124     char d = 0x00;
 125     //data
 126     for (int i=7;i>=0;i--){
 127         i2c.write(0x3F | d);
 128         d = ((c>>i)&1)<<6;
 129         i2c.write(0x3F | d);
 130         i2c.write(0xBF | d);
 131     }
 132     //ack
 133     i2c.write(0x3F | d);
 134     i2c.write(0xBF);
 135     i2c.stop();
 136     cmd[0] = 0x1B;
 137     cmd[1] = 0x7F;
 138     i2c.write(addr, cmd, 2);
 139     cmd[0] = 0x03;
 140     i2c.write(addr, cmd, 1, false);
 141     i2c.start();
 142     i2c.write(addr | 0x01);
 143     cmd[1] = i2c.read(false);
 144 //    int res = (~cmd[1]) & 0x40;
 145     int res = cmd[1];
 146     i2c.stop();
 147     cmd[0] = 0x1B;
 148     cmd[1] = 0x3F;
 149     i2c.write(addr, cmd, 2);
 150     cmd[0] = 0x0B;
 151     cmd[1] = 0xBF;
 152     i2c.write(addr, cmd, 2, false);
 153     return res;
 154 */
 155 }
 156
 157 char i2cbang_read(I2C i2c, bool ack){
 158     char res = 0;
 159     for(int i=0;i<8;i++){
 160         res<<=1;
 161         res |= i2cbang_readbit(i2c);
 162     }
 163
 164     if(ack){
 165         i2cbang_writebit(i2c, 0);
 166     }else{
 167         i2cbang_writebit(i2c, 1);
 168     }
 169
 170     wait_ms(1);
 171
 172     return res;
 173 }
 174
 175 #endif // I2CBANG_H
 176