тема такая помогите переделать этот скетч

Karens4
Offline
Зарегистрирован: 23.05.2015
#define BA {B01110000,B10001000,B10001000,B11111000,B10001000,B10001000}
#define BB {B11110000,B10001000,B10001000,B11110000,B10001000,B11111000}
#define BC {B11111000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define BD {B11110000,B10001000,B10001000,B10001000,B10001000,B11110000}
#define BE {B11111000,B10000000,B10000000,B11110000,B10000000,B11111000}
#define BF {B11111000,B10000000,B10000000,B11110000,B10000000,B10000000}
#define BG {B01110000,B10001000,B10000000,B10011000,B10001000,B01110000}
#define BH {B10001000,B10001000,B11111000,B10001000,B10001000,B10001000}
#define BI {B11111000,B00100000,B00100000,B00100000,B00100000,B11111000}
#define BJ {B00111000,B00010000,B00010000,B00010000,B10010000,B01100000}
#define BM {B10001000,B11011000,B10101000,B10101000,B10001000,B10001000}
#define BN {B10001000,B11001000,B10101000,B10101000,B10011000,B10001000}
#define BL {B10000000,B10000000,B10000000,B10000000,B10000000,B11111000}
#define BO {B01110000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define BP {B11110000,B10001000,B10001000,B11110000,B10000000,B10000000}
#define BQ {B01110000,B10001000,B10101000,B10011000,B01111000,B00001000}
#define BR {B11110000,B10001000,B10001000,B11110000,B10001000,B10001000}
#define BS {B01110000,B10001000,B01100000,B00010000,B10001000,B01110000}
#define BK {B10001000,B10010000,B11100000,B11100000,B10010000,B10001000}
#define BT {B11111000,B00100000,B00100000,B00100000,B00100000,B00100000}
#define BU {B10001000,B10001000,B10001000,B10001000,B10001000,B01110000}
#define BV {B10001000,B10001000,B10001000,B10001000,B01010000,B00100000}
#define BW {B10001000,B10001000,B10101000,B10101000,B10101000,B01010000}
#define BX {B10001000,B01010000,B00100000,B00100000,B01010000,B10001000}
#define BY {B10001000,B01010000,B00100000,B00100000,B00100000,B00100000}
#define BZ {B11111000,B00001000,B00110000,B01100000,B10000000,B11111000}
#define LA{B00000000,B01110000,B00001000,B01111000,B10001000,B01111000}
#define LB{B10000000,B10000000,B10110000,B11001000,B10001000,B11110000}
#define LC{B00000000,B01110000,B10000000,B10000000,B10001000,B01110000}
#define LD{B00001000,B00001000,B01111000,B10001000,B10001000,B01111000}
#define LE{B00000000,B01110000,B10001000,B11111000,B10000000,B01110000}
#define LF{B00110000,B01001000,B01000000,B11100000,B01000000,B01000000}
#define LG{B00000000,B01111000,B10001000,B01111000,B00001000,B01110000}
#define LH{B10000000,B10000000,B10110000,B11001000,B10001000,B10001000}
#define LI{B00100000,B00000000,B01100000,B00100000,B00100000,B01111000}
#define LJ{B00010000,B00000000,B00111000,B00010000,B10010000,B01100000}
#define LK{B10000000,B10010000,B10100000,B11000000,B10100000,B10010000}
#define LL{B01100000,B00100000,B00100000,B00100000,B00100000,B01111000}
#define LM{B00000000,B00000000,B11010000,B10101000,B10101000,B10001000}
#define LN{B00000000,B00000000,B10110000,B11001000,B10001000,B10001000}
#define LO{B00000000,B01110000,B10001000,B10001000,B10001000,B01110000}
#define LP{B00000000,B11110000,B10001000,B11110000,B10000000,B10000000}
#define LQ{B00000000,B01101000,B10011000,B01111000,B00001000,B00001000}
#define LR{B00000000,B00000000,B10110000,B11001000,B10000000,B10000000}
#define LS{B00000000,B01110000,B10000000,B01110000,B00001000,B11110000}
#define LT{B01000000,B01000000,B11100000,B01000000,B01001000,B00110000}
#define LU{B00000000,B00000000,B10001000,B10001000,B10011000,B01101000}
#define LV{B00000000,B00000000,B10001000,B10001000,B01010000,B00100000}
#define LW{B00000000,B00000000,B10001000,B10101000,B10101000,B01010000}
#define LX{B00000000,B10001000,B01010000,B00100000,B01010000,B10001000}
#define LY{B00000000,B10001000,B10001000,B01111000,B00001000,B01110000}
#define LZ{B00000000,B11111000,B00010000,B00100000,B01000000,B11111000}
#define SPACE{B00000000,B00000000,B00000000,B00000000,B00000000,B00000000}
#define NUM0{B01110000,B10011000,B10101000,B10101000,B11001000,B01110000}
#define NUM1{B00100000,B01100000,B10100000,B00100000,B00100000,B01110000}
#define NUM2{B01110000,B10001000,B00001000,B01110000,B10000000,B11111000}
#define NUM3{B11110000,B00001000,B00001000,B01111000,B00001000,B11110000}
#define NUM4{B10001000,B10001000,B10001000,B11111000,B00001000,B00001000}
#define NUM5{B11111000,B10000000,B11110000,B00001000,B10001000,B01110000}
#define NUM6{B11111000,B10000000,B11111000,B10001000,B10001000,B11111000}
#define NUM7{B11111000,B00001000,B00001000,B01111000,B00001000,B00001000}
#define NUM8{B11111000,B10001000,B11111000,B10001000,B10001000,B11111000}
#define NUM9{B11111000,B10001000,B11111000,B00001000,B00001000,B11111000}
#define DEVIDE{B00001000,B00010000,B00100000,B00100000,B01000000,B10000000}
#define TWODOTS{B01100000,B01100000,B00000000,B00000000,B01100000,B01100000}
#define DOT{B00000000,B00000000,B00000000,B00000000,B01100000,B01100000}
#define COMA{B00000000,B00000000,B00000000,B00110000,B00110000,B01100000}
#define LINE{B00000000,B00000000,B11111000,B11111000,B00000000,B00000000}
#define QUASTION{B01110000,B10001000,B00010000,B00100000,B00000000,B00100000}
#define MARK{B00100000,B01110000,B01110000,B00100000,B00000000,B00100000}

int latchPin = 10;
int clockPin = 13;
int dataPin = 11;
int clock = 9;
int Reset = 8;
int latchPinPORTB = latchPin - 8;
int clockPinPORTB = clockPin - 8;
int dataPinPORTB = dataPin - 8;
int i = 0;
int incomingByte[44];
long scrolling_word[6];
int array_turn=0;
byte patterns[100][6];
byte dummy_array[70][6] ={BA,BB,BC,BD,BE,BF,BG,BH,BI,BJ,BK,BL,BM,BN,BO,BP,BQ,BR,BS,BT,BU,BV,BW,BX,BY,BZ,SPACE,NUM0,NUM1,NUM2,NUM3,NUM4,NUM5,NUM6,NUM7,NUM8,NUM9,DEVIDE,TWODOTS,DOT,COMA,LINE,QUASTION,MARK,LA,LB,LC,LD,LE,LF,LG,LH,LI,LJ,LK,LL,LM,LN,LO,LP,LQ,LR,LS,LT,LU,LV,LW,LX,LY,LZ};
void setup(){
  Serial.begin(9600);
  pinMode(dataPin,OUTPUT);
  pinMode(clockPin,OUTPUT);
  pinMode(latchPin,OUTPUT);
  pinMode(clock,OUTPUT);
  pinMode(Reset,OUTPUT);
  digitalWrite(Reset,HIGH);
  digitalWrite(Reset,LOW);
  setupSPI();
}

void display_word(int loops,byte word_print[][6],int num_patterns,int delay_langth){// this function displays your symbols
  i = 0;// resets the counter fot the 4017
  for(int g=0;g<6;g++)//resets the the long int where your word goes
    scrolling_word[g] = 0;
  for(int x=0;x<num_patterns;x++){//main loop, goes over your symbols
   // you will need to find a better way to make the symbols scroll my way is limited for 24 columns

   for(int r=0;r<6;r++)//puts the buildes the first symbol
      scrolling_word[r] |= word_print[x][r]; 
    for (int z=0;z<6;z++){//the sctolling action
        for(int p=0;p<6;p++)
          scrolling_word[p] = scrolling_word[p] << 1;
// end of the scrolling funcion
      for(int t=0;t<delay_langth;t++){// delay function, it just loops over the same display
        for(int y=0;y<6;y++){// scaning the display
          if(i == 6){// counting up to 6 with the 4017
            digitalWrite(Reset,HIGH);
            digitalWrite(Reset,LOW);
            i = 0;
          }
          latchOff();
          spi_transfer(make_word(0x01000000,y));// sending the data
          spi_transfer(make_word(0x00010000,y));
          spi_transfer(make_word(0x00000100,y));
          latchOn();
          delayMicroseconds(800);//waiting a bit
          latchOff();
          spi_transfer(0);// clearing the data
          spi_transfer(0);
          spi_transfer(0);
          latchOn();
          digitalWrite(clock,HIGH);//counting up with the 4017
          digitalWrite(clock,LOW);
          i++;
        }
      }
    }
  }
  finish_scroll(delay_langth);
}

void finish_scroll(int delay_scroll){// this function is the same as the funcion above, it just finishing scrolling
  for (int n=0;n<24;n++){
        for(int h=0;h<6;h++)
          scrolling_word[h] = scrolling_word[h] << 1;
      for(int w=0;w<delay_scroll;w++){
        for(int k=0;k<6;k++){
          if(i == 6){
            digitalWrite(Reset,HIGH);
            digitalWrite(Reset,LOW);
            i = 0;
          }
          latchOff();
          spi_transfer(make_word(0x01000000,k));
          spi_transfer(make_word(0x00010000,k));
          spi_transfer(make_word(0x00000100,k));
          latchOn();
          delayMicroseconds(800);
          latchOff();
          spi_transfer(0);
          spi_transfer(0);
          spi_transfer(0);
          latchOn();
          digitalWrite(clock,HIGH);
          digitalWrite(clock,LOW);
          i++;
        }
      }
    }
}

byte make_word (long posistion,byte turn){
  byte dummy_word = 0;
  for(int q=0;q<8;q++){
    if(scrolling_word[turn] & (posistion<<q))
      dummy_word |= 0x01<<q;
  }
  return dummy_word;
}   


  void loop() {

	// send data only when you receive data:
	if(Serial.available() > 0){
		delay(100);
		incomingByte[array_turn] = Serial.read();
                array_turn++;
	}
           else{
             if(array_turn != 0){ 
               for(int az=0;az<array_turn;az++){
                 if((incomingByte[az] > 64 && incomingByte[az] < 91) || (incomingByte[az] > 96 && incomingByte[az] < 123)){
                  if(incomingByte[az] > 64 && incomingByte[az] < 91){
                   for(int lal=0;lal<6;lal++)                 
                 patterns[az][lal] = dummy_array[incomingByte[az] - 65][lal];
               }
               else{
                 for(int lal=0;lal<6;lal++)                 
                 patterns[az][lal] = dummy_array[incomingByte[az] - 53][lal];
               }}
               else{
                 switch(incomingByte[az]){
                case 32://space
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[26][lol];
                 break;
                case 33://mark
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[43][lol];
                 break;
                case 45://line
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[41][lol];
                 break;                 
                 case 44://coma
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[40][lol];
                 break;
                 case 46://dot
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[39][lol];
                 break;
                 case 47://dvide
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[37][lol];
                 break;
                 case 48://0
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[27][lol];
                 break;
                 case 49://1
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[28][lol];
                 break;
                 case 50://2
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[29][lol];
                 break;
                 case 51://3
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[30][lol];
                 break;
                 case 52://4
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[31][lol];
                 break;
                 case 53://5
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[32][lol];
                 break;
                 case 54://6
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[33][lol];
                 break;
                 case 55://7
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[34][lol];
                 break;
                 case 56://8
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[35][lol];
                 break;
                 case 57://9
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[36][lol];
                 break;
                 case 58://tow dots
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[38][lol];
                 break;
                 case 63://quastion
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[42][lol];
                 break;
                 default:
                 for(int lol=0;lol<6;lol++)                 
                 patterns[az][lol] = dummy_array[26][lol];
                 break; 
                 }
               }               
             }
           }
          display_word(1,patterns,array_turn,15);
          array_turn =0; 
         } 
       }
  
  //display_word(1,patterns,43,15);// calls for the display_pattern function and says that int loop = 15(if you do more loop the pattern whould scrrol slower).

void latchOn(){
  bitSet(PORTB,latchPinPORTB);
}

void latchOff(){
  bitClear(PORTB,latchPinPORTB);
}


void setupSPI(){
  byte clr;
  SPCR |= ( (1<<SPE) | (1<<MSTR) ); // enable SPI as master
  //SPCR |= ( (1<<SPR1) | (1<<SPR0) ); // set prescaler bits
  SPCR &= ~( (1<<SPR1) | (1<<SPR0) ); // clear prescaler bits
  clr=SPSR; // clear SPI status reg
  clr=SPDR; // clear SPI data reg
  SPSR |= (1<<SPI2X); // set prescaler bits
  //SPSR &= ~(1<<SPI2X); // clear prescaler bits

  delay(10);
}
byte spi_transfer(byte data)
{
  SPDR = data;			  // Start the transmission
  while (!(SPSR & (1<<SPIF)))     // Wait the end of the transmission
  {
  };
  return SPDR;			  // return the received byte, we don't need that
}

 

ДЛЯ http://net2ftp.ru/node0/jawokemuce@olypmall.ru/%d0%a1%d1%85%d0%b5%d0%bc%d0%b0.zip прошу 

мой vk http://vk.com/krdzhonyn  для доп вопроса ну или ответе в каментари 

 

Karens4
Offline
Зарегистрирован: 23.05.2015

каму лень качать вот фото схема в pdf в Архиве

Karens4
Offline
Зарегистрирован: 23.05.2015

помогите дописать скетч 

#define clock 12 //Пин подключен к SH_CP входу 74HC595
#define data 11  //Пин подключен к DS входу 74HC595
#define latch 8  //Пин подключен к ST_CP входу 74HC595

 
void setup() {
  pinMode(clock, OUTPUT);
  pinMode(data, OUTPUT);
  pinMode(latch, OUTPUT);
  digitalWrite(latch, HIGH);
}
 
void loop() {
  digitalWrite(latch, LOW);
  shiftOut(data, clock, LSBFIRST, 0b10000000); //1 регистер  6 led высота
  shiftOut(data, clock, LSBFIRST, 0b01000000); //2 регистер  8 led шырена 
  digitalWrite(latch, HIGH);
}




//нужно сделать режимы чтобы выводить символы с лево на право или на оборот нужно дописать это скетч я долго копался как сделать но так и не нашел//

 

m_t
Offline
Зарегистрирован: 29.03.2012
Могу сделать.
пишите на почту 
m_t01@mail.ru
В сообщении  указывайте ссылку на тему.
 
Karens4
Offline
Зарегистрирован: 23.05.2015

=) я написал !

MacSim
Offline
Зарегистрирован: 28.11.2012

Интересная у Вас затея. Что нибудь получается?

Что Вы хотите получить в итоге? Как понимаю таких блоков будет не один?

Яркость диодов разная при включении в столбце 1 и 6 диодов, так?

maksimovaleksandr@inbox.ru

Karens4
Offline
Зарегистрирован: 23.05.2015

да так все работает но нет режимов а с тусклостю разберусь главное скетч

Vitalik1985St
Offline
Зарегистрирован: 31.01.2016

помогите со скетчем

Проект такой . АВТОМАТИЧЕСКИЙ НАМОТЧНЫЙ станок катушек!!

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

int relayPin = 7;//к этому пину подключено реле
int buttPin = 2;//кнопка
int gerkoPin = 3;//геркон
int i = 0;//счетчик
void setup() {
  pinMode(relayPin, OUTPUT);
  pinMode(gerkoPin, INPUT);
  digitalWrite(relayPin, 0);
  attachInterrupt(0, tap, RISING);//прерывания на кнопку
  Serial.begin(9600);
}
bool isOn = false;
void loop() {
  while(isOn)
  {
    if (digitalRead(gerkoPin) == 1)
    {
      i++;
      if (i == 10)
      {
       digitalWrite(relayPin, 0);//выключаем реле
       isOn = false;
     }
     while(digitalRead(gerkoPin) == 1) {}
    }
    Serial.println(i);
  }
  delay(50);
}
void tap()
{
  i = 0;
  digitalWrite(relayPin, 1);//включаем реле
  isOn = true;
  //attachInterrupt(1, gerkonOn, RISING);//вешаем прерывания на геркон Если геркон на замыкания то RISING если на размыкания то FALLING
}

с помощью шагового двигателя двигается головка с проводом

#include <Stepper.h>
#define STEPS 200   //Количество шагов
Stepper stepper(STEPS, 8, 9, 10, 11); // пины к которым подключен двигатель
void setup(){
stepper.setSpeed(130); //скорость вращения
}
void loop()
{
  stepper.step(10*STEPS);
  delay(1000);
  stepper.step(-10*STEPS);
  delay(1000);
}

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

Кто может со скетчем

ЗА РАННИЕ СПАСИБО

 

MacSim
Offline
Зарегистрирован: 28.11.2012

Vitalik1985St пишет:

помогите со скетчем

Вы в каждой чужой теме свой единственный вопрос вставлять будете?

maksimovaleksandr@inbox.ru