Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Generic boards that are not Maple or Maple mini clones, and don't contain the additional USB reset hardware
User avatar
martinayotte
Posts: 1241
Joined: Mon Apr 27, 2015 1:45 pm

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by martinayotte » Sun Jul 24, 2016 3:10 pm

What are the errors ?
(I've used them since awhile, but I don't remember if I had to tweak them and how, it should be pretty easy)

User avatar
Manny
Posts: 77
Joined: Wed Dec 09, 2015 3:15 pm

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by Manny » Sun Jul 24, 2016 6:50 pm

For the eeprom I think it was TWR not declared but I found this simple working library http://arduino.alhin.de/index.php?n=61
The SPI flash its SPIFlash.cpp:60:11: error: 'SPSR' was not declared in this scope _SPSR = SPSR;

TA
M

madias
Posts: 813
Joined: Mon Apr 27, 2015 11:26 am
Location: Vienna, Austria

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by madias » Sun Jul 24, 2016 7:26 pm

For the Winbond I posted a library a while ago:
viewtopic.php?f=13&t=9&p=10&hilit=winbond#p10
All you have to do is to change in the examples every
if(mem.begin(_W25Q64,SPI,10))
to W24Q16 (if it is a library example)
As I remember in the zip folder there are some example with and without library, but this should be easy.
For the I2c EEPROM I took any of the standard libraries for Arduino (Or did I wrote it myself from the datasheet? - can't remember) - so every "standard" I2c driven library should work. But you managed it already.

User avatar
martinayotte
Posts: 1241
Joined: Mon Apr 27, 2015 1:45 pm

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by martinayotte » Mon Jul 25, 2016 3:00 pm

Manny wrote:For the eeprom I think it was TWR not declared but I found this simple working library http://arduino.alhin.de/index.php?n=61
The SPI flash its SPIFlash.cpp:60:11: error: 'SPSR' was not declared in this scope _SPSR = SPSR;
I've look at the copies I have in my libs folder, I've simply comment out those guilty lines.

User avatar
Manny
Posts: 77
Joined: Wed Dec 09, 2015 3:15 pm

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by Manny » Mon Jul 25, 2016 10:47 pm

martinayotte wrote:
Manny wrote:For the eeprom I think it was TWR not declared but I found this simple working library http://arduino.alhin.de/index.php?n=61
The SPI flash its SPIFlash.cpp:60:11: error: 'SPSR' was not declared in this scope _SPSR = SPSR;
I've look at the copies I have in my libs folder, I've simply comment out those guilty lines.
Thanks will give it a try.


madias wrote:For the Winbond I posted a library a while ago:
viewtopic.php?f=13&t=9&p=10&hilit=winbond#p10
All you have to do is to change in the examples every
if(mem.begin(_W25Q64,SPI,10))
to W24Q16 (if it is a library example)
As I remember in the zip folder there are some example with and without library, but this should be easy.
For the I2c EEPROM I took any of the standard libraries for Arduino (Or did I wrote it myself from the datasheet? - can't remember) - so every "standard" I2c driven library should work. But you managed it already.
Had a quick go with that library, got it working ok, some examples don't seem to do much in the serial input sketch..will have a better look at it tomorrow.

TA
M

madias
Posts: 813
Joined: Mon Apr 27, 2015 11:26 am
Location: Vienna, Austria

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by madias » Tue Jul 26, 2016 12:45 pm

Ok, I see there are not all sketches in the zip.
Here are two of the latest examples I found: One with the use of the library and the other one without
Keep in mind you have to erase one sector before you can overwrite it. (Maybe you can read my infos (german))

Example with library:

Code: Select all

// ACHTUNG!!!! Immer zuerst den zu schreibenden Bereich vorher löschen, sonst Mist!!!!!
// löschen nur in Sektoren (4KB = 4096) möglich. d.h. immer 4096 Schritte einplanen oder zwischenpuffern
// Workaround: zuerst den Bereich, den man füllen möchte, mit 0xFF überschreiben? nicht geklappt


#include <SPI.h>
//#include <Metro.h>
#include "winbondflash.h"

winbondFlashSPI mem;

void setup()
{
  pinMode(10,OUTPUT);
    SPI.begin();
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV2);
  SPI.setDataMode(SPI_MODE0);
  Serial.begin(9600);
  Serial.println("InitWaitingChip...");
  delay(2000);
  Serial.println("Init Chip...");
  if(mem.begin(_W25Q64,SPI,10))
    Serial.println("OK");
  else
  {
    Serial.println("FAILED");
    while(1);
  }
}

void loop()
{
  if(Serial.available() > 0)
  {
    switch(Serial.read())
    {
    case 'R':
      {
        //R0,100
        Serial.print(F("Read "));
        int addr = Serial.parseInt();
        int len = Serial.parseInt();
        Serial.print(F("addr=0x"));
        Serial.print(addr>>8,HEX);
        Serial.print(addr,HEX);
        Serial.print(F(",len=0x"));
        Serial.print(len>>8,HEX);
        Serial.print(len,HEX);
        Serial.println(F(":"));
        uint8_t *buf = new uint8_t[len];
        while(mem.busy());
        mem.read(addr,buf,len);
        for(int i = 0;i < len; i++)
        {
          Serial.print((char)buf[i]);
        }
        Serial.println();
        Serial.println(F("OK"));
        delete [] buf;
      }
      break;
    case 'W':
      {
        //W0,test string[LF]
        //
        Serial.print(F("Write "));
        int addr = Serial.parseInt();
        Serial.print(F("0x"));
        Serial.print(addr>>8,HEX);
        Serial.print(addr,HEX);
        Serial.read();
        uint8_t buf[256];
       memset(buf,0,256);
        uint8_t len = Serial.readBytesUntil('\n',(char*)buf,256);
        Serial.print(F(",0x"));
        Serial.print(len>>8,HEX);
        Serial.print(len,HEX);
        Serial.print(F(": "));
        while(mem.busy());
      
        mem.WE();
        mem.writePage(addr,buf);
        Serial.println(F("OK"));
      }
      break;
    case 'E':
      while(Serial.available() < 1);
      char x = Serial.read();
      //Serial.print(x);
      switch(x)
      {
        int addr;
      case 'S':
        Serial.print(F("Erase Sector "));
        addr = Serial.parseInt();
        Serial.print(F("addr=0x"));
        Serial.print(addr>>8,HEX);
        Serial.print(addr,HEX);
        Serial.print(F(": "));
        mem.WE();
        mem.eraseSector(addr);
        Serial.println("OK");
        break;
      case 'b':
        Serial.print(F("Erase 32k Block "));
        addr = Serial.parseInt();
        Serial.print(F("addr=0x"));
        Serial.print(addr>>8,HEX);
        Serial.print(addr,HEX);
        Serial.print(F(": "));
        mem.WE();
        mem.erase32kBlock(addr);
        Serial.println("OK");
        break;
      case 'B':
        Serial.print(F("Erase 64k Block "));
        addr = Serial.parseInt();
        Serial.print(F("addr=0x"));
        Serial.print(addr>>8,HEX);
        Serial.print(addr,HEX);
        Serial.print(F(": "));
        mem.WE();
        mem.erase64kBlock(addr);
        Serial.println("OK");
        break;
      case 'A':
        while(mem.busy());
        mem.WE();
        mem.eraseAll();
        long ss = millis();
        while(mem.busy())
        {
          Serial.print(millis()-ss);
          delay(1000);
        }
        break;
      }

      /*
      if(Serial.read() == 'S')
       {
       //ES0
       Serial.print(F("Erase Sector "));
       int addr = Serial.parseInt();
       Serial.print(F("addr=0x"));
       Serial.print(addr>>8,HEX);
       Serial.print(addr,HEX);
       Serial.print(F(": "));
       mem.WE();
       mem.eraseSector(addr);
       Serial.println("OK");
       }
       break;
       */
    } 
  }
}
Example without library:

Code: Select all

// winbond W25Q64xxx test code, 
// original library: http://tinyurl.com/ptm98pw
// by WarMonkey (luoshumymail@gmail.com)
// stripped down for STM32-Arduino and translated from Japanese by Matthias Diro (29.03.2015)
// Pin 7 (HOLD) must be set HIGH (3.3V)
// ******** from Datasheet **********
/*
The W25Q64FV array is organized into 32,768 programmable pages of 256-bytes each. 
Up to 256 bytes can be programmed at a time. Pages can be erased in groups of 16 
(4KB sector erase), groups of 128 (32KB block erase), groups of 256 (64KB block erase) 
or the entire chip (chip erase). The W25Q64FV has 2,048 erasable sectors and 128 
erasable blocks respectively. The small 4KB sectors allow for greater flexibility 
in applications that require data and parameter storage.
*/

// rough translation (original: Japanese)
// SPI serial flash memory W25Q64 operation verification program
// W25Q64 memory area structure of
// Total number of bytes 8388608
// Memory space 24-bit addressing 0x00000 - 0x7FFFFF
// Block number 128 (64KB / block)
// Sector number 2048 (4KB / sector)
// Total number of sector 2048

#include <SPI.h>
//#include <string.h>
//#define ledpin 33
#define SPI_SLAVE_SEL_PIN    10     // chip select pin number
#define MAX_BLOCKSIZE        128    // total number of blocks
#define MAX_SECTORSIZE       2048   // total number of sectors

#define CMD_WRIRE_ENABLE      0x06
#define CMD_WRITE_DISABLE     0x04
#define CMD_READ_STATUS_R1    0x05
#define CMD_READ_STATUS_R2    0x35
#define CMD_WRITE_STATUS_R    0x01 // not implemented
#define CMD_PAGE_PROGRAM      0x02
#define CMD_QUAD_PAGE_PROGRAM 0x32 // not implemented
#define CMD_BLOCK_ERASE64KB   0xd8
#define CMD_BLOCK_ERASE32KB   0x52
#define CMD_SECTOR_ERASE      0x20
#define CMD_CHIP_ERASE        0xC7 // not implemented
#define CMD_ERASE_SUPPEND     0x75 // not implemented
#define CMD_ERASE_RESUME      0x7A // not implemented
#define CMD_POWER_DOWN        0xB9
#define CMD_HIGH_PERFORM_MODE 0xA3 // not implemented
#define CMD_CNT_READ_MODE_RST 0xFF // not implemented
#define CMD_RELEASE_PDOWN_ID  0xAB // not implemented
#define CMD_MANUFACURER_ID    0x90
#define CMD_READ_UNIQUE_ID    0x4B
#define CMD_JEDEC_ID          0x9f

#define CMD_READ_DATA         0x03
#define CMD_FAST_READ         0x0B
#define CMD_READ_DUAL_OUTPUT  0x3B // not implemented
#define CMD_READ_DUAL_IO      0xBB // not implemented
#define CMD_READ_QUAD_OUTPUT  0x6B // not implemented
#define CMD_READ_QUAD_IO      0xEB // not implemented
#define CMD_WORD_READ         0xE3 // not implemented

#define SR1_BUSY_MASK	0x01
#define SR1_WEN_MASK	0x02

void setup() {
    byte buf[256];        // get data
    byte wdata[256];       // write data
    
    uint16_t n;           // number of acquired data
        Serial.begin(9600);
        delay(2000);
        Serial.println("Test in 2 seconds");
        delay(2000);
        Serial.println("Test starts");
    W25Q64_begin();        // Flash memory utilization start

    
    // Acquisition test of // JEDEC ID
    readManufacturer(buf);
    Serial.print("JEDEC ID : ");
    for (byte i=0; i< 3; i++) {
      Serial.print(buf[i],HEX);
      Serial.print(" ");
    }
    Serial.println("");
    
    // Acquisition test of Unique ID
    readUniqieID(buf);
    Serial.print("Unique ID : ");
    for (byte i=0; i< 7; i++) {
      Serial.print(buf[i],HEX);
      Serial.print(" ");
    }
    Serial.println("");
    
    // Reading of data (from address 0 to 256 bytes acquisition)
    memset(buf,0,256);
    n =  read(0,buf, 256);
    Serial.print("Read Data: n=");
    Serial.println(n,DEC);
    dump(buf,256);

    // Read of the high-speed data (from address 0 to 256 bytes acquisition)
    memset(buf,0,256);
    n =  fastread(0,buf, 256);
    Serial.print("Fast Read Data: n=");
    Serial.println(n,DEC);
    dump(buf,256);

    // Delete the sector unit
    n = eraseSector(0,true);
    Serial.print("Erase Sector(0): n=");
    Serial.println(n,DEC);
    memset(buf,0,256);
    n =  read (0,buf, 256);
    dump(buf,256);
 
    // Data writing test
    for (byte i=0; i < 255;i++) {
      wdata[i]= i;
    }  
    n =  page_write(0, 0, wdata, 255);
    Serial.print("page_write(0,0,d,16): n=");
    Serial.println(n,DEC);
    memset(buf,0,256);
    n =  read (0,buf, 256);
    dump(buf,256);

    // Acquisition of status register 1
    buf[0] = readStatusReg1();
    Serial.print("Status Register-1: ");
    Serial.print(buf[0],BIN);
    Serial.println("");

    // Acquisition of status register 2
    buf[0] = readStatusReg2();
    Serial.print("Status Register-2: ");
    Serial.print(buf[0],BIN);
    Serial.println("");
}

//
// Use the start of the flash memory W25Q64
// 
void W25Q64_begin() {
    pinMode (SPI_SLAVE_SEL_PIN, OUTPUT);
    SPI.begin();
    SPI.setClockDivider(SPI_CLOCK_DIV2);
   SPI.setBitOrder(MSBFIRST);
  SPI.setDataMode(SPI_MODE0);
    deselect();
}

//
// Use the end of the flash memory W25Q64
// 
void W25Q64_end() {
  powerDown();
   SPI.end();
}

//
// Chip select
// I want to select a flash memory operation
//
void select() {
   digitalWrite(SPI_SLAVE_SEL_PIN, LOW); 
}

//
// Chip deselected
// I make a flash memory operation to Yuhi selection
//
void deselect() {
   digitalWrite(SPI_SLAVE_SEL_PIN, HIGH); 
}

//
// Values obtained in the status register 1
// Returns: status register value of 1
//
byte readStatusReg1() {
  byte rc;
  select();
  SPI.transfer(CMD_READ_STATUS_R1);
  rc = SPI.transfer(0xFF);
  deselect();
  return rc;
}

//
//Values obtained in the status register 2
//  Returns: status register 2 of value
//
byte readStatusReg2() {
  byte rc;
  select();
  SPI.transfer(CMD_READ_STATUS_R2);
  rc = SPI.transfer(0xFF);
  deselect();
  return rc;
}

//
// Acquisition of JEDEC ID(Manufacture, Memory Type,Capacity)
// d (out): Manufacture, Memory Type, store the 3 bytes of Capacity
//
void readManufacturer(byte* d) {
  select();
  SPI.transfer(CMD_JEDEC_ID);
  for (byte i =0; i <3; i++) {
    d[i] = SPI.transfer(0x00);
  } 
  deselect();
}

//
// Acquisition of Unique ID
// d (out):  returns the Unique ID 7 bytes
//
void readUniqieID(byte* d) {
  select();
  SPI.transfer(CMD_READ_UNIQUE_ID);
  SPI.transfer(0x00);
  SPI.transfer(0x00);
  SPI.transfer(0x00);
  SPI.transfer(0x00);
  for (byte i =0; i <7; i++) {
    d[i] = SPI.transfer(0x00);
  }
 deselect(); 
}

//
// During the processing of writing such as check
// Return Value: true: work, false: in idle
//
boolean IsBusy() {
  uint8_t r1;
  select();
  SPI.transfer(CMD_READ_STATUS_R1);
  r1 = SPI.transfer(0xff);
  deselect();
  if(r1 & SR1_BUSY_MASK)
    return true;
  return false;
}

//
// Power down the specified 
//
void powerDown() {
  select();
  SPI.transfer(CMD_POWER_DOWN);
  deselect();
}

//
// Write permission settings
//
void WriteEnable() {
  select();
  SPI.transfer(CMD_WRIRE_ENABLE);
  deselect();
}

//
// Write-protect setting
//
void WriteDisable() {
  select();
  SPI.transfer(CMD_WRITE_DISABLE);
  deselect();
}

//
// Reading data
// addr (in): read start address (24 bits 0x00000 - 0xFFFFF)
// n (in): the number of read data
//
uint16_t read(uint32_t addr,uint8_t *buf,uint16_t n){ 
  select();
  SPI.transfer(CMD_READ_DATA);
  SPI.transfer(addr>>16);          // A23-A16
  SPI.transfer((addr>>8) & 0xFF);  // A15-A08
  SPI.transfer(addr & 0xFF);       // A07-A00
 
  uint16_t i;
  for(i = 0; i<n; i++ ) {
    buf[i] = SPI.transfer(0x00);
  }
  
  deselect();
  return i;
}

//
// Read of the high-speed data
// addr (in): read start address (24 bits 0x00000 - 0xFFFFF)
// n (in): the number of read data
//
uint16_t fastread(uint32_t addr,uint8_t *buf,uint16_t n) {
  select();
  SPI.transfer(CMD_FAST_READ);
  SPI.transfer(addr>>16);          // A23-A16
  SPI.transfer((addr>>8) & 0xFF);  // A15-A08
  SPI.transfer(addr & 0xFF);       // A07-A00
  SPI.transfer(0x00);              // dummy
  
  uint16_t i;
  for(i = 0; i<n; i++) {
    buf[i] = SPI.transfer(0x00);
  }
  
  deselect();  
  return i;
}

//
// Erase sector units (erases the data in 4kb space units)
// sect_no (in) sector number (0 - 2048)
// flgwait(in) true:waits to be processed false:No wait
// Return value: true:Successful completion false:Failure
//  Note: in the data sheet is described as normally takes 30ms, 400ms maximum erasure
//         Significant 11 bits of the address 23-bit corresponds sector number. Lower 12 bits is the sector in the address.
//
boolean eraseSector(uint16_t sect_no, boolean flgwait) {
 uint32_t addr = sect_no;
 addr<<=12;

 WriteEnable();
 select(); 
 SPI.transfer(CMD_SECTOR_ERASE);
 SPI.transfer((addr>>16) & 0xff);
 SPI.transfer((addr>>8) & 0xff);
 SPI.transfer(addr & 0xff);
 deselect();
 
 // 処理待ち
 while(IsBusy() & flgwait) {
    delay(10);
 }
 
 return true;
}

//
// 64KB block erase (erasing the data in the 64kb space units)
// blk_no (in) block number (0 - 127)
// flgwait(in) true:waiting to be processed false: no wait
// Return value: true:Successful completion false:Failure
//   Note: in the data sheet is described as normally takes 150ms, 1000ms maximum erasure
//         Upper 7 bits of the address 23-bit is equivalent of block. Lower 16 bits will be block address.
//
boolean erase64Block(uint16_t blk_no, boolean flgwait) {
 uint32_t addr = blk_no;
 addr<<=16;

 WriteEnable();
 select(); 
 SPI.transfer(CMD_BLOCK_ERASE64KB);
 SPI.transfer((addr>>16) & 0xff);
 SPI.transfer((addr>>8) & 0xff);
 SPI.transfer(addr & 0xff);
 deselect();
 
 // 処理待ち
 while(IsBusy() & flgwait) {
    delay(50);
 }
 
 return true;
}


//
// (erasing the data in the 32kb space units) 32KB block erase
// Blk_no (in) block number (0 - 255)
// Flgwait (in) true: false perform a process waiting: waiting None
// Return value: true: successful completion false: failure
// Note: in the data sheet it has been described as usually takes 120ms, 800ms maximum to erase
// Upper 8 bits of the address 23-bit corresponds to block. Lower 15 bits is the block address.
boolean erase32Block(uint16_t blk_no, boolean flgwait) {

 uint32_t addr = blk_no;
 addr<<=15;

 WriteEnable();  
 select(); 
 SPI.transfer(CMD_BLOCK_ERASE32KB);
 SPI.transfer((addr>>16) & 0xff);
 SPI.transfer((addr>>8) & 0xff);
 SPI.transfer(addr & 0xff);
 deselect();
 
 // Waiting to be processed
 while(IsBusy() & flgwait) {
    delay(50);
 }
 
 return true;
}

//
// 全領域の消去
// flgwait(in) true:処理待ちを行う false:待ち無し
// 戻り値: true:正常終了 false:失敗
//   補足: データシートでは消去に通常 15s 、最大30sかかると記載されている

// Erase of the entire region
// Flgwait (in) true: false perform a process waiting: waiting None
// Return value: true: successful completion false: failure
// Note: in the data sheets are described as normally takes 15s, 30s up to the clear
//
boolean eraseAll(boolean flgwait) {
 WriteEnable();  
 select(); 
 SPI.transfer(CMD_CHIP_ERASE);
 deselect();

 // Waiting to be processed
 while(IsBusy() & flgwait) {
    delay(500);
 }
 
 deselect();
 return true;
}

//
// Writing of data
// Sect_no (in): sector number (0x00 - 0x7FF)
// Inaddr (in): sector in the address (0x00-0xFFF)
// Data (in): write data storage address
// N (in): the number of bytes written (0-256)
//
uint16_t page_write(uint16_t sect_no, uint16_t inaddr, byte* data, byte n) {

  uint32_t addr = sect_no;
  int i;
  addr<<=12;
  addr += inaddr;

  WriteEnable();  
  
  if (IsBusy()) {
    return 0;  
  }

  select();
  SPI.transfer(CMD_PAGE_PROGRAM);
  SPI.transfer((addr>>16) & 0xff);
  SPI.transfer((addr>>8) & 0xff);
  SPI.transfer(addr & 0xff);

  for (i=0; i < n; i++) {
    SPI.transfer(data[i]);
  }  
  deselect();
  while(IsBusy()) ;
  
  return i;
}

//
// Dump list of write data
// Dt (in): data storage start address
// N (in): the number of display data
void dump(byte *dt, int n) {
  unsigned long sz;
  char buf[64];
  int clm = 0;
  byte data;
  byte sum;
  byte vsum[16];
  byte total =0;
  int saddr =0;
  int eaddr =n-1;
  sz = eaddr -saddr;
  
  Serial.println("----------------------------------------------------------");
  
  for (int i=0;i<16;i++) vsum[i]=0;  
  for (unsigned long addr = saddr; addr <= eaddr; addr++) {
    data = dt[addr];
    if (clm == 0) {
      sum =0;
      sprintf(buf,"%05lx: ",addr);
      Serial.print(buf);
    }

    sum+=data;
    vsum[addr % 16]+=data;
    
    sprintf(buf,"%02x ",data);
    Serial.print(buf);
    clm++;
    if (clm == 16) {
      sprintf(buf,"|%02x ",sum);
      Serial.print(buf);      
      Serial.println("");
      clm = 0;
    }    
  }
  Serial.println("----------------------------------------------------------");
  Serial.print("       ");
  for (int i=0; i<16;i++) {
    total+=vsum[i];
    sprintf(buf,"%02x ",vsum[i]);
    Serial.print(buf);
  }
  sprintf(buf,"|%02x ",total);
  Serial.print(buf);      
  Serial.println("");
  Serial.println("");
}

void loop() {

}

BlackBrix
Posts: 31
Joined: Wed Dec 06, 2017 7:49 am

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by BlackBrix » Wed Jan 03, 2018 4:36 pm

when I first saw this thread some weeks ago,
I was excited about this board, cause it seems to be versatile and it seemed to meet my requirements for a daily development device for testing purposes and so on...

I ordered it on aliexpress (9€) but what finally I got yesterday looks a little different but not so bad at all:
(If not already known here in the forum ...)

Image


you can see that compared to madias board is has some new/different features:
  • different name: CZ miniSTM32F103VE-EK (instead of CZ miniSTM32F103V_-EK) :mrgreen:
  • additional SD-Card Reader :o
  • additional socket for ESP-01 Wifi-Module
  • additional socket for nRF24L01-Module (2.4GHz ISM Transceiver)
  • two user buttons on different ports now: PE3, PC5 (moved as well to different locations now)
  • a more 'modern' RTC-crystal in plastic SMD package
  • different serial I²C EEPROM 24C04 (512 Byte) (instead of 24C02)
  • different / smaller RS485 connector space holder
  • no inner mounting holes
  • slightly larger Board size : 104.7 mm x 76.8 mm (instead of 101.5 mm x 76.68 mm)

the rest of the board seems to be the same:
  • MCU: STM32F103VET6
  • power on/off switch
  • reset button (moved to different location now)
  • Boot0 and Boot1 jumper
  • jumpers (RX,TX) for the USB-Serial converter
  • VREF jumper
  • 2x USB one with CH340 RS232-USB-converter chip (“Serial1”)
  • 32.768kHz and 8Mhz crystals on board
  • CR1220 battery holder
  • Two controllable LED: PE5, PE6
  • power indicator LED (moved to slightly different location now)
  • JTAG / SWD 20 -pin standard interface
  • 32 foot FSMC TFT LCD screen interface
  • SPI flash W25q16
  • space holder for 485 IC
  • space holder for DS18B20 (moved to slightly different location now)
  • space holder for HS0038
Last edited by BlackBrix on Wed Jan 03, 2018 5:15 pm, edited 5 times in total.

zmemw16
Posts: 1687
Joined: Wed Jul 08, 2015 2:09 pm
Location: St Annes, Lancs,UK

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by zmemw16 » Wed Jan 03, 2018 5:08 pm

there are many variations of this beast, certainly in the previous iterations be that tft plug/socket, sdcard or not etc, etc

i have the one in the image, x3 actually
if you look back in the thread there are details of the esp8266 and nrf24 connectors
i'm still trying 'drive' these boards :D
i also have the zet variant, all of tft, nrf24 & esp8266 as well :D
stephen

BlackBrix
Posts: 31
Joined: Wed Dec 06, 2017 7:49 am

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by BlackBrix » Wed Jan 03, 2018 5:18 pm

zmemw16 wrote:
Wed Jan 03, 2018 5:08 pm
if you look back in the thread there are details of the esp8266 and nrf24 connectors
could not find it in this thread, can you post a link please.
zmemw16 wrote:
Wed Jan 03, 2018 5:08 pm
i also have the zet variant, all of tft, nrf24 & esp8266 as well :D
do you have a picture of the 'zet' variant ?

zmemw16
Posts: 1687
Joined: Wed Jul 08, 2015 2:09 pm
Location: St Annes, Lancs,UK

Re: Review: CZ mini STM32F103VET6 (infos, documents, BL…)

Post by zmemw16 » Thu Jan 04, 2018 11:19 am

wrong thread, this one
viewtopic.php?f=28&t=2913&hilit=esp8266

this one starts at the pictures i posted
viewtopic.php?f=28&t=2913&hilit=esp8266#p37809

the details just happen to be still in my Notes app

Code: Select all

ESP-1 WIFI module
Pin PC3 --- Reset
Pin PA0 --- CH_PD
Pin PB11 --- ESP RX
Pin PB10 --- ESP TX
Pin PC1 --- GPIO 0
Pin PC0 --- GPIO 2

NRF24L01 wireless module
Pin PE2
Pin PB5
Pin PC13
Pin PE4
Pin PB3
Pin PB4
easiest way to differentiate is that the VE is mounted square whilst the ZE is rotated 45deg.
it's also way, way physically bigger, pin count is also way, way up 144? as well

stephen

Post Reply