CRC8 / CRC16 which algorithm has to be used

[f41ardu]

Using the low level protocoll require calculation of crc8 and crc16.
Which algorithm has to be used?

Thanks in advance
f41ardu

 

[volate!lo]

check tellolib. It contains several bugs but should get you started.

 

[f41ardu]

check tellolib. It contains several bugs but should get you started.

I know, but need the algorithm used to implemet them using Python. I already transfered parts of tellolib into Processing (java like). Ugly to be honest, so I'm looking for the algorithm to get this implemented in Python.
For CRC16 i.e I have one (CRC-16/CCITT-FALSE ). But can this algorithm used?

 

[volate!lo]

Sorry I never used python so no clue

 

[newbiePilot]

Check out this python implementation, it uses a table with the _calcCRC8 function

TBL_CRC8 = [
0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41,
0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc,
0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62,
0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff,
0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07,
0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a,
0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24,
0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9,
0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd,
0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50,
0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee,
0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73,
0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b,
0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16,
0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8,
0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35,
]

 

[f41ardu]

Check out this python implementation, it uses a table with the _calcCRC8 function
......

Thanks,

tried pingusoft tellolib after conversion to Python3 but:

raise ImportError('You must be root to use this library on linux.')
ImportError: You must be root to use this library on linux.

So much work ahead to implement it in my pygame based code.

May take some time cause I'm working in several projects with much higher priority.


And to be honest conversion to bytes and bytes arrays is so much easier in Processing.

 

[newbiePilot]

Are you running in virtualenv?

 

[newbiePilot]

Pygame Implementation of Peggu's

import pygame
from pygame.locals import *

Global Vars

# Init pygame
pygame.init()

# Creat pygame window
pygame.display.set_caption("Video Feed")
screen = pygame.display.set_mode([960,720])

# create update timer
pygame.time.set_timer(USEREVENT + 1, 50)

Replace this with the original main:

###############################################################################
# main
###############################################################################
#print( 'Tello Controller                      '
#print( '+------------------------------------+'
#print( '|  ESC(quit) 1(360) 2(bounce)        |'
#print( '+------------------------------------+'
#print( '|                                    |'
#print( '|      w                   up        |'
#print( '|  a       d          left    right  |'
#print( '|      s                  down       |'
#print( '|                                    |'
#print( '|         space(takeoff/land)        |'
#print( '|                                    |'
#print( '+------------------------------------+'

mDrone = tello.Tello()
#keyboard.hook(handleKey)

while True:   
    for event in pygame.event.get():
        if event.type == USEREVENT + 1:
            update()
        elif event.type == QUIT:
            should_stop = True
        elif event.type == KEYDOWN:
            if event.key == K_ESCAPE:
                should_stop = True
            else:
                keydown(event.key)
        elif event.type == KEYUP:
            keyup(event.key)

The functions required:

def update():
    global mRCVal
    global mDrone
    """ Update routine. Send velocities to Tello."""
    mDrone.setStickData(0, mRCVal[IDX_ROLL], mRCVal[IDX_PITCH], mRCVal[IDX_THR], mRCVal[IDX_YAW])

def keydown(key):
    """ Update velocities based on key pressed
    Arguments:
        key: pygame key
    """
    global pygame
    global mRCVal
    
    if key == pygame.K_UP:  # set forward velocity
        mRCVal[IDX_PITCH] = RC_VAL_MAX
    elif key == pygame.K_DOWN:  # set backward velocity
        mRCVal[IDX_PITCH] = RC_VAL_MIN
    elif key == pygame.K_LEFT:  # set left velocity
        mRCVal[IDX_ROLL] = RC_VAL_MIN
    elif key == pygame.K_RIGHT:  # set right velocity
        mRCVal[IDX_ROLL] = RC_VAL_MAX
    elif key == pygame.K_w:  # set up velocity
        mRCVal[IDX_THR] = RC_VAL_MAX
    elif key == pygame.K_s:  # set down velocity
        mRCVal[IDX_THR] = RC_VAL_MIN
    elif key == pygame.K_a:  # set yaw clockwise velocity
        mRCVal[IDX_YAW] = RC_VAL_MIN
    elif key == pygame.K_d:  # set yaw counter clockwise velocity
        mRCVal[IDX_YAW] = RC_VAL_MAX
    elif key == pygame.K_1:  # set yaw counter clockwise velocity
        mDrone.setSmartVideoShot(tello.Tello.TELLO_SMART_VIDEO_360, True)
        print( 'SmartVideo 360 start')

def keyup(key):
    """ Update velocities based on key released
    Arguments:
        key: pygame key
    """
    global mDrone
    
    if key == pygame.K_UP or key == pygame.K_DOWN:  # set zero forward/backward velocity
        mRCVal[IDX_PITCH] = RC_VAL_MID
    elif key == pygame.K_LEFT or key == pygame.K_RIGHT:  # set zero left/right velocity
        mRCVal[IDX_ROLL] = RC_VAL_MID
    elif key == pygame.K_w or key == pygame.K_s:  # set zero up/down velocity
        mRCVal[IDX_THR] = RC_VAL_MID
    elif key == pygame.K_a or key == pygame.K_d:  # set zero yaw velocity
        mRCVal[IDX_YAW] = RC_VAL_MID
    elif key == pygame.K_t:  # takeoff
        mDrone.takeOff()
        print( 'take off')
    elif key == pygame.K_l:  # land
        mDrone.land()
        print( 'land')

 

[f41ardu]

Online CRC-8 CRC-16 CRC-32 Calculator

Neither of the show algorithm 7/18 show the same result as tellolib built crc's. Strange isn't it.
So I'll uses the crc calcs from tellolib.

But now I have a much simpler approach to create the telegrams send to Tello. Not finalised yet.
Who is interested to join the development?

We can collaborate using WebEX.