Чтение из массива данных STM32F103

forfrends
Offline
Зарегистрирован: 24.02.2015

Всем привет! Столкнулся с проблемой. Есть массив (буфер) вида:

byte bitmap[1248] = { 0x00,0x00,0x00,0x00,0x00.... );
 
побайтовое чтение произвожу командой: 
 
Value = bitRead(bitmap[l*16+15-i], j) != 0 ? HIGH : LOW;
 
Если использовать Ардуино то все нормально работает, но у Ардуино очень мало ОЗУ, Буфер максимум может занимать 2 килобайта, а у Ардуино (Uno, и ей подобных) всего 2 Кб. ОЗУ.
Я решил использовать плату STM32F103C8T6. Поддержку STM сделал, залил загрузчик, код компилируется и прошивается. Но команда Value = bitRead(bitmap... возвращает только нули и только 200 чтений (или около того). То есть делает 200 раз Value = bitRead() после чего программа намертво зависает.
Почему не происходит чтение из массива и почему зависание происходит?
andriano
andriano аватар
Онлайн
Зарегистрирован: 20.06.2015

Вероятно, напутали в циклах.

b707
Онлайн
Зарегистрирован: 26.05.2017

forfrends -

во-первых, то что вы  привели - это не "побайтовое", а "побитное" чтение массива.

Во-вторых, неплохо было бы привести более подробный код, что именно и как вы читаете.

И последнее - если это битмап и выводите вы ее на экран - скорее всего работать побитно не только нет нужды. но еще и вредно. Большинство экранов имеют байтовую адресацию и заполнять их точками - это как копать котлован детским совочком.

dimax
dimax аватар
Offline
Зарегистрирован: 25.12.2013

forfrends, ну начнём с того,  макросы для AVR  совсем не обязаны работать на stm32. Если аддон от Роджера Кларка, то там есть макрос с аналогичной функцией bb_peri_get_bit(адрес, бит)

forfrends
Offline
Зарегистрирован: 24.02.2015

Пытаюсь разобраться в работе термопринтера от кассового аппарата. Отдельно созданная тема: http://arduino.ru/forum/apparatnye-voprosy/termoprinter-iz-starogo-terminala-kassovogo-apparata

Решил переехать из ПроМини на STM. Код не менял, только пины переназначил. Скетч (смотреть функцию processPrintBitmap() ):

//Максимальное число одновременно печатаемых точек - 32 (програмно делит строку на 12 столбиков и печатает по очереди)

byte bitmap[1248] = {
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x0F,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x01,0xFF,0xE0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x0F,0xFF,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x3F,0xED,0xF0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0xFF,0x81,0xF0,0x00,0x00,0x0F,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0xFF,0xE0,0xF0,0x00,0x00,0x1F,0xC0,0x00,0x00,0x00,0x07,0xF8,0x00,0x00,0x00,
0x03,0xFF,0xFF,0xFD,0xF0,0x00,0x1F,0x80,0x00,0x00,0x00,0x1C,0x07,0x00,0x00,0x00,
0x07,0xFF,0xFF,0xFD,0xF8,0xFF,0xFF,0x00,0x00,0x00,0x00,0x78,0x7E,0xC0,0x00,0x00,
0x0F,0xFF,0xAF,0x7F,0xFF,0xEC,0x1F,0x00,0x00,0x00,0x00,0xDD,0xFF,0xC0,0x00,0x00,
0x1F,0xFF,0xC0,0xFF,0xFE,0x4C,0x0F,0xC0,0x00,0x00,0x01,0xF3,0xFF,0xA0,0x00,0x00,
0x1F,0xFF,0xB8,0x7C,0xF8,0x00,0x00,0x20,0x00,0x00,0x01,0xFF,0xFF,0xF0,0x00,0x00,
0x1F,0xFF,0xEE,0xFC,0xF8,0x00,0x00,0x18,0x00,0x00,0x01,0xFF,0xFF,0xF0,0x00,0x00,
0x3F,0xFF,0xFF,0xFD,0x80,0x00,0x00,0x0C,0x00,0x00,0x01,0x77,0xFF,0xD0,0x00,0x00,
0x3F,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x06,0x00,0x00,0x01,0x7B,0xFF,0xF0,0x00,0x00,
0x3F,0xFF,0xFF,0xBA,0x00,0x00,0x00,0x02,0x00,0x00,0x01,0x7F,0xFF,0xB0,0x00,0x00,
0x7F,0xFF,0xFF,0x84,0x00,0x00,0x00,0x03,0x00,0x00,0x01,0x79,0xFF,0x30,0x00,0x00,
0x7F,0xFF,0xFF,0x8C,0x00,0x00,0x07,0xE1,0x00,0x00,0x00,0x8E,0x7C,0x78,0x00,0x00,
0x7F,0xFF,0xFF,0x08,0x07,0xE0,0x1C,0x01,0x80,0x00,0x00,0xC6,0x00,0xE8,0x00,0x00,
0x7F,0xFF,0xFF,0x10,0x3E,0xF8,0x10,0x00,0x80,0x00,0x00,0x70,0x07,0xF8,0x00,0x00,
0x7F,0xFF,0xFF,0x30,0x00,0x0C,0x20,0x00,0xC0,0x00,0x00,0xFF,0xFF,0x98,0x00,0x00,
0x7F,0xFF,0xFF,0x20,0x00,0x06,0x00,0x00,0xE0,0x00,0x01,0x9F,0xFF,0x30,0x00,0x00,
0x7F,0xFF,0xFF,0xA0,0x00,0x02,0x00,0x00,0xE0,0x00,0x01,0xDF,0xFE,0x70,0x00,0x00,
0x7F,0xFF,0xFF,0xE0,0x00,0x01,0x01,0xE0,0x60,0x00,0x03,0xDB,0x01,0xF0,0x00,0x00,
0x3F,0xFF,0xFF,0xE0,0x1F,0xE1,0x03,0xF0,0x60,0x00,0x07,0xFD,0xFF,0xF0,0x00,0x00,
0x3F,0xFF,0xFF,0xE0,0x3F,0xF0,0x07,0xF0,0x70,0x00,0x0F,0xEE,0x7F,0xA0,0x00,0x00,
0x3F,0xFF,0xFF,0xE0,0x7F,0xF8,0x1C,0xF0,0xF8,0x00,0x0F,0xFF,0x00,0x60,0x00,0x00,
0x3F,0xFF,0xFF,0xE0,0x7E,0xF8,0xEF,0xE0,0xFF,0xC0,0x1F,0xFF,0xC0,0xE0,0x00,0x00,
0x1F,0xFF,0xFF,0xE0,0x7C,0xF8,0x7F,0xE0,0xFF,0xFF,0x3F,0xFF,0xFF,0xC0,0x00,0x00,
0x1F,0xFF,0xFF,0xE0,0x3F,0x58,0x1F,0xC0,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,
0x1F,0xFF,0xFF,0xE0,0x3F,0xF0,0x00,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,
0x0F,0xFF,0xFF,0xE0,0x1F,0xE0,0x01,0x81,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,
0x07,0xFF,0xFF,0xF0,0x0F,0xC0,0x01,0x01,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,0x00,0x00,
0x07,0xFF,0xFF,0xF0,0x03,0x00,0x01,0x03,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,0x00,
0x03,0xFF,0xFF,0xF8,0x00,0x00,0x0C,0x03,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,0x00,
0x01,0xFF,0xFF,0xFC,0x00,0x80,0x1E,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,0x00,0x00,
0x00,0xFF,0xFF,0xFC,0x00,0x2E,0x7A,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x00,0x00,
0x00,0x7F,0xFF,0xFE,0x00,0x17,0xFC,0x0F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,0x00,
0x00,0x1F,0xFF,0xFF,0x00,0x13,0xFC,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xE0,0x00,
0x00,0x0F,0xFF,0xFF,0x80,0x0C,0x69,0x3F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xF8,0x00,
0x00,0x07,0xFF,0xFF,0xC0,0x03,0xE1,0x7F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,0x00,
0x00,0x03,0xFF,0xFF,0xF0,0x00,0x02,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,0x00,
0x00,0x01,0xFF,0xFF,0xFC,0x08,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x80,
0x00,0x00,0xFF,0xFF,0xFF,0x83,0x0F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xC0,
0x00,0x00,0x7F,0xFF,0xFF,0xF8,0xFF,0xFF,0xFF,0xF7,0xFF,0xFF,0xFF,0xFF,0xFF,0xF0,
0x00,0x00,0x1F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0x17,0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,
0x00,0x00,0x0F,0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,0x17,0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,
0x00,0x00,0x07,0xFF,0xFF,0xFF,0xFF,0xFF,0xF9,0x97,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
0x00,0x00,0x03,0xFF,0xFF,0xFF,0xFF,0xF8,0x6C,0x77,0xFF,0xFF,0xFF,0xFF,0xFF,0x3E,
0x00,0x00,0x01,0xFF,0xFF,0xFF,0xF0,0x00,0x58,0x33,0xFF,0xFF,0xFF,0xFF,0xFF,0x7F,
0x00,0x00,0x00,0xFF,0xFF,0xFF,0x80,0x00,0x53,0xAB,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
0x00,0x00,0x00,0x7F,0xFF,0xF8,0x00,0x00,0x1E,0xE3,0xFF,0xFF,0xFF,0xFF,0xFF,0xFC,
0x00,0x00,0x00,0x3F,0xFF,0xC0,0x00,0x00,0x10,0x41,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
0x00,0x00,0x00,0x1F,0xFF,0x00,0x00,0x00,0x10,0x61,0xFF,0xFF,0xFF,0xFF,0xFF,0xFE,
0x00,0x00,0x00,0x0F,0xFC,0x00,0x00,0x00,0x13,0xE0,0xFF,0xFF,0xFF,0xFF,0xDF,0xFC,
0x00,0x00,0x00,0x07,0xF8,0x00,0x00,0x00,0x1C,0x60,0xFF,0xFF,0xFF,0xFF,0x1F,0xFC,
0x00,0x00,0x00,0x03,0xF0,0x00,0x00,0x00,0x14,0x60,0x7F,0xFF,0xFF,0xFE,0x0F,0x80,
0x00,0x00,0x00,0x01,0xE0,0x00,0x00,0x00,0x1B,0xE0,0x7F,0xFF,0xFB,0xF8,0x00,0x00,
0x00,0x00,0x00,0x00,0xE0,0x00,0x00,0x00,0x0C,0xB0,0x3F,0xFF,0xFB,0xE0,0x00,0x00,
0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x08,0x30,0x1F,0xFF,0xF9,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x60,0x00,0x00,0x00,0x0D,0xF0,0x1F,0xFF,0xF1,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x20,0x00,0x00,0x00,0x06,0x18,0x0F,0xFF,0xE3,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x06,0x78,0x03,0xFF,0xC1,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x06,0x8C,0x03,0xFF,0x83,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x03,0x8C,0x00,0xFE,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x01,0x1E,0x00,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x01,0xC2,0x00,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x0C,0x00,0x00,0x00,0x00,0xCF,0x00,0x00,0x01,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x06,0x04,0x00,0x00,0x00,0x71,0x00,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x06,0x08,0x00,0x00,0x00,0x61,0x00,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x03,0x10,0x00,0x00,0x00,0x38,0x80,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x03,0x20,0x00,0x00,0x00,0x10,0x80,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0xE0,0x00,0x00,0x00,0x1B,0xC0,0x00,0x03,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0xE0,0x00,0x00,0x00,0x08,0x40,0x00,0x02,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x0C,0x40,0x00,0x02,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0xC0,0x00,0x00,0x00,0x07,0x60,0x00,0x06,0x00,0x00,0x00
};

//#include <avr/pgmspace.h>
//#undef PROGMEM
//#define PROGMEM __attribute__(( section(".progmem.data") ))
#include "font.h"

String string;
int x=1000; //задержка между импульсами шагмотора
int ll = 0;
/*
  For Arduino:
#define LATCH  9
#define STROBE 10
#define CLOCK 11
#define DATA_IN 13

#define in1 2
#define in3 3
#define in2 4
#define in4 5

#define POWER_ENABLE 7
*/
#define LATCH   PA6
#define STROBE  PA7
#define CLOCK   PB0
#define DATA_IN   PB1

#define in1 PA1
#define in3 PA2
#define in2 PA3
#define in4 PA4

#define POWER_ENABLE  PA5

int dl = 1;

static const byte height=26; //высота области печати
static const byte width=384; //ширина области печати

void setup()
{
    // Set mode for TPH
    pinMode(LATCH, OUTPUT);
    pinMode(STROBE, OUTPUT);
    pinMode(CLOCK, OUTPUT);
    pinMode(DATA_IN, OUTPUT);
    
    // Настройки для шагового двигателя
    pinMode(POWER_ENABLE, OUTPUT); //en
    pinMode(in1, OUTPUT);
    pinMode(in2, OUTPUT);
    pinMode(in3, OUTPUT);
    pinMode(in4, OUTPUT);
   
    // Initial: We need to switch strobe off as soon it is possible to prevent TPH overheating.
    digitalWrite(LATCH, HIGH); // Inverted
    digitalWrite(STROBE, LOW); // Inverted
    digitalWrite(CLOCK, LOW);
    digitalWrite(DATA_IN, LOW);
    
    digitalWrite(POWER_ENABLE, HIGH);
    
    Serial.begin(9600);
    //while (!Serial) {
        ; // wait for serial port to connect. Needed for Leonardo only
    //}
    Serial.println("Error: ");
}

void loop()
{
   while (Serial.available() <= 0)
   {
   }
   
   // Read sync
   string = Serial.readStringUntil(' ');
   if (string != "C"){
      Serial.println("Error: Waiting for command");
      Serial.flush();
      return;
   }
   string = Serial.readStringUntil(' ');
//**************************************************************   
   if (string == "STP") //Управление смещением ленты C STP 128 1 
   {
     string = Serial.readStringUntil(' ');
     int iterations = string.toInt();
     string = Serial.readStringUntil(' ');
     int direction = string.toInt();
     processStepper(iterations,direction);
   }
//**************************************************************
   else if (string == "BTM")//вывод картинки из массива сработает только один раз, первый
   {
     processPrintBitmap(); 
     //промотать ленту вперед на 40 точек (вообще надо на 128, но тогда не видно всей картинки будет) 
     processStepper(40,1);
   }
//**************************************************************
   else if (string == "LINE")
   {
    Serial.println("Error: ");
     string = Serial.readStringUntil(' ');
     int X1 = string.toInt();
     string = Serial.readStringUntil(' ');
     int Y1 = string.toInt();
     string = Serial.readStringUntil(' ');
     int X2 = string.toInt();
     string = Serial.readStringUntil(' ');
     int Y2 = string.toInt();
     string = Serial.readStringUntil(' ');
     int color = string.toInt();
     Serial.println(X1);
     Serial.println(Y1);
     Serial.println(X2);
     Serial.println(Y2);
     Serial.println(color);
     //очистить массив битмап
     Rect(1,1,width,height,1,0);
     //Rect(1,1,28,28,1,1);
     //нарисовать линию в этом массиве
     Line(X1,Y1,X2,Y2,color);
     //промотать ленту назад на height + 28 точек (вообще надо на 128, но тогда не видно всей картинки будет)
     processStepper(40,1);
     //вывести напечать массив
     Serial.println("Bitmap");
     processPrintBitmap(); 
     //промотать ленту вперед на 40 точек (вообще надо на 128, но тогда не видно всей картинки будет) 
     processStepper(40,1);
   }
//**************************************************************
   else if (string == "RECT")
   {
     string = Serial.readStringUntil(' ');
     int X1 = string.toInt();
     string = Serial.readStringUntil(' ');
     int Y1 = string.toInt();
     string = Serial.readStringUntil(' ');
     int X2 = string.toInt();
     string = Serial.readStringUntil(' ');
     int Y2 = string.toInt();
     string = Serial.readStringUntil(' ');
     int fill = string.toInt();
     string = Serial.readStringUntil(' ');
     int color = string.toInt();
     //очистить массив битмап
     Rect(1,1,width,height,1,0);
     //нарисовать прямоугольник в этом массиве
     Rect(X1,Y1,X2,Y2,fill,color);
     //промотать ленту назад на height + 40 точек (вообще надо на 128, но тогда не видно всей картинки будет)
     processStepper(height+40,0);
     //вывести напечать массив
     processPrintBitmap(); 
     //промотать ленту вперед на 40 точек (вообще надо на 128, но тогда не видно всей картинки будет) 
     processStepper(40,1);
   }

//**************************************************************
   else if (string == "CIRC")
   {
     string = Serial.readStringUntil(' ');
     int X = string.toInt();
     string = Serial.readStringUntil(' ');
     int Y = string.toInt();
     string = Serial.readStringUntil(' ');
     int R = string.toInt();
     string = Serial.readStringUntil(' ');
     int fill = string.toInt();
     string = Serial.readStringUntil(' ');
     int color = string.toInt();
     //очистить массив битмап
     Rect(1,1,width,height,1,0);
     //нарисовать круг в этом массиве
     Circle(X,Y,R,fill,color);
     //промотать ленту назад на height + 40 точек (вообще надо на 128, но тогда не видно всей картинки будет)
     processStepper(height+40,0);
     //вывести напечать массив
     processPrintBitmap(); 
     //промотать ленту вперед на 40 точек (вообще надо на 128, но тогда не видно всей картинки будет) 
     processStepper(40,1);
   }


//**************************************************************
   else if (string == "TXT")
   {
     string = Serial.readStringUntil(' ');
     int X = string.toInt();
     string = Serial.readStringUntil(' ');
     int Y = string.toInt();
     string = Serial.readStringUntil(' ');
     int color = string.toInt();
     string = Serial.readStringUntil('\n');
     int fill = string.toInt();
     
     //очистить массив битмап
     Rect(1,1,width,height,1,0);
     //нарисовать текст в этом массиве
     Text(X,Y, string, color);
     //промотать ленту назад на height + 40 точек (вообще надо на 128, но тогда не видно всей картинки будет)
     processStepper(height+40,0);
     //вывести напечать массив
     processPrintBitmap(); 
     //промотать ленту вперед на 40 точек (вообще надо на 128, но тогда не видно всей картинки будет) 
     processStepper(40,1);
   }

      
   Serial.flush();
}

void processStepper(int Y,int D) //Y - смещение по оси Y (1 - вперед, 0 - назад), D - направление смещения 
{  
   Serial.print("Move: ");
   if (D == 1)
   {
     //digitalWrite(TPH_PIN_DIR, HIGH);
     Serial.print("forward ");
   }
   else 
   {
      //digitalWrite(TPH_PIN_DIR, LOW);
      Serial.print("backward ");
   }
   
   Serial.print(Y);
   Serial.print("px ");
   int iterations = Y; //опытным путем установил, что между пикселами 5 импульсов на шаговый двигатель
   
   digitalWrite(POWER_ENABLE, LOW);
   for (int i = 0; i < iterations; ++i)
   {
     for (int s = 0; s < 5; ++s)
     {
        _steper();
        delay(1);
     }
   }
   digitalWrite(POWER_ENABLE, HIGH);
   Serial.println("DONE!");  
}

void processPrintBitmap()
{
    int fireTime = 1;
    digitalWrite(POWER_ENABLE, LOW); // подаем питание на мотор и головку
    for (int l=0; l<78; ++l)
    {
        for (int p = 0; p<12; ++p) //прогоняем 12 раза каждую строку, тк одновременно можно нагревать только 32 точки - да, это не оптимально...
        {
            for (int i = 0; i < 48; ++i)
            {
                for (int j = 0; j < 8; ++j)
                {
                    uint8_t pinValue = LOW;
                    if (i/4==p) //каждый цикл печатаем по 1 четвертой (32 точки)
                    {                 
                        pinValue = bitRead(bitmap[l*16+15-i], j) != 0 ? HIGH : LOW;
                        //Serial.print(pinValue);
                    }
                    digitalWrite(DATA_IN, pinValue);
                    digitalWrite(CLOCK, HIGH);
                    digitalWrite(CLOCK, LOW);
                }
            }
            digitalWrite(LATCH, LOW);
            digitalWrite(LATCH, HIGH);
            digitalWrite(STROBE, LOW);
            digitalWrite(STROBE, HIGH);
            delay(5);
            digitalWrite(DATA_IN, LOW);
        }

        digitalWrite(STROBE, HIGH);
        delayMicroseconds(2000);
        digitalWrite(STROBE, LOW);
        
        _steper(); // 1 шаг мотора
        delay(1);
        _steper(); // 1 шаг мотора
    }
    digitalWrite(POWER_ENABLE, HIGH); 
    Serial.println("DONE!");
}

//*******************************
//       *** НАРИСОВАТЬ ТОЧКУ ***
//*******************************
void Point(int X,int Y, byte color){
    int l=0; int el_num=0; int bit_num=0;
    //проверяем, не выходят ли координаты за пределы экрана и прерываем, если выходят
    if(X>width||X<1)return;
    if(Y>height||Y<1)return;
    //вычисляем нужный элемент массива  
    if (Y>1)l=(Y-1)*width; //т.к. массив одномерный, то считаем количество элементов, которые надо пройти, если строк больше 1
    l=l+X;//добавляем положение по Х
    //вычисляем нужный бит
    if (l%8>0){ //если при делении суммы точек на 8 (8 бит в одном элементе массива), остаток не равен нулю
      bit_num=l%8-1; //то вычисляется остаток = номер бита в элементе массива, а тк нумерация бит с 0, то отнимаем 1
      el_num=l/8;    //и вычисляем сколько целых элементов
    }
    else{
      bit_num=7; //если остаток равен 0, то значит точка в последнем бите - номер 7
      el_num=l/8-1;//и вычисляем сколько целых элементов, а тк нумерация бит с 0, то отнимаем 1 
    }
    //изменяем заданный бит в необходимом элементе
    if (color==1) bitSet(bitmap[el_num],7-bit_num);
    else bitClear(bitmap[el_num],7-bit_num);
  }
  
//*******************************
//                 *** ПРЯМАЯ ***
//*******************************
void Line(int X1,int Y1, int X2,int Y2, byte color){
    Serial.println("Line1");
  byte i;
  if(X1==X2) //если линия вертикальная
    {
      Serial.println("Line2");
      if(Y2<Y1){i=Y1;Y1=Y2;Y2=i;} //если конечная точка меньше начальной, то меняем значения местами
      for(i=Y1;i<=Y2;i++)Point(X1,i,color);//X,Y,Color - 1/0
      Serial.println("Line3");
    }
  else if (Y1==Y2) //если линия горизонтальная
    {
      Serial.println("Line4");
      if(X2<X1){i=X1;X1=X2;X2=i;} //если конечная точка меньше начальной, то меняем значения местами
      for(i=X1;i<=X2;i++)Point(i,Y1,color);//X,Y,Color - 1/0
      Serial.println("Line5");
    }
  else //Если линия - наклонная, то используем алгоритм Брезенхема, для построения наклонных прямых
    {
      Serial.println("Line6");
      Brezenhem(X1, Y1, X2, Y2,color);
    }
    Serial.println("Line7");
}

//*******************************
//    *** АЛГОРИТМ БРЕЗЕНХЕМА ***
//    *** ДЛЯ НАКЛОННЫХ ПРЯМЫХ **
//    ** prog-cpp.ru/brezenham **
//*******************************
void Brezenhem(byte X1, byte Y1, byte X2, byte Y2, byte color)
{
  int A, B, sign;
  A = Y2 - Y1;
  B = X1 - X2;
  if (abs(A) > abs(B)) sign = 1;
  else sign = -1;
  int signa, signb;
  if (A < 0) signa = -1;
  else signa = 1;
  if (B < 0) signb = -1;
  else signb = 1;
  int f = 0;
  
  Point(X1,Y1,color);//X,Y,Color - 1/0
  int x = X1, y = Y1;
  if (sign == -1) 
  {
    do {
      f += A*signa;
      if (abs(f) > abs(f-abs(B)))
      {
        f -= B*signb;
        y += signa;
      }
      x -= signb;
      Point(x,y,color);//X,Y,Color - 1/0
    } while (x != X2 || y != Y2);
  }
  else
  {
    do {
      f += B*signb;
      if (abs(f) > abs(f-abs(A)))
      {
        f -= A*signa;
        x -= signb;
      }
      y += signa;
      Point(x,y,color);//X,Y,Color - 1/0
    } while (x != X2 || y != Y2);
  }
}

//*******************************
//          *** ПРЯМОУГОЛЬНИК ***
//*******************************
void Rect(int X1,int Y1, int X2,int Y2, byte fill, byte color){
  Line(X1, Y1, X2, Y1, color);//X1,Y1,X2,Y2,Color - 1/0
  Line(X1, Y2, X2, Y2, color);//X1,Y1,X2,Y2,Color - 1/0
  if(fill==1)//заливаем
    {
      for(int i=Y1+1;i<Y2;i++)
        {
          Line(X1, i, X2, i, color);//X1,Y1,X2,Y2,Color - 1/0
        }
    }  
  else
    {
      Line(X2, Y1, X2, Y2, color);//X1,Y1,X2,Y2,Color - 1/0
      Line(X1, Y2, X1, Y1, color);//X1,Y1,X2,Y2,Color - 1/0
    } 
}

//*******************************
//    *** АЛГОРИТМ БРЕЗЕНХЕМА ***
//    ** из книги Г.Шилдта «Си **
//    ** для профессиональных  **
//    ** программистов» модиф. **
//*******************************
/* Вспомогательная функция, печатает точки, определяющие окружность */
void plot_circle(byte x, byte y, byte x_center, byte  y_center, byte fill, byte color)
{
    Point(x_center+x,y_center+y,color);//X,Y,Color - 1/0
    Point(x_center+x,y_center-y,color);//X,Y,Color - 1/0
    Point(x_center-x,y_center+y,color);//X,Y,Color - 1/0
    Point(x_center-x,y_center-y,color);//X,Y,Color - 1/0
    if(fill==1)//заливаем
    {
      Line(x_center+x, y_center-y, x_center-x, y_center-y, color);//X1,Y1,X2,Y2,Color - 1/0
      Line(x_center+x, y_center+y, x_center-x, y_center+y, color);//X1,Y1,X2,Y2,Color - 1/0
    }  
}

/* Вычерчивание окружности с использованием алгоритма Брезенхэма */
void Circle(byte x_center, byte y_center, byte radius, byte fill,byte color_code)
{
    int x,y,delta;
    x = 0;
    y = radius;
    delta=3-2*radius;
    while(x<y) {
        plot_circle(x,y,x_center,y_center,fill,color_code);
        plot_circle(y,x,x_center,y_center,fill,color_code);
        if (delta<0)
            delta+=4*x+6;
        else {
            delta+=4*(x-y)+10;
            y--;
        }
        x++;
    }
    if(x==y) plot_circle(x,y,x_center,y_center,fill,color_code);
}

//*******************************
//          *** ВЫВОД ТЕКСТА  ***
//*******************************
void Text(int X,int Y, String S, byte color){

    
  byte i;
  byte n;
  byte m;
  int len=0;
  word c;
  word cyr = 0;
  byte symbolsCount = 0;
  uint8_t line;
  
  len=S.length()-1;//длина переменной т.к. считываем до энтера, то последний символ отсекаем
  //TextLen=len;
  
  for(n=0;n<len;n++)//перебираем все буквы
    {
      c=((word)S[n]);//берем по 1 букве    
      if (c > 0xFF00) {
        if (cyr == 0) {
          
          cyr = c << 8;
          continue;
        } else {
          cyr += c & 255;
          c = cyr;
          cyr = 0;
        }
      }

      symbolsCount++;
  /*****************************/
  //Для русских символов смещаем номер элемента массива
  if (c >= 0xC000) 
    {
      if (c == 0xD081) { c = 0xA8;}
      else if (c == 0xD191) { c = 0xB8;}
      else if (c >= 0xD090 && c <= 0xD0BF) c = c - 0xD000 + 0x30;
      else if (c >= 0xD180 && c <= 0xD18F) c = c - 0xD100 + 0x70;
      
    }
  /*****************************/
  //Отрисовываем букву по точкам
  for(i=0;i<6;i++)
        {
          line=pgm_read_byte(&(font_rus[c*5+i]));
          
          for(m=0;m<8;m++)//строим вертикалоьную линию из точек, символ состоит из 5 таких линий
            {
              if (i<5)
                {
                  //Рисуем букву. В базе белым на черном
                  if(color==1)Point(i+(symbolsCount-1)*6+X,m+Y,bitRead(line, m));//X,Y,Color - 1/0
                  //Рисуем букву. В базе черным на белом*/
                  else Point(i+(symbolsCount-1)*6+X,m+Y,~bitRead(line, m));//X,Y,Color - 1/0
                }
              //Рисуем полоску после буквы инверстным цветом
              //else Point(i+(symbolsCount-1)*6+X,m+Y,~color);//X,Y,Color - 1/0
            }    
        }
    }
}

void _steper()
{
    if(dl == 1){    
        digitalWrite( in1, HIGH );
        digitalWrite( in2, LOW );
        digitalWrite( in3, LOW );
        digitalWrite( in4, HIGH );
        dl = 3;
    }else if(dl == 3){ 
        digitalWrite( in1, HIGH );
        digitalWrite( in2, HIGH );
        digitalWrite( in3, LOW );
        digitalWrite( in4, LOW );
        dl = 5;
    }else if(dl == 5){
        digitalWrite( in1, LOW );
        digitalWrite( in2, HIGH );
        digitalWrite( in3, HIGH );
        digitalWrite( in4, LOW );
         dl = 7;
    }else if(dl == 7){
        
        digitalWrite( in1, LOW );
        digitalWrite( in2, LOW );
        digitalWrite( in3, HIGH );
        digitalWrite( in4, HIGH );
        dl = 1;
    }
}

void _steper2()
{
    if(dl == 1){    
        digitalWrite( in1, HIGH );
        digitalWrite( in2, LOW );
        digitalWrite( in3, LOW );
        digitalWrite( in4, HIGH );
        dl = 2;
    }else if(dl == 2){ 
        digitalWrite( in1, HIGH );
        digitalWrite( in2, HIGH );
        digitalWrite( in3, LOW );
        digitalWrite( in4, HIGH );
        dl = 3;
    }else if(dl == 3){ 
        digitalWrite( in1, HIGH );
        digitalWrite( in2, HIGH );
        digitalWrite( in3, LOW );
        digitalWrite( in4, LOW );
        dl = 4;
    }else if(dl == 4){
        digitalWrite( in1, HIGH );
        digitalWrite( in2, HIGH );
        digitalWrite( in3, HIGH );
        digitalWrite( in4, LOW );
         dl = 5;
    }else if(dl == 5){
        digitalWrite( in1, LOW );
        digitalWrite( in2, HIGH );
        digitalWrite( in3, HIGH );
        digitalWrite( in4, LOW );
        dl = 6;
    }else if(dl == 6){
        digitalWrite( in1, LOW );
        digitalWrite( in2, HIGH );
        digitalWrite( in3, HIGH );
        digitalWrite( in4, HIGH );
        dl = 7;
    }else if(dl == 7){
        digitalWrite( in1, LOW );
        digitalWrite( in2, LOW );
        digitalWrite( in3, HIGH );
        digitalWrite( in4, HIGH );
        dl = 8;
    }else if(dl == 8){
        digitalWrite( in1, HIGH );
        digitalWrite( in2, LOW );
        digitalWrite( in3, HIGH );
        digitalWrite( in4, HIGH );
        dl = 1;
    }
}

 

forfrends
Offline
Зарегистрирован: 24.02.2015

Кстати, если не делать побитовое чтение (pinValue = bitRead(bitmap[l*16+15-i], j) != 0 ? HIGH : LOW;), а присваивать случайное значение переменной (pinValue = !pinValue) то код работает нормально и печатается "сетка" из точек. А вот с побитовым чтением - никак.

Если есть мысли по оптимизации кода, то буду благодарен! А то печатает медленно.

andriano
andriano аватар
Онлайн
Зарегистрирован: 20.06.2015

Как Вы думаете, чему равен индекс в массиве при l=0 и i=47?

forfrends
Offline
Зарегистрирован: 24.02.2015

andriano, я вас понял. Как бы это исправить... Как только я пытаюсь в этом что-то менять, то печать прекращается (выходит пустая лента). Ок. Попробую оптимизировать.

b707
Онлайн
Зарегистрирован: 26.05.2017

forfrends пишет:

andriano, я вас понял. Как бы это исправить... Как только я пытаюсь в этом что-то менять, то печать прекращается (выходит пустая лента). Ок. Попробую оптимизировать.

причем тут "оптимизировать"?? - о какой оптимизации речь, когда вы лезете в отрицательные индексы массива? - у вас алгоритм печати совершенно неверно написан

Попробуйте обьяснить, что значат все эти вложенные циклы - один от 0 до78, другой до 48, третий до 12, четвертый до восьми... Вы что такое печатаете-то, у вас битмап из четырех измерений? :)

Всегда было достаточно только х и у

b707
Онлайн
Зарегистрирован: 26.05.2017

forfrends - ответил в той ветке