Главная » Форумы » Программирование

Помогите с сетью на rs485 плиз

4 ответа [Последнее сообщение]
Втр, 28/02/2017 - 01:11
swatsar
Offline
Зарегистрирован: 28.02.2017

Здравствуйте!Имеется 5 ардуин мега 2560 и 4 уно  соеденены в 2 сети через свистки и бук с софтом.При этом часть сети работает,та что на 1ой лини ,а 2ая не работает.Уже изломал себе весь мозГ!Вопрос можно ли их соеденить в 1 сеть?С Сишкой дружу, но с ардуиной дружба не задалась!(

1ая -  линия

1)Ардуина мега 2560

#include <Keypad.h>

#define buttonLamp 31
#define gerkon1 30
#define gerkon2 32
#define gerkon3 33

#define Dir 2
#define RelayWall 5
#define RelayRoom2 4 
#define RelayRoom3 6

#define Adress  1

#define SendTime 50

//char pass[5] = {0x01, 0x03, 0x07, 0x0A, 0x01}; //Кодовое слово

const byte ROWS = 4; // 8 строк
const byte COLS = 4; // 8 столбцов
byte rowPins[ROWS] = {29,28,27,26};
byte colPins[COLS] = {25,24,23,22};
char keys[ROWS][COLS] = {
  {2,3,4,13},
  {5,6,7,14},
  {8,9,10,15},
  {11,1,12,16}
};
Keypad key = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

char z[5];
char statusID = 0;
char flag = 0;
unsigned char mode = 0;
unsigned char buttonCount = 0;
uint8_t oldstate = 0;

uint8_t counterRS = 0;
unsigned long timesRS = 0;

unsigned long oldTime = 0;
unsigned long doorTime = 0;

unsigned char keyP;
unsigned char buttonState = 0;
unsigned char Passwd[5] = {2,6,13,1,12};

void Doors(void);

void setup() {
  Serial3.begin(1200);
  Serial.begin(9600);
  
  pinMode(buttonLamp, INPUT);
  pinMode(gerkon1, INPUT);
  pinMode(gerkon2, INPUT);
  pinMode(gerkon3, INPUT);
  
  pinMode(RelayWall, OUTPUT);
  digitalWrite(RelayWall, LOW);
  pinMode(RelayRoom2, OUTPUT);
  digitalWrite(RelayRoom2, LOW);
  pinMode(RelayRoom3, OUTPUT);
  digitalWrite(RelayRoom3, LOW);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  Serial.println("OK");
}
  
void loop(){
/*********************************************************
 * Read sending data
*********************************************************/
  if(flag!=0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial3.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    }else{
      Doors();
    }
    flag = 0;
  }

/*********************************************************
 * Packet detect
*********************************************************/
  
  if(timesRS != 0){
    if(millis() > timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
        if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }

/*********************************************************
 * Main cicle
*********************************************************/
  if(doorTime != 0){
    if(millis() >= doorTime)
    {
      doorTime = 0;
      bitClear(z[2],1);
      Doors();
    }
  }
  
  switch(mode)
  {
  case 0:
    //Set up start state
    buttonCount = 0;

    //Close all doors
    statusID = 1;
    mode = 1;
    break;
  case 1:
    //1 read lamp code
    //count = 6, timeout = 5 sec
    if(oldTime != 0)
    {
      if(millis() >= oldTime)
      {
        oldTime = 0;
        buttonCount = 0;
      }
    }
    if(!digitalRead(buttonLamp)) //Если выключатель лампы включен
    {
      delay(5);
      if(!digitalRead(buttonLamp) && buttonState == 1) //inverted signal
      {
        if(buttonState = 1)
        {
          buttonState = 0;
          oldTime = millis() + 5000;
          buttonCount++;
          if(buttonCount >= 6)
          {
            Serial.println("door1");
            bitSet(z[2],0);
            statusID = 2;
            buttonCount = 0;
            oldTime = 0;
            mode = 2;
            Doors();
          }
        }
      }
    }else{ //Если он выключен
      delay(5);
      if(digitalRead(buttonLamp) && buttonState == 0) buttonState = 1;
    }
    break;
  case 2:
    //3 read password
    if(oldTime != 0)
    {
      if(millis() >= oldTime)
      {
        oldTime = 0;
        buttonCount = 0;
      }
    }
    
    keyP = key.getKey();
    if(keyP == Passwd[buttonCount])
    {
      oldTime = millis() + 5000; //reset timer
      buttonCount++;
      if(buttonCount >= 5)
      {
        //four open door
        oldTime = 0;
        statusID = 3;
        bitSet(z[2],1);
        doorTime = millis() + 120000;//magnet timer
        Doors();
        mode = 3;
      }
    }else if((keyP != Passwd[buttonCount]) && keyP != 0) {
      oldTime = 0;//reset timer
      buttonCount = 0;
    }
    break;
  case 3:
    //опрос герконов
    if(!digitalRead(gerkon1) && !digitalRead(gerkon2) && !digitalRead(gerkon3))
    {
       statusID = 4;
       mode = 4;
    }
    break;
  case 4:
    break;
  case 5:
    statusID = 5;
  default:
    //mode = 0;
    break;
  }
}

void Doors(void){
  uint8_t temp1, temp2;
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables, open doors
            case 0:
              digitalWrite(RelayWall, HIGH);
              break;
            case 1:
              digitalWrite(RelayRoom2, HIGH);
              break;
            case 2:
              digitalWrite(RelayRoom3, HIGH);
              mode = 5;
              break;
            case 3:
              break;
            case 4:
              break;
            case 5:
              break;
            case 6:
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent3(){
  timesRS = millis() + 20;
  z[counterRS] = Serial3.read();
  counterRS++;
}

2)Ардуина мега 2560

#include <Keypad.h>
//0000

#define Dir 2
#define Relay 3

#define GreenLed  40
#define RedLed    41

#define Adress    2

#define MC1A 49
#define MC1B 48
#define MC1C 47
#define INH  50
#define MC2A 53
#define MC2B 52
#define MC2C 51

#define LedTime 250
#define SendTime 50

char pass[5] = {0x01, 0x02, 0x03, 0x04, 0x05}; //Кодовое слово
uint8_t oldstate = 0;
uint8_t mode = 0;
uint8_t i;
uint16_t cnt = 0;
unsigned long times, curtimes;
uint8_t counterRS = 0;
unsigned long timesRS = 0;
char j = 0, key;

const byte ROWS = 8; // 8 строк
const byte COLS = 8; // 8 столбцов

char z[5];
char statusID = 0;
char flag = 0;
uint8_t counter = 0;

char keys[ROWS][COLS] =
{
  {0x38,0x39,0x00,0x00,0x00,0x00,0x36,0x00},
  {0x3B,0x06,0x26,0x00,0x33,0x1E,0x32,0x37},
  {0x02,0x20,0x07,0x1F,0x00,0x08,0x27,0x00},
  {0x31,0x1C,0x0D,0x05,0x1B,0x1A,0x2F,0x30},
  {0x0E,0x09,0x12,0x10,0x04,0x0F,0x2D,0x2E},
  {0x24,0x13,0x01,0x11,0x00,0x0B,0x2B,0x2C},
  {0x34,0x19,0x1D,0x03,0x15,0x18,0x29,0x2A},
  {0x25,0x21,0x16,0x23,0x0A,0x35,0x3A,0x28}
};

uint8_t printStr[421] = {
    0x23,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
    0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0xB,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14, 0x22,
  };

byte rowPins[ROWS] = {22,23,24,25,26,27,28,29};
byte colPins[COLS] = {30,31,32,33,34,35,36,37};
Keypad keypad = Keypad(makeKeymap(keys), rowPins, colPins, ROWS, COLS);

void SwithState(void);

void setup() {
  Serial.begin(9600);
  Serial3.begin(1200);

  Serial.println("Start");
  
  pinMode(RedLed, OUTPUT);
  pinMode(GreenLed, OUTPUT);
  digitalWrite(RedLed, HIGH);
  digitalWrite(GreenLed, HIGH);

  pinMode(Relay, OUTPUT);
  digitalWrite(Relay, HIGH);
  
  pinMode(INH, OUTPUT);
  digitalWrite(INH, HIGH);
  
  //Red in table
  pinMode(MC1A, OUTPUT);
  pinMode(MC1B, OUTPUT);
  pinMode(MC1C, OUTPUT);
  //Blue in table
  pinMode(MC2A, OUTPUT);
  pinMode(MC2B, OUTPUT);
  pinMode(MC2C, OUTPUT);
    
  digitalWrite(MC1A, LOW);
  digitalWrite(MC1B, LOW);
  digitalWrite(MC1C, LOW);
  digitalWrite(MC2A, LOW);
  digitalWrite(MC2B, LOW);
  digitalWrite(MC2C, LOW);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  mode = 0;
  statusID = 0;
}

void SetChar(char symbol)
{
  switch(symbol)
  {
    case 0x01: //"А"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
    
    case 0x02: //"Б"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x03: //"В"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x04: //"Г"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x05: //"Д"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x06: //"Е"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x07: //"Ё"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x08: //"Ж"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x09: //"З"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x0A: //"И"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x0B: //"Й"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x0C: //"К"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x0D: //"Л"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x0E: //"М"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x0F: //"Н"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x10: //"О"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x11: //"П"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x12: //"Р"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x13: //"С"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x14: //"Т"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x15: //"У"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x16: //"Ф"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x17: //"Х"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x18: //"Ц"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x19: //"Ч"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x1A: //"Ш"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x1B: //"Щ"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x1C: //"Ь"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x1D: //"Ы"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x1E: //"Ъ"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x1F: //"Э"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x20: //"Ю"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x21: //"Я"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x22: //Enter
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;

    case 0x23: //Caps lock
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
          
    case 0x24: //"CODE"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x25: //left shift
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x26: //right shift
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x27: //"0"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x28: //"1"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x29: //"2"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x2A: //"3"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x2B: //"4"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x2C: //"5"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x2D: //"6"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x2E: //"7"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x2F: //"8"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x30: //"9"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x31: //"-"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x32: //"="
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x33: //"IND"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x34: //"+t"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x35: //"dec"
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x36: //верх первая слева
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, HIGH);
      digitalWrite(MC2C, HIGH);
      break;
      
    case 0x37: //верх вторая справа
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x38: //низ первая справа
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x39: //низ вторая справа
      digitalWrite(MC1A, HIGH);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
      
    case 0x3A: //"del"
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, HIGH);
      digitalWrite(MC1C, HIGH);
      digitalWrite(MC2A, LOW);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
    
    case 0x3B: //Пробел
      digitalWrite(MC1A, LOW);
      digitalWrite(MC1B, LOW);
      digitalWrite(MC1C, LOW);
      digitalWrite(MC2A, HIGH);
      digitalWrite(MC2B, LOW);
      digitalWrite(MC2C, LOW);
      break;
    
    default: break;
  }
}

void PrintChar(char symbol)
{
  if(symbol <= 0x3A)
  {
    SetChar(symbol);
    digitalWrite(INH, LOW);
    delay(100);
    digitalWrite(INH, HIGH);
  }
}

void loop()
{
  if(flag!=0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial3.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    }else{
      SwithState();
    }
    flag = 0;
  }

  if(timesRS != 0){
    if(millis() >= timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
         if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }
  
  switch(mode)
  {
    case 0: //Wait
      statusID = 1;
      Serial.println("State1");
      break;
    case 1: //Password
      Serial.println("State2");
      statusID = 2;
      if((millis() - times) <= 5000){
        key = keypad.getKey();
        if(key){
          if(key == pass[j]){
            times = millis();
            j++;
            //Мыргнуть зеленым светодиодом
            digitalWrite(GreenLed, LOW);
            delay(LedTime);
            digitalWrite(GreenLed, HIGH);
            if(j >= 5)
            {
              digitalWrite(GreenLed, LOW); //Зажигаем зеленый светодиод
              mode = 2;
              j = 0;
            }
          }else{
            j = 0;
            times = millis();
            digitalWrite(RedLed, LOW);
            delay(LedTime);
            digitalWrite(RedLed, HIGH);
          }
        }
      }else{
        times = millis();
        if(j != 0){
          digitalWrite(RedLed, LOW);
          delay(LedTime);
          digitalWrite(RedLed, HIGH);
          j = 0;
        }
      }
      break;
    case 2: //Wait
      Serial.println("State3");
      statusID = 3;
      break;
    case 3: //Printing
      Serial.println("State4");
      digitalWrite(Relay, LOW);
      delay(10000);
      for(cnt = 0; cnt < 421; cnt++)
      {
        PrintChar(printStr[cnt]);
        if (printStr[cnt] == 0x22) delay(1000);
      }
      delay(5000);
      digitalWrite(Relay, HIGH);
      z[0] = Adress;
      statusID = 5;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial3.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
      mode = 4;
      break;
    case 4:
      Serial.println("State4");
      statusID = 6;
      break;
    case 5:
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;
  
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              mode = 3;
              break;
            case 2:
              break;
            case 3:
              break;
            case 4:
              break;
            case 5:
              break;
            case 6:
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent3(){
  timesRS = millis() + 20;
  z[counterRS] = Serial3.read();
  counterRS++;
}

3)Ардуина мега 2560

//ports
#define Dir     2 //Управление 485

#define RMagBad 5 
//#define RMagCom 4 
#define RLamp   6
#define GBad    3
#define G4      8
#define G3      9
#define G2      10 
#define G1      11 

#define Adress  3
#define SendTime 50

uint8_t oldstate = 0;

void SwithState(void);

void setup() {
  Serial.begin(1200);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  pinMode(RMagBad, OUTPUT);
  digitalWrite(RMagBad, LOW);
//  pinMode(RMagCom, OUTPUT);
//  digitalWrite(RMagCom, HIGH);
  pinMode(RLamp, OUTPUT);
  digitalWrite(RLamp, HIGH);

  pinMode(GBad, INPUT);
  pinMode(G1, INPUT);
  pinMode(G2, INPUT);
  pinMode(G3, INPUT);
  pinMode(G4, INPUT);
}

uint8_t z[32];
uint8_t flag = 0;
uint8_t counterRS = 0;
uint8_t statusID = 0;
unsigned long timesRS = 0;
uint8_t mode = 0;

void loop() {
  if(flag!=0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    }else{
      SwithState();//пришла управляющая комманда
    }
    flag = 0;
  }
  
  if(timesRS != 0){
    if(millis() > timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
        if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }

  switch(mode)
  {
    case 0: //Ждем комманды на начало работы
      statusID = 1;
      break;
    case 1: //Ждем пароль 
      statusID = 2;
      if(!digitalRead(G1) && !digitalRead(G2) && !digitalRead(G3) && !digitalRead(G4)){
        mode = 2;
        digitalWrite(RLamp, LOW);//Открываем тумбу
      }
      
      break;
    case 2: //Ждем команду от print
      statusID = 3;
      break;
    case 3: //Открываем дверцу и ждем, когда заберут предмет
      statusID = 3;
      digitalWrite(RMagBad, HIGH);
      if(digitalRead(GBad)) mode = 4; //предмет забрали
      break;
    case 4:
      statusID = 4;
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;
  
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              digitalWrite(RMagBad, HIGH); //Открывыаем дверцу 
              mode = 3; //Ожидаем, когда заберут предмет
              break;
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent(){
  timesRS = millis() + 20;
  z[counterRS] = Serial.read();
  counterRS++;
}

 

 
2ая - линия
 
1)Ардуина мега 2560
#define Dir     2 //Управление 485

#define Cap1_1    22 //не бачит
#define Cap1_2    23
#define Cap2_1    24
#define Cap2_2    25
#define Cap3_1    26

#define CapR4_1   28
#define CapR4_2   29
#define CapR4_3   31 //Не бачит

#define MagR1_in  53 //Вход в первую комнату
#define MagR3toR4 52

#define MyAdress  4

#define SendTime 50

void SwithState(void);

uint8_t oldstate = 0;
uint8_t people = 0; //Количество игроков 0=2, 1>=3
uint8_t mode = 0;

void setup() {
  Serial3.begin(1200);
  Serial.begin(115200);
  
  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  //pinMode(Cap1_1, INPUT);
  pinMode(Cap1_2, INPUT);
  pinMode(Cap2_1, INPUT);
  pinMode(Cap2_2, INPUT);
  pinMode(Cap3_1, INPUT);
  
  pinMode(CapR4_1, INPUT);
  pinMode(CapR4_2, INPUT);
  //pinMode(CapR4_3, INPUT);

  //pinMode(MagR1_in, OUTPUT);
  //digitalWrite(MagR1_in, LOW);

  pinMode(MagR3toR4, OUTPUT);
  digitalWrite(MagR3toR4, LOW);

  mode = 3;
}

uint8_t z[32];
uint8_t flag = 0;
uint8_t wait = 1;
uint8_t counterRS = 0;
uint8_t statusID = 0;
uint8_t serv = 0;
uint8_t first = 0;
uint8_t temp = 0;
uint8_t Adress = MyAdress;
unsigned long timesRS = 0;
unsigned long sendTimer = 0;
unsigned long doorTimer = 0;

void WriteToPort(){
  digitalWrite(Dir, HIGH);
  Serial3.write(z, 5);
  delay(SendTime);
  digitalWrite(Dir, LOW);
  Serial.println("Write");
}

inline uint8_t ReadStatus(uint8_t a){
  if(sendTimer == 0){
    Adress = a;
    z[0] = a;
    z[1] = 0x00;
    z[2] = 0x08;//Запрос состояния 
    z[3] = z[0]+z[1]+z[2];
    z[4] = a;
    WriteToPort();//пишем в сеть
    sendTimer = millis()+1000;
  }else{
    if(millis() > sendTimer){
      Serial.println("S = 1");
      sendTimer = 0;
      first = 0;
      return 0;
    }else{
      Serial.println("S = 2");
      if(flag != 0){ //ждем ответа
       Serial.println("S = 3");
       flag = 0;
       first = 0;
       return z[2];
      }
    }
  }
}
    
inline uint8_t SendAndRead (uint8_t a, uint8_t b){
  if(first == 0){
    Serial.println("A");
    z[0] = a;
    z[1] = 0;
    z[2] = b;
    z[3] = z[0]+z[1]+z[2];
    z[4] = a;
    WriteToPort();
    first = 1;
    delay(50);
  }else{
    return ReadStatus(a);
  }
}

void loop() {
  if(flag != 0 && wait == 0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      WriteToPort();
    }else{
      SwithState();//пришла управляющая комманда
    }
    flag = 0;
  }
  
  if(timesRS != 0){
    if(millis() > timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
        if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;  
      }
      counterRS = 0;
    }
  }

  switch(mode){
    case 0: //Ждем комманды на начало работы
      break;
    case 1: //Отрабатываем третью комнату
      break;
    case 2: //Ожидаем таймер на открытие двери
      break;
    case 3:
      Serial.print("Ansver");
      Serial.println(ReadStatus(0x05),HEX);
      delay(500);
    break;
      //опрашиваем кругом 56789
      /*switch(serv){
        case 0:
          temp = SendAndRead(0x05,0x02);
          if(temp != 1 && temp != 0) serv = 1;
        break;
        case 1:
          temp = SendAndRead(0x06,0x02);
          if(temp != 1 && temp != 0) serv = 2;
        break;
        case 2:
          temp = SendAndRead(0x07,0x02);
          if(temp != 1 && temp != 0) serv = 3;
        break;
        case 3:
          temp = SendAndRead(0x08,0x02);
          if(temp != 1 && temp != 0) serv = 4;
        break;
        case 4:
          temp = SendAndRead(0x09,0x02);
          if(temp != 1 && temp != 0) serv = 5;
        break;
        case 5:
          if(ReadStatus(0x05)==3 && ReadStatus(0x06)==3 && ReadStatus(0x07)==3 && ReadStatus(0x08)==3 && ReadStatus(0x09)==3) mode = 4;
        break;
      }  
      break;*/
    case 4: //считываем емкостники с четвертой комнаты
      Serial.println("End");
      break;
    case 5:
    default:
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;
  
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              mode = 4;
              break;
            case 2:
              mode = 5;
              break;
            case 3:
              break;
            case 4:
              digitalWrite(MagR3toR4, LOW); //Закрываем дверь в 4 комнату
              break;
            case 5:
              digitalWrite(MagR3toR4, HIGH); //Открываем дверь в 4 комнату
              break;
            case 6:
              people = 1;
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent3(){
  timesRS = millis() + 20;
  z[counterRS] = Serial3.read();
  counterRS++;
}

 

 

Верх
Втр, 28/02/2017 - 01:41
#1
swatsar
Offline
Зарегистрирован: 28.02.2017

2)Ардуино мега2560

#include <SPI.h>
#include <MFRC522.h>

//ports
#define Dir  2
#define Mag4 4
#define Led  5

#define RST_PIN         9           // Configurable, see typical pin layout above
#define SS_PIN          10          // Configurable, see typical pin layout above

#define Adress 5

#define SendTime 50

//E0 73 B5 4F
uint8_t oldstate = 0;
uint8_t mode = 0;
uint8_t passwd[4] = {0xE0,0x73,0xB5,0x4F};

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance.
void SwithState(void);

void setup() {
  Serial.begin(1200);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  pinMode(Led, OUTPUT);
  digitalWrite(Led, LOW);

  pinMode(Mag4, OUTPUT);
  digitalWrite(Mag4, LOW);
  
  SPI.begin();                // Init SPI bus
  mfrc522.PCD_Init();         // Init MFRC522 card
}

uint8_t z[32];
uint8_t flag = 0;
uint8_t counterRS = 0;
uint8_t statusID = 0;
uint8_t ledState = LOW;
unsigned long timesRS = 0;
unsigned long timer = 0;

void loop() {
  if(flag!=0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    }else{
      SwithState();//пришла управляющая комманда
    }
    flag = 0;
  }
  
  if(timesRS != 0){
    if(millis() > timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
        if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }

  switch(mode)
  {
    case 0: //Ждем комманды на начало работы
      statusID = 1;
      break;
    case 1: //Ждем считыватель
      statusID = 2;
      if (! mfrc522.PICC_IsNewCardPresent()){
        mfrc522.uid.uidByte[0] = 0;
        mfrc522.uid.uidByte[1] = 0;
        mfrc522.uid.uidByte[2] = 0;
        mfrc522.uid.uidByte[3] = 0;
        return;
      }
      
      if(!mfrc522.PICC_ReadCardSerial()) return;
      
      if(mfrc522.uid.size == 4){
        if((mfrc522.uid.uidByte[0] == passwd[0]) && (mfrc522.uid.uidByte[1] == passwd[1]) && (mfrc522.uid.uidByte[2] == passwd[2]) && (mfrc522.uid.uidByte[3] == passwd[3])){
          mode = 2;
          timer = millis() + 500;
          ledState = HIGH;
          digitalWrite(Led, ledState);
        }
      }
      break;
    case 2: //Мыргаем и ждем команды на переключение
      statusID = 3;
      if(millis() >= timer){
        //Мыргаем светиком
        timer = millis() + 500;
        if (ledState == LOW) {
          ledState = HIGH;
        } else {
          ledState = LOW;
        }
        digitalWrite(Led, ledState);
      }
      break;
    case 3: //зажигаем светик, ждем команды на открытие двери
      statusID = 4;
      digitalWrite(Led, HIGH);
      break;
    case 4: // открываем дверь
      statusID = 5;
      digitalWrite(Mag4, HIGH);
      mode = 5;
      break;
    case 5:
      statusID = 5;
    default:
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;
  
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              mode = 3;
              break;
            case 2:
              mode = 4;
              break;
            case 3:
              break;
            case 4: //Открыть дверь
              digitalWrite(Mag4, HIGH);
              break;
            case 5: //Закрыть дверь
              digitalWrite(Mag4, LOW);
              break;
            case 6:
              mode = 5;
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent(){
  timesRS = millis() + 20;
  z[counterRS] = Serial.read();
  counterRS++;
}

3)Ардуино уно

#include <SPI.h>
#include <MFRC522.h>

//ports
#define Dir  2
#define Led  3

#define RST_PIN         9           // Configurable, see typical pin layout above
#define SS_PIN          10          // Configurable, see typical pin layout above

#define Adress 6

#define SendTime 50

uint8_t oldstate = 0;
uint8_t mode = 0;
uint8_t passwd[4] = {0x66, 0x2A, 0x22, 0x49};

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance.
void SwithState(void);

void setup() {
  Serial.begin(1200);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  pinMode(Led, OUTPUT);
  digitalWrite(Led, LOW);
  
  SPI.begin();                // Init SPI bus
  mfrc522.PCD_Init();         // Init MFRC522 card
}

uint8_t z[32];
uint8_t flag = 0;
uint8_t counterRS = 0;
uint8_t statusID = 0;
uint8_t ledState = LOW;
unsigned long timesRS = 0;
unsigned long timer = 0;

void loop() {
  if(flag!=0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    }else{
      SwithState();//пришла управляющая комманда
    }
    flag = 0;
  }
  
  if(timesRS != 0){
    if(millis() > timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
        if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }

  switch(mode)
  {
    case 0: //Ждем комманды на начало работы
      statusID = 1;
      break;
    case 1: //Ждем считыватель
      statusID = 2;
      if (! mfrc522.PICC_IsNewCardPresent()){
        mfrc522.uid.uidByte[0] = 0;
        mfrc522.uid.uidByte[1] = 0;
        mfrc522.uid.uidByte[2] = 0;
        mfrc522.uid.uidByte[3] = 0;
        return;
      }
      
      if(!mfrc522.PICC_ReadCardSerial()) return;
      
      if(mfrc522.uid.size == 4){
        if((mfrc522.uid.uidByte[0] == passwd[0]) && (mfrc522.uid.uidByte[1] == passwd[1]) && (mfrc522.uid.uidByte[2] == passwd[2]) && (mfrc522.uid.uidByte[3] == passwd[3])){
          mode = 2;
          timer = millis() + 500;
          ledState = HIGH;
          digitalWrite(Led, ledState);
        }
      }
      break;
    case 2: //Мыргаем и ждем команды на переключение
      statusID = 3;
      if(millis() >= timer){
        //Мыргаем светиком
        timer = millis() + 500;
        if (ledState == LOW) {
          ledState = HIGH;
        } else {
          ledState = LOW;
        }
        digitalWrite(Led, ledState);
      }
      break;
    case 3: //зажигаем светик
      statusID = 4;
      digitalWrite(Led, HIGH);
      mode = 4;
      break;
    case 4:
      statusID = 5;
      break;
    default:
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;
  
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              mode = 3;
              break;
            case 2:
              break;
            case 3:
              break;
            case 4:
              break;
            case 5:
              break;
            case 6:
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent(){
  timesRS = millis() + 20;
  z[counterRS] = Serial.read();
  counterRS++;
}

4)Ардуино уно

//ports
#define Dir  2
#define Led  3
#define Gerkon 4

#define Adress 7

#define SendTime 50

uint8_t oldstate = 0;
uint8_t mode = 0;

void SwithState(void);

void setup() {
  Serial.begin(1200);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  pinMode(Led, OUTPUT);
  digitalWrite(Led, LOW);

  pinMode(Gerkon, INPUT);
}

uint8_t z[32];
uint8_t flag = 0;
uint8_t counterRS = 0;
uint8_t statusID = 0;
uint8_t ledState = LOW;
unsigned long timesRS = 0;
unsigned long timer = 0;

void loop() {
  if(flag!=0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    }else{
      SwithState();//пришла управляющая комманда
    }
    flag = 0;
  }
  
  if(timesRS != 0){
    if(millis() > timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
        if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }

  switch(mode)
  {
    case 0: //Ждем комманды на начало работы
      statusID = 1;
      break;
    case 1: //Ждем геркон
      statusID = 2;
      if (!digitalRead(Gerkon)){
          mode = 2;
          timer = millis() + 500;
          ledState = HIGH;
          digitalWrite(Led, ledState);
      }
      break;
    case 2: //Мыргаем и ждем команды на переключение
      statusID = 3;
      if(millis() >= timer){
        //Мыргаем светиком
        timer = millis() + 500;
        if (ledState == LOW) {
          ledState = HIGH;
        } else {
          ledState = LOW;
        }
        digitalWrite(Led, ledState);
      }
      break;
    case 3: //зажигаем светик
      statusID = 4;
      digitalWrite(Led, HIGH);
      mode = 4;
      break;
    case 4:
      statusID = 5;
      break;
    default:
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;
  
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              mode = 3;
              break;
            case 2:
              break;
            case 3:
              break;
            case 4:
              break;
            case 5:
              break;
            case 6:
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent(){
  timesRS = millis() + 20;
  z[counterRS] = Serial.read();
  counterRS++;
}

5)Ардуино уно

#include <SPI.h>
#include <MFRC522.h>

//ports
#define Dir  2
#define Led  3

#define RST_PIN         9           // Configurable, see typical pin layout above
#define SS_PIN          10          // Configurable, see typical pin layout above

#define Adress 8

#define SendTime 50

//87 7A 93 85
uint8_t oldstate = 0;
uint8_t mode = 0;
uint8_t passwd[4] = {0x87,0x7A,0x93,0x85};

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance.
void SwithState(void);

void setup() {
  Serial.begin(1200);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  pinMode(Led, OUTPUT);
  digitalWrite(Led, LOW);
  
  SPI.begin();                // Init SPI bus
  mfrc522.PCD_Init();         // Init MFRC522 card
}

uint8_t z[32];
uint8_t flag = 0;
uint8_t counterRS = 0;
uint8_t statusID = 0;
uint8_t ledState = LOW;
unsigned long timesRS = 0;
unsigned long timer = 0;

void loop() {
  if(flag!=0){
    if(bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0]+z[1]+z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    }else{
      SwithState();//пришла управляющая комманда
    }
    flag = 0;
  }
  
  if(timesRS != 0){
    if(millis() > timesRS)
    {
      timesRS = 0;
      if(counterRS == 5)
      {
        if((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0]+z[1]+z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }

  switch(mode)
  {
    case 0: //Ждем комманды на начало работы
      statusID = 1;
      break;
    case 1: //Ждем считыватель
      statusID = 2;
      if (! mfrc522.PICC_IsNewCardPresent()){
        mfrc522.uid.uidByte[0] = 0;
        mfrc522.uid.uidByte[1] = 0;
        mfrc522.uid.uidByte[2] = 0;
        mfrc522.uid.uidByte[3] = 0;
        return;
      }
      
      if(!mfrc522.PICC_ReadCardSerial()) return;
      
      if(mfrc522.uid.size == 4){
        if((mfrc522.uid.uidByte[0] == passwd[0]) && (mfrc522.uid.uidByte[1] == passwd[1]) && (mfrc522.uid.uidByte[2] == passwd[2]) && (mfrc522.uid.uidByte[3] == passwd[3])){
          mode = 2;
          timer = millis() + 500;
          ledState = HIGH;
          digitalWrite(Led, ledState);
        }
      }
      break;
    case 2: //Мыргаем и ждем команды на переключение
      statusID = 3;
      if(millis() >= timer){
        //Мыргаем светиком
        timer = millis() + 500;
        if (ledState == LOW) {
          ledState = HIGH;
        } else {
          ledState = LOW;
        }
        digitalWrite(Led, ledState);
      }
      break;
    case 3: //зажигаем светик
      statusID = 4;
      digitalWrite(Led, HIGH);
      mode = 4;
      break;
    case 4:
      statusID = 5;
      break;
    default:
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;
  
  if(oldstate ^ z[2]){
    for(uint8_t j=0; j<8; j++)
    {
      temp1 = bitRead(z[2],j);
      temp2 = bitRead(oldstate,j);
      if(temp1 != temp2)
      {
        if(temp1 > temp2)
        {
          switch(j){ //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              mode = 3;
              break;
            case 2:
              break;
            case 3:
              break;
            case 4:
              break;
            case 5:
              break;
            case 6:
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      } 
    }
    oldstate = z[2];
  }
}

void serialEvent(){
  timesRS = millis() + 20;
  z[counterRS] = Serial.read();
  counterRS++;
}

6)Ардуино уно

#include <SPI.h>
#include <MFRC522.h>

//ports
#define Dir  2
#define Cap  8
#define Led  3
#define Rel  5

#define RST_PIN         9           // Configurable, see typical pin layout above
#define SS_PIN          10          // Configurable, see typical pin layout above

#define Adress 9

#define SendTime 50

//60 F1 B3 4F
uint8_t oldstate = 0;
uint8_t mode = 0;
uint8_t passwd[4] = {0x60, 0xF1, 0xB3, 0x4F};

MFRC522 mfrc522(SS_PIN, RST_PIN);   // Create MFRC522 instance.
void SwithState(void);

void setup() {
  Serial.begin(1200);

  pinMode(Dir, OUTPUT);
  digitalWrite(Dir, LOW);

  pinMode(Rel, OUTPUT);
  digitalWrite(Rel, LOW);

  pinMode(Led, OUTPUT);
  digitalWrite(Led, LOW);

  pinMode(Cap, INPUT);
  //analogReference(INTERNAL);

  SPI.begin();                // Init SPI bus
  mfrc522.PCD_Init();         // Init MFRC522 card
}

uint8_t z[32];
uint8_t flag = 0;
uint8_t counterRS = 0;
uint8_t statusID = 0;
uint8_t ledState = LOW;
unsigned long timesRS = 0;
unsigned long timer = 0;

void loop() {
  /*if(digitalRead(Cap)) Serial.println("Cap on");
    else Serial.println("Cap off");
    delay(500);*/
  if (flag != 0) {
    if (bitRead(z[2], 3)) //Пришел запрос состояния
    {
      z[0] = Adress;
      z[1] = statusID;
      z[2] = oldstate;
      z[3] = z[0] + z[1] + z[2];
      z[4] = Adress;
      digitalWrite(Dir, HIGH);
      Serial.write(z, 5);
      delay(SendTime);
      digitalWrite(Dir, LOW);
    } else {
      SwithState();//пришла управляющая комманда
    }
    flag = 0;
  }

  if (timesRS != 0) {
    if (millis() > timesRS)
    {
      timesRS = 0;
      if (counterRS == 5)
      {
        if ((z[0] == z[4]) && (z[0] == Adress) && z[3] == (z[0] + z[1] + z[2])) flag = 1;
      }
      counterRS = 0;
    }
  }

  switch (mode)
  {
    case 0: //Ждем комманды на начало работы
      statusID = 1;
      break;
    case 1: //Ждем считыватель
      statusID = 2;
      if (! mfrc522.PICC_IsNewCardPresent()) {
        mfrc522.uid.uidByte[0] = 0;
        mfrc522.uid.uidByte[1] = 0;
        mfrc522.uid.uidByte[2] = 0;
        mfrc522.uid.uidByte[3] = 0;
        return;
      }

      if (!mfrc522.PICC_ReadCardSerial()) return;

      if (mfrc522.uid.size == 4) {
        if ((mfrc522.uid.uidByte[0] == passwd[0]) && (mfrc522.uid.uidByte[1] == passwd[1]) && (mfrc522.uid.uidByte[2] == passwd[2]) && (mfrc522.uid.uidByte[3] == passwd[3])) {
          mode = 2;
          timer = millis() + 500;
          ledState = HIGH;
          digitalWrite(Led, ledState);
        }
      }
      break;
    case 2: //Мыргаем и ждем команды на переключение
      statusID = 3;
      if (millis() >= timer) {
        //Мыргаем светиком
        timer = millis() + 500;
        if (ledState == LOW) {
          ledState = HIGH;
        } else {
          ledState = LOW;
        }
        digitalWrite(Led, ledState);
      }
      break;
    case 3: //Ждем емкостник и зажигаем светик
      statusID = 4;
      if (millis() >= timer) {
        //Мыргаем светиком
        timer = millis() + 500;
        if (ledState == LOW) {
          ledState = HIGH;
        } else {
          ledState = LOW;
        }
        digitalWrite(Led, ledState);
      }
      if (digitalRead(Cap)) {
        digitalWrite(Led, HIGH);
        mode = 4;
        timer = millis() + 5000;
      }
      break;
    case 4: //Ждем время и включаем стробоскоп
      statusID = 5;
      if (millis() >= timer) {
        digitalWrite(Rel, LOW);
        timer = millis() + 5000;
        mode = 5;
      }
      break;
    case 5:
      statusID = 6;
      if (millis() >= timer) {
        digitalWrite(Rel, HIGH);
        timer = millis() + 5000;
        mode = 6;
      }
    case 6:
      statusID = 7;
    default:
      break;
  }
}

void SwithState(void)
{
  uint8_t temp1, temp2;

  if (oldstate ^ z[2]) {
    for (uint8_t j = 0; j < 8; j++)
    {
      temp1 = bitRead(z[2], j);
      temp2 = bitRead(oldstate, j);
      if (temp1 != temp2)
      {
        if (temp1 > temp2)
        {
          switch (j) { //Enables
            case 0:
              mode = 1;
              break;
            case 1:
              mode = 3;
              break;
            case 2:
              break;
            case 3:
              break;
            case 4:
              break;
            case 5:
              break;
            case 6:
              break;
            case 7:
              __asm("jmp 0x0000");
              break;
          }
        }
      }
    }
    oldstate = z[2];
  }
}

void serialEvent() {
  timesRS = millis() + 20;
  z[counterRS] = Serial.read();
  counterRS++;
}

 

Верх
Втр, 28/02/2017 - 11:27
#2
Baks
Baks аватар
Offline
Зарегистрирован: 11.01.2016

я не совсем понял в чем прикол сдвумя сетями, я бы изначально делал одну сеть.

попробуйте поиском по форуму воспользоваться так к примеру http://arduino.ru/forum/obshchii/vopros-po-easyvr#comment-263357

и да есть уже готовые биюлиотеки для работы с модбус. по форуму почитайте

 

Верх
Втр, 28/02/2017 - 12:28
#3
swatsar
Offline
Зарегистрирован: 28.02.2017

Изначально была проблема в протяжке была сети, собранная по тапологии звезда в последствии было по мере возможности на 2нормальных сети и 2 свистка и обьеденино в сеть через софт на C#.Если есть возможность помогите плиз, а то уже парюсь 1,5 месяца, естественно не за бесплатно софт могу сбросить под 1 порт и под 2 портa.

Верх
Втр, 28/02/2017 - 14:50
#4
p.masyukov
p.masyukov аватар
Offline
Зарегистрирован: 14.11.2015

опиши что это вообще. а то кода чтото много, а глаза ломать и думать что к чему....

или позвони на скайп p.masyukov - обьясни на словах..

Верх